@upstart.gg/vite-plugins 0.0.38 → 0.0.40

package/src/tests/upstart-editor-api.test.ts

@@ -22,201 +22,117 @@ describe("UpstartEditorAPI", () => {
   });
 
   describe("editText", () => {
-    test("should edit text content at correct offset", async () => {
-      // Create a test source file
-      const sourceContent = `<div>Hello World</div>`;
-      const sourcePath = path.join(tempDir, "test.tsx");
-      await fs.writeFile(sourcePath, sourceContent);
-
-      // Create registry
-      const registry: EditableRegistry = {
-        version: 1,
-        generatedAt: new Date().toISOString(),
-        elements: {
-          "test.tsx:1": {
-            file: "test.tsx",
-            type: "text",
-            startOffset: 5,
-            endOffset: 16,
-            originalContent: "Hello World",
-            context: { parentTag: "div" },
-          },
-        },
-      };
-      await fs.writeFile(registryPath, JSON.stringify(registry));
-
-      // Edit the text
-      const result = await api.editText("test.tsx:1", "Hello Universe");
+    async function writeLocaleFile(language: string, namespace: string, data: Record<string, unknown>) {
+      const dir = path.join(tempDir, "app", "locales", language);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(path.join(dir, `${namespace}.json`), JSON.stringify(data, null, 2) + "\n");
+    }
+
+    async function readLocaleFile(language: string, namespace: string) {
+      const content = await fs.readFile(
+        path.join(tempDir, "app", "locales", language, `${namespace}.json`),
+        "utf-8",
+      );
+      return JSON.parse(content);
+    }
+
+    test("should update a flat key in a locale file", async () => {
+      await writeLocaleFile("en", "translation", { greeting: "Hello" });
+
+      const result = await api.editText({
+        action: "editText",
+        language: "en",
+        namespace: "translation",
+        key: "greeting",
+        content: "Hi",
+      });
 
       expect(result.success).toBe(true);
-
-      // Verify file was updated
-      const updatedContent = await fs.readFile(sourcePath, "utf-8");
-      expect(updatedContent).toBe("<div>Hello Universe</div>");
+      const data = await readLocaleFile("en", "translation");
+      expect(data.greeting).toBe("Hi");
     });
 
-    test("should update registry after edit", async () => {
-      const sourceContent = `<div>Original</div>`;
-      const sourcePath = path.join(tempDir, "test.tsx");
-      await fs.writeFile(sourcePath, sourceContent);
+    test("should update a flat dotted key when it exists", async () => {
+      await writeLocaleFile("en", "translation", { "nav.home": "Home" });
 
-      const registry: EditableRegistry = {
-        version: 1,
-        generatedAt: new Date().toISOString(),
-        elements: {
-          "test.tsx:1": {
-            file: "test.tsx",
-            type: "text",
-            startOffset: 5,
-            endOffset: 13,
-            originalContent: "Original",
-            context: { parentTag: "div" },
-          },
-        },
-      };
-      await fs.writeFile(registryPath, JSON.stringify(registry));
-
-      await api.editText("test.tsx:1", "Modified");
+      const result = await api.editText({
+        action: "editText",
+        language: "en",
+        namespace: "translation",
+        key: "nav.home",
+        content: "Dashboard",
+      });
 
-      // Read updated registry
-      const updatedRegistry = JSON.parse(await fs.readFile(registryPath, "utf-8"));
-      expect(updatedRegistry.elements["test.tsx:1"].originalContent).toBe("Modified");
+      expect(result.success).toBe(true);
+      const data = await readLocaleFile("en", "translation");
+      expect(data["nav.home"]).toBe("Dashboard");
     });
 
-    test("should shift subsequent offsets after edit", async () => {
-      const sourceContent = `<div>First</div><span>Second</span>`;
-      const sourcePath = path.join(tempDir, "test.tsx");
-      await fs.writeFile(sourcePath, sourceContent);
-
-      const registry: EditableRegistry = {
-        version: 1,
-        generatedAt: new Date().toISOString(),
-        elements: {
-          "test.tsx:1": {
-            file: "test.tsx",
-            type: "text",
-            startOffset: 5,
-            endOffset: 10,
-            originalContent: "First",
-            context: { parentTag: "div" },
-          },
-          "test.tsx:2": {
-            file: "test.tsx",
-            type: "text",
-            startOffset: 22,
-            endOffset: 28,
-            originalContent: "Second",
-            context: { parentTag: "span" },
-          },
-        },
-      };
-      await fs.writeFile(registryPath, JSON.stringify(registry));
-
-      // Edit first element (adding 5 characters: "First" -> "First!!!!!")
-      await api.editText("test.tsx:1", "First!!!!!");
+    test("should update a nested key via dot notation", async () => {
+      await writeLocaleFile("en", "translation", { nav: { home: "Home", about: "About" } });
 
-      // Read updated registry
-      const updatedRegistry = JSON.parse(await fs.readFile(registryPath, "utf-8"));
+      const result = await api.editText({
+        action: "editText",
+        language: "en",
+        namespace: "translation",
+        key: "nav.home",
+        content: "Dashboard",
+      });
 
-      // Second element offset should have shifted by 5
-      expect(updatedRegistry.elements["test.tsx:2"].startOffset).toBe(27);
-      expect(updatedRegistry.elements["test.tsx:2"].endOffset).toBe(33);
+      expect(result.success).toBe(true);
+      const data = await readLocaleFile("en", "translation");
+      expect(data.nav.home).toBe("Dashboard");
+      expect(data.nav.about).toBe("About");
     });
 
-    test("should fail if element not found", async () => {
-      const registry: EditableRegistry = {
-        version: 1,
-        generatedAt: new Date().toISOString(),
-        elements: {},
-      };
-      await fs.writeFile(registryPath, JSON.stringify(registry));
-
-      const result = await api.editText("nonexistent:1", "New text");
+    test("should fail if locale file does not exist", async () => {
+      const result = await api.editText({
+        action: "editText",
+        language: "fr",
+        namespace: "translation",
+        key: "greeting",
+        content: "Bonjour",
+      });
 
       expect(result.success).toBe(false);
-      expect(result.error).toContain("not found");
+      expect(result.error).toContain("Failed to read locale file");
     });
 
-    test("should fail if element is not text type", async () => {
-      const registry: EditableRegistry = {
-        version: 1,
-        generatedAt: new Date().toISOString(),
-        elements: {
-          "test.tsx:1": {
-            file: "test.tsx",
-            type: "className",
-            startOffset: 5,
-            endOffset: 10,
-            originalContent: "px-4",
-            context: { parentTag: "div" },
-          },
-        },
-      };
-      await fs.writeFile(registryPath, JSON.stringify(registry));
+    test("should fail if key does not exist", async () => {
+      await writeLocaleFile("en", "translation", { greeting: "Hello" });
 
-      const result = await api.editText("test.tsx:1", "New text");
+      const result = await api.editText({
+        action: "editText",
+        language: "en",
+        namespace: "translation",
+        key: "farewell",
+        content: "Bye",
+      });
 
       expect(result.success).toBe(false);
-      expect(result.error).toContain("not a text element");
+      expect(result.error).toContain("not found");
     });
 
-    test("should find content by search if offset has shifted", async () => {
-      // Simulate a file where content has shifted (e.g., due to manual edit)
-      const sourceContent = `\n\n<div>Hello World</div>`;
-      const sourcePath = path.join(tempDir, "test.tsx");
-      await fs.writeFile(sourcePath, sourceContent);
-
-      // Registry has old offsets (before the newlines were added)
-      const registry: EditableRegistry = {
-        version: 1,
-        generatedAt: new Date().toISOString(),
-        elements: {
-          "test.tsx:1": {
-            file: "test.tsx",
-            type: "text",
-            startOffset: 5, // Old offset (now content is at offset 7)
-            endOffset: 16,
-            originalContent: "Hello World",
-            context: { parentTag: "div" },
-          },
-        },
-      };
-      await fs.writeFile(registryPath, JSON.stringify(registry));
-
-      // Should still find and edit the content
-      const result = await api.editText("test.tsx:1", "Hello Universe");
+    test("should preserve other keys in the file", async () => {
+      await writeLocaleFile("en", "translation", {
+        greeting: "Hello",
+        farewell: "Goodbye",
+        title: "Welcome",
+      });
+
+      const result = await api.editText({
+        action: "editText",
+        language: "en",
+        namespace: "translation",
+        key: "greeting",
+        content: "Hi",
+      });
 
       expect(result.success).toBe(true);
-
-      const updatedContent = await fs.readFile(sourcePath, "utf-8");
-      expect(updatedContent).toBe("\n\n<div>Hello Universe</div>");
-    });
-
-    test("should fail if original content no longer exists", async () => {
-      const sourceContent = `<div>Completely Different</div>`;
-      const sourcePath = path.join(tempDir, "test.tsx");
-      await fs.writeFile(sourcePath, sourceContent);
-
-      const registry: EditableRegistry = {
-        version: 1,
-        generatedAt: new Date().toISOString(),
-        elements: {
-          "test.tsx:1": {
-            file: "test.tsx",
-            type: "text",
-            startOffset: 5,
-            endOffset: 16,
-            originalContent: "Hello World",
-            context: { parentTag: "div" },
-          },
-        },
-      };
-      await fs.writeFile(registryPath, JSON.stringify(registry));
-
-      const result = await api.editText("test.tsx:1", "New content");
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("not found in file");
+      const data = await readLocaleFile("en", "translation");
+      expect(data.greeting).toBe("Hi");
+      expect(data.farewell).toBe("Goodbye");
+      expect(data.title).toBe("Welcome");
     });
   });
 
@@ -242,7 +158,11 @@ describe("UpstartEditorAPI", () => {
       };
       await fs.writeFile(registryPath, JSON.stringify(registry));
 
-      const result = await api.editClassName("test.tsx:1", "px-8 py-4 bg-blue-500");
+      const result = await api.editClassName({
+        action: "editClassName",
+        id: "test.tsx:1",
+        className: "px-8 py-4 bg-blue-500",
+      });
 
       expect(result.success).toBe(true);
 
@@ -267,7 +187,11 @@ describe("UpstartEditorAPI", () => {
       };
       await fs.writeFile(registryPath, JSON.stringify(registry));
 
-      const result = await api.editClassName("test.tsx:1", "new-class");
+      const result = await api.editClassName({
+        action: "editClassName",
+        id: "test.tsx:1",
+        className: "new-class",
+      });
 
       expect(result.success).toBe(false);
       expect(result.error).toContain("not a className element");