feat: json sorting (#435)

* feat: preserve newlines, whitespaces while formatting

* fix: fix broken imports

* refactor: refactored newline loader

* feat(cli): json sorting

* test: add test

Author: maxprilutskiy

.changeset/fresh-kings-allow.md

@@ -0,0 +1,5 @@
+---
+"lingo.dev": minor
+---
+
+preserve newlines, whitespaces while formatting

.changeset/fuzzy-terms-kick.md

@@ -0,0 +1,5 @@
+---
+"lingo.dev": minor
+---
+
+add json sorting

packages/cli/src/cli/loaders/index.spec.ts

@@ -655,54 +655,94 @@ user.password=Contraseña
       expect(data).toEqual(expectedOutput);
     });
 
-    it("should save xcode-xcstrings", async () => {
+    it("should save xcode-xcstrings with alphabetically sorted keys", async () => {
       setupFileMocks();
 
       const input = `
 {
   "sourceLanguage" : "en",
   "strings" : {
-    "greeting" : {
+    "zebra" : {
       "extractionState" : "manual",
       "localizations" : {
         "en" : {
           "stringUnit" : {
             "state" : "translated",
-            "value" : "Hello!",
-          },
-        },
-      },
+            "value" : "Zebra"
+          }
+        }
+      }
     },
+    "apple" : {
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Apple"
+          }
+        },
+        "zh" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "苹果"
+          }
+        }
+      }
+    }
   },
   "version" : "1.0"
-}
-      `.trim();
-      const payload = { greeting: "¡Hola!" };
-      const expectedOutput = `
-{
+}`.trim();
+      const payload = {
+        zebra: "Cebra",
+        apple: "Manzana",
+      };
+      const expectedOutput = `{
   "sourceLanguage" : "en",
   "strings" : {
-    "greeting" : {
+    "apple" : {
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Apple"
+          }
+        },
+        "es" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Manzana"
+          }
+        },
+        "zh" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "苹果"
+          }
+        }
+      }
+    },
+    "zebra" : {
       "extractionState" : "manual",
       "localizations" : {
         "en" : {
           "stringUnit" : {
             "state" : "translated",
-            "value" : "Hello!"
+            "value" : "Zebra"
           }
         },
         "es" : {
           "stringUnit" : {
             "state" : "translated",
-            "value" : "¡Hola!"
+            "value" : "Cebra"
           }
         }
       }
     }
   },
   "version" : "1.0"
-}
-      `.trim();
+}`.trim();
 
       mockFileOperations(input);
 

packages/cli/src/cli/loaders/index.ts

@@ -28,6 +28,7 @@ import createVariableLoader from "./variable";
 import createSyncLoader from "./sync";
 import createPlutilJsonTextLoader from "./plutil-json-loader";
 import createNewLineLoader from "./new-line";
+import createJsonSortingLoader from "./json-sorting";
 
 export default function createBucketLoader(
   bucketType: Z.infer<typeof bucketTypeSchema>,
@@ -123,6 +124,7 @@ export default function createBucketLoader(
         createNewLineLoader(),
         createPlutilJsonTextLoader(),
         createJsonLoader(),
+        createJsonSortingLoader(),
         createXcodeXcstringsLoader(),
         createFlatLoader(),
         createSyncLoader(),

packages/cli/src/cli/loaders/json-sorting.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect } from "vitest";
+
+import createJsonSortingLoader from "./json-sorting";
+
+describe("JSON Sorting Loader", () => {
+  const loader = createJsonSortingLoader();
+  loader.setDefaultLocale("en");
+
+  describe("pull", () => {
+    it("should return input unchanged", async () => {
+      const input = { b: 1, a: 2 };
+      const result = await loader.pull("en", input);
+      expect(result).toEqual(input);
+    });
+  });
+
+  describe("push", () => {
+    it("should sort object keys at root level", async () => {
+      const input = { zebra: 1, apple: 2, banana: 3 };
+      const expected = { apple: 2, banana: 3, zebra: 1 };
+
+      const result = await loader.push("en", input);
+      expect(result).toEqual(expected);
+    });
+
+    it("should sort nested object keys", async () => {
+      const input = {
+        b: {
+          z: 1,
+          y: 2,
+          x: 3,
+        },
+        a: 1,
+      };
+      const expected = {
+        a: 1,
+        b: {
+          x: 3,
+          y: 2,
+          z: 1,
+        },
+      };
+
+      const result = await loader.push("en", input);
+      expect(result).toEqual(expected);
+    });
+
+    it("should handle arrays by sorting their object elements", async () => {
+      const input = {
+        items: [
+          { b: 1, a: 2 },
+          { d: 3, c: 4 },
+        ],
+      };
+      const expected = {
+        items: [
+          { a: 2, b: 1 },
+          { c: 4, d: 3 },
+        ],
+      };
+
+      const result = await loader.push("en", input);
+      expect(result).toEqual(expected);
+    });
+
+    it("should handle mixed nested structures", async () => {
+      const input = {
+        zebra: [
+          { beta: 2, alpha: 1 },
+          { delta: 4, gamma: 3 },
+        ],
+        apple: {
+          two: 2,
+          one: 1,
+        },
+      };
+      const expected = {
+        apple: {
+          one: 1,
+          two: 2,
+        },
+        zebra: [
+          { alpha: 1, beta: 2 },
+          { delta: 4, gamma: 3 },
+        ],
+      };
+
+      const result = await loader.push("en", input);
+      expect(result).toEqual(expected);
+    });
+
+    it("should handle null and primitive values", async () => {
+      const input = {
+        c: null,
+        b: "string",
+        a: 123,
+        d: true,
+      };
+      const expected = {
+        a: 123,
+        b: "string",
+        c: null,
+        d: true,
+      };
+
+      const result = await loader.push("en", input);
+      expect(result).toEqual(expected);
+    });
+  });
+});

packages/cli/src/cli/loaders/json-sorting.ts

@@ -0,0 +1,30 @@
+import { ILoader } from "./_types";
+import { createLoader } from "./_utils";
+
+export default function createJsonSortingLoader(): ILoader<Record<string, any>, Record<string, any>> {
+  return createLoader({
+    async pull(locale, input) {
+      return input;
+    },
+    async push(locale, data, originalInput) {
+      return sortObjectDeep(data);
+    },
+  });
+}
+
+function sortObjectDeep(obj: any): any {
+  if (Array.isArray(obj)) {
+    return obj.map(sortObjectDeep);
+  }
+
+  if (obj !== null && typeof obj === "object") {
+    return Object.keys(obj)
+      .sort()
+      .reduce((result: any, key) => {
+        result[key] = sortObjectDeep(obj[key]);
+        return result;
+      }, {});
+  }
+
+  return obj;
+}