@upstart.gg/vite-plugins 0.0.38 → 0.0.40

package/src/tests/vite-plugin-upstart-branding.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "vitest";
+import { upstartBranding } from "../vite-plugin-upstart-branding/plugin";
+import type { UpstartBrandingPluginOptions } from "../vite-plugin-upstart-branding/types";
+
+const MAIN_ID = "/project/src/entry.client.tsx";
+const OTHER_ID = "/project/src/other.tsx";
+
+type BrandingPlugin = {
+  name?: string;
+  transform?: ((code: string, id: string) => unknown) | { handler: (code: string, id: string) => unknown };
+};
+
+function getPlugin(options: UpstartBrandingPluginOptions): BrandingPlugin {
+  const plugin = upstartBranding.vite(options) as unknown;
+  return (Array.isArray(plugin) ? plugin[0] : plugin) as BrandingPlugin;
+}
+
+function runTransform(plugin: BrandingPlugin, code: string, id: string): { code: string } | null {
+  const transform = plugin.transform;
+  if (!transform) {
+    throw new Error("Expected transform hook to be defined");
+  }
+
+  const handler = typeof transform === "function" ? transform : transform.handler;
+  const result = handler(code, id);
+
+  if (typeof result === "string") {
+    return { code: result };
+  }
+
+  if (result && typeof result === "object" && "code" in result) {
+    return { code: String((result as { code?: unknown }).code ?? "") };
+  }
+
+  return null;
+}
+
+describe("upstart-branding plugin", () => {
+  test("returns disabled plugin when not enabled", () => {
+    const plugin = getPlugin({ enabled: false });
+    expect(plugin.name).toBe("upstart-branding-disabled");
+  });
+
+  test("returns disabled plugin with default options", () => {
+    const plugin = getPlugin({});
+    expect(plugin.name).toBe("upstart-branding-disabled");
+  });
+
+  test("injects runtime init into entry file", () => {
+    const plugin = getPlugin({ enabled: true });
+
+    const result = runTransform(plugin, "console.log('app');", MAIN_ID);
+
+    expect(result).not.toBeNull();
+    expect(result?.code).toContain("initUpstartBranding");
+    expect(result?.code).toContain("requestIdleCallback");
+  });
+
+  test("does not inject into non-entry files", () => {
+    const plugin = getPlugin({ enabled: true });
+
+    const result = runTransform(plugin, "console.log('app');", OTHER_ID);
+
+    expect(result).toBeNull();
+  });
+
+  test("does not inject when initUpstartBranding is already present", () => {
+    const plugin = getPlugin({ enabled: true });
+
+    const result = runTransform(
+      plugin,
+      "import { initUpstartBranding } from 'x'; initUpstartBranding();",
+      MAIN_ID,
+    );
+
+    expect(result).toBeNull();
+  });
+
+  test("skips node_modules files", () => {
+    const plugin = getPlugin({ enabled: true });
+
+    const result = runTransform(
+      plugin,
+      "console.log('app');",
+      "/project/node_modules/some-pkg/entry.client.tsx",
+    );
+
+    expect(result).toBeNull();
+  });
+});

package/src/tests/vite-plugin-upstart-editor.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "vitest";
 import { upstartEditor } from "../vite-plugin-upstart-editor/plugin";
 import type { UpstartEditorPluginOptions } from "../vite-plugin-upstart-editor/runtime/types";
 
-const MAIN_ID = "/project/src/main.tsx";
+const MAIN_ID = "/project/src/entry.client.tsx";
 const OTHER_ID = "/project/src/other.tsx";
 
 type EditorPlugin = {
@@ -48,7 +48,6 @@ describe("upstart-editor plugin", () => {
 
     expect(result).not.toBeNull();
     expect(result?.code).toContain("initUpstartEditor");
-    expect(result?.code).toContain("DOMContentLoaded");
   });
 
   test("does not inject into non-entry files", () => {

package/src/upstart-editor-api.ts

@@ -1,18 +1,47 @@
 import MagicString from "magic-string";
 import fs from "fs/promises";
 import path from "path";
+import z from "zod";
 import type { EditableEntry } from "./vite-plugin-upstart-attrs";
 
+export const payloadEditText = z.object({
+  action: z.literal("editText"),
+  language: z
+    .string()
+    .length(2)
+    .regex(/^[a-z]{2}$/),
+  namespace: z.string().regex(/^[a-z0-9_-]+$/),
+  key: z.string().regex(/^[a-zA-Z0-9_.-]+$/),
+  content: z.string(),
+});
+
+export type PayloadEditText = z.infer<typeof payloadEditText>;
+
+export const payloadEditClassName = z.object({
+  action: z.literal("editClassName"),
+  id: z.string().min(1),
+  className: z.string(),
+});
+
+export type PayloadEditClassName = z.infer<typeof payloadEditClassName>;
+
 export interface EditableRegistry {
   version: number;
   generatedAt: string;
   elements: Record<string, EditableEntry>;
 }
 
-export interface EditResult {
-  success: boolean;
-  error?: string;
-}
+export type EditResult =
+  | {
+      success: true;
+      error?: never;
+      filePath: string;
+    }
+  | {
+      success: false;
+      error: string;
+      filePath?: never;
+    };
 
 export class UpstartEditorAPI {
   private registry: EditableRegistry | null = null;
@@ -47,33 +76,72 @@ export class UpstartEditorAPI {
   }
 
   /**
-   * Edit the text content of an element
+   * Edit a translation value in an i18next locale file.
+   * Auto-detects flat keys (e.g. "nav.home" as literal key) vs nested keys (e.g. nav -> home).
+   * Only updates existing keys — returns an error if the key is not found.
    */
-  async editText(id: string, newContent: string): Promise<EditResult> {
-    if (!this.registry) {
-      try {
-        await this.loadRegistry();
-      } catch (err) {
-        return { success: false, error: `Failed to load registry: ${err}` };
-      }
+  async editText(params: PayloadEditText): Promise<EditResult> {
+    const parsed = payloadEditText.safeParse(params);
+    if (!parsed.success) {
+      return { success: false, error: `Invalid payload: ${parsed.error.message}` };
     }
+    const { language, namespace, key, content: newContent } = parsed.data;
+    const filePath = path.join(this.projectRoot, "app", "locales", language, `${namespace}.json`);
 
-    const entry = this.registry!.elements[id];
-    if (!entry) {
-      return { success: false, error: `Element ${id} not found in registry` };
+    let raw: string;
+    try {
+      raw = await fs.readFile(filePath, "utf-8");
+    } catch (err) {
+      return { success: false, error: `Failed to read locale file: ${filePath}` };
     }
 
-    if (entry.type !== "text") {
-      return { success: false, error: `Element ${id} is not a text element (type: ${entry.type})` };
+    let data: Record<string, unknown>;
+    try {
+      data = JSON.parse(raw);
+    } catch (err) {
+      return { success: false, error: `Failed to parse locale file: ${filePath}` };
     }
 
-    return this.applyEdit(id, entry, newContent);
+    // Strategy 1: check for flat/literal key at top level
+    if (key in data && typeof data[key] === "string") {
+      data[key] = newContent;
+    } else {
+      // Strategy 2: nested traversal via dot notation
+      const parts = key.split(".");
+      let current: Record<string, unknown> = data;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (current[part] == null || typeof current[part] !== "object") {
+          return { success: false, error: `Key "${key}" not found in locale file ${filePath}` };
+        }
+        current = current[part] as Record<string, unknown>;
+      }
+
+      const leafKey = parts[parts.length - 1];
+      if (!(leafKey in current) || typeof current[leafKey] !== "string") {
+        return { success: false, error: `Key "${key}" not found in locale file ${filePath}` };
+      }
+      current[leafKey] = newContent;
+    }
+
+    try {
+      await fs.writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+    } catch (err) {
+      return { success: false, error: `Failed to write locale file: ${filePath}` };
+    }
+
+    return { success: true, filePath };
   }
 
   /**
    * Edit the className of an element
    */
-  async editClassName(id: string, newClassName: string): Promise<EditResult> {
+  async editClassName(params: PayloadEditClassName): Promise<EditResult> {
+    const parsed = payloadEditClassName.safeParse(params);
+    if (!parsed.success) {
+      return { success: false, error: `Invalid payload: ${parsed.error.message}` };
+    }
+    const { id, className: newClassName } = parsed.data;
     if (!this.registry) {
       try {
         await this.loadRegistry();
@@ -97,11 +165,7 @@ export class UpstartEditorAPI {
   /**
    * Apply an edit to a source file
    */
-  private async applyEdit(
-    id: string,
-    entry: EditableEntry,
-    newContent: string
-  ): Promise<EditResult> {
+  private async applyEdit(id: string, entry: EditableEntry, newContent: string): Promise<EditResult> {
     const filePath = path.join(this.projectRoot, entry.file);
 
     try {
@@ -150,12 +214,9 @@ export class UpstartEditorAPI {
       }
 
       // Save the updated registry
-      await fs.writeFile(
-        this.registryPath,
-        JSON.stringify(this.registry, null, 2)
-      );
+      await fs.writeFile(this.registryPath, JSON.stringify(this.registry, null, 2));
 
-      return { success: true };
+      return { success: true, filePath };
     } catch (err) {
       return { success: false, error: String(err) };
     }