rwsdk 0.1.16 → 0.1.17-test.20250715200658

package/dist/vite/ssrBridgePlugin.mjs

@@ -0,0 +1,137 @@
+import debug from "debug";
+import { SSR_BRIDGE_PATH } from "../lib/constants.mjs";
+import { findSsrImportSpecifiers } from "./findSsrSpecifiers.mjs";
+const log = debug("rwsdk:vite:ssr-bridge-plugin");
+export const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
+export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
+    log("Initializing SSR bridge plugin with SSR_BRIDGE_PATH=%s", SSR_BRIDGE_PATH);
+    let devServer;
+    let isDev = false;
+    const ssrBridgePlugin = {
+        name: "rwsdk:ssr-bridge",
+        enforce: "pre",
+        async configureServer(server) {
+            devServer = server;
+            log("Configured dev server");
+        },
+        config(_, { command, isPreview }) {
+            isDev = !isPreview && command === "serve";
+            log("Config: command=%s, isPreview=%s, isDev=%s", command, isPreview, isDev);
+        },
+        configEnvironment(env, config) {
+            log("Configuring environment: env=%s", env);
+            if (env === "worker") {
+                // Configure esbuild to mark rwsdk/__ssr paths as external for worker environment
+                log("Configuring esbuild options for worker environment");
+                config.optimizeDeps ??= {};
+                config.optimizeDeps.esbuildOptions ??= {};
+                config.optimizeDeps.esbuildOptions.plugins ??= [];
+                config.optimizeDeps.include ??= [];
+                config.optimizeDeps.esbuildOptions.plugins.push({
+                    name: "rwsdk-ssr-external",
+                    setup(build) {
+                        log("Setting up esbuild plugin to mark rwsdk/__ssr paths as external for worker");
+                        build.onResolve({ filter: /.*$/ }, (args) => {
+                            process.env.VERBOSE &&
+                                log("Esbuild onResolve called for path=%s, args=%O", args.path, args);
+                            if (args.path === "rwsdk/__ssr_bridge") {
+                                log("Marking as external: %s", args.path);
+                                return {
+                                    path: args.path,
+                                    external: true,
+                                };
+                            }
+                        });
+                    },
+                });
+                log("Worker environment esbuild configuration complete");
+            }
+        },
+        async resolveId(id) {
+            process.env.VERBOSE &&
+                log("Resolving id=%s, environment=%s, isDev=%s", id, this.environment?.name, isDev);
+            if (isDev) {
+                // context(justinvdm, 27 May 2025): In dev, we need to dynamically load
+                // SSR modules, so we return the virtual id so that the dynamic loading
+                // can happen in load()
+                if (id.startsWith(VIRTUAL_SSR_PREFIX)) {
+                    log("Returning virtual SSR id for dev: %s", id);
+                    return id;
+                }
+                // context(justinvdm, 28 May 2025): The SSR bridge module is a special case -
+                // it is the entry point for all SSR modules, so to trigger the
+                // same dynamic loading logic as other SSR modules (as the case above),
+                // we return a virtual id
+                if (id === "rwsdk/__ssr_bridge" && this.environment.name === "worker") {
+                    const virtualId = `${VIRTUAL_SSR_PREFIX}${id}`;
+                    log("Bridge module case (dev): id=%s matches rwsdk/__ssr_bridge in worker environment, returning virtual id=%s", id, virtualId);
+                    return virtualId;
+                }
+            }
+            else {
+                // context(justinvdm, 27 May 2025): In builds, since all SSR import chains
+                // originate at SSR bridge module, we return the path to the already built
+                // SSR bridge bundle - SSR env builds it, worker build tries to resolve it
+                // here and uses it
+                if (id === "rwsdk/__ssr_bridge" && this.environment.name === "worker") {
+                    log("Bridge module case (build): id=%s matches rwsdk/__ssr_bridge in worker environment, returning SSR_BRIDGE_PATH=%s", id, SSR_BRIDGE_PATH);
+                    return SSR_BRIDGE_PATH;
+                }
+            }
+            process.env.VERBOSE && log("No resolution for id=%s", id);
+        },
+        async load(id) {
+            process.env.VERBOSE &&
+                log("Loading id=%s, isDev=%s, environment=%s", id, isDev, this.environment.name);
+            if (id.startsWith(VIRTUAL_SSR_PREFIX) &&
+                this.environment.name === "worker") {
+                const realId = id.slice(VIRTUAL_SSR_PREFIX.length);
+                log("Virtual SSR module load: id=%s, realId=%s", id, realId);
+                if (isDev) {
+                    log("Dev mode: fetching SSR module for realPath=%s", realId);
+                    const result = await devServer?.environments.ssr.fetchModule(realId);
+                    process.env.VERBOSE &&
+                        log("Fetch module result: id=%s, result=%O", realId, result);
+                    const code = "code" in result ? result.code : undefined;
+                    if (realId.endsWith(".css")) {
+                        process.env.VERBOSE &&
+                            log("Not a JS file, returning code: %s", code);
+                        return code ?? "";
+                    }
+                    log("Fetched SSR module code length: %d", code?.length || 0);
+                    const { imports, dynamicImports } = findSsrImportSpecifiers(realId, code || "", log);
+                    const allSpecifiers = [
+                        ...new Set([...imports, ...dynamicImports]),
+                    ].map((id) => id.startsWith("/@id/") ? id.slice("/@id/".length) : id);
+                    const switchCases = allSpecifiers
+                        .map((specifier) => `    case "${specifier}": void import("${VIRTUAL_SSR_PREFIX}${specifier}");`)
+                        .join("\n");
+                    const transformedCode = `
+await (async function(__vite_ssr_import__, __vite_ssr_dynamic_import__) {${code}})(
+  __ssrImport.bind(null, false),
+  __ssrImport.bind(null, true)
+);
+
+function __ssrImport(isDynamic, id, ...args) {
+  id = id.startsWith('/@id/') ? id.slice('/@id/'.length) : id;
+
+  switch (id) {
+${switchCases}
+  }
+
+  return isDynamic
+    ? __vite_ssr_dynamic_import__("/@id/${VIRTUAL_SSR_PREFIX}" + id, ...args)
+    : __vite_ssr_import__("/@id/${VIRTUAL_SSR_PREFIX}" + id, ...args);
+}
+`;
+                    log("Transformed SSR module code length: %d", transformedCode.length);
+                    process.env.VERBOSE &&
+                        log("Transformed SSR module code for realId=%s: %s", realId, transformedCode);
+                    return transformedCode;
+                }
+            }
+            process.env.VERBOSE && log("No load handling for id=%s", id);
+        },
+    };
+    return ssrBridgePlugin;
+};

package/dist/vite/transformClientComponents.d.mts

@@ -0,0 +1,12 @@
+interface TransformContext {
+    environmentName: string;
+    clientFiles?: Set<string>;
+    isEsbuild?: boolean;
+    addClientModule?: (environment: string, id: string) => void;
+}
+interface TransformResult {
+    code: string;
+    map?: any;
+}
+export declare function transformClientComponents(code: string, normalizedId: string, ctx: TransformContext): Promise<TransformResult | undefined>;
+export type { TransformContext, TransformResult };

package/dist/vite/transformClientComponents.mjs

@@ -0,0 +1,116 @@
+import MagicString from "magic-string";
+import debug from "debug";
+import { hasDirective } from "./hasDirective.mjs";
+import { findExports } from "./findSpecifiers.mjs";
+const logVite = debug("rwsdk:vite:transform-client-components:vite");
+const logEsbuild = debug("rwsdk:vite:transform-client-components:esbuild");
+export async function transformClientComponents(code, normalizedId, ctx) {
+    const log = ctx.isEsbuild ? logEsbuild : logVite;
+    log("Called transformClientComponents for id: id=%s", normalizedId);
+    if (!hasDirective(code, "use client")) {
+        log("Skipping: no 'use client' directive in id=%s", normalizedId);
+        process.env.VERBOSE &&
+            log(":VERBOSE: Returning code unchanged for id=%s:\n%s", normalizedId, code);
+        return;
+    }
+    log("Processing 'use client' module: id=%s", normalizedId);
+    ctx.addClientModule?.(ctx.environmentName, normalizedId);
+    // Parse exports using the findExports helper
+    const exportInfos = findExports(normalizedId, code, log);
+    const processedExports = [];
+    let defaultExportInfo;
+    // Helper to get the computed local name (with alias suffix if present)
+    function getComputedLocalName(info) {
+        return `${info.local}${info.alias ? `_${info.alias}` : ""}`;
+    }
+    // Convert ExportInfo to ProcessedExportInfo
+    exportInfos.forEach((exportInfo, idx) => {
+        if (exportInfo.isDefault) {
+            defaultExportInfo = {
+                local: exportInfo.alias || "default",
+                exported: "default",
+                isDefault: true,
+                statementIdx: idx,
+            };
+        }
+        else {
+            // For aliases like "export { MyComponent as CustomName }", we need:
+            // - local: "MyComponent" (the original name)
+            // - exported: "CustomName" (the alias name)
+            // - alias: "CustomName" (to generate MyComponent_CustomName)
+            const hasAlias = exportInfo.alias && exportInfo.originalName;
+            processedExports.push({
+                local: exportInfo.originalName || exportInfo.name, // Use originalName if available
+                exported: exportInfo.name, // The exported name (alias if present)
+                isDefault: false,
+                statementIdx: idx,
+                alias: hasAlias ? exportInfo.alias : undefined,
+            });
+        }
+    });
+    // 3. Client/SSR files: just remove the directive
+    if (ctx.environmentName === "ssr" || ctx.environmentName === "client") {
+        log(":isEsbuild=%s: Handling SSR virtual module: %s", !!ctx.isEsbuild, normalizedId);
+        // Remove 'use client' directive using magic-string
+        const s = new MagicString(code);
+        // Find and remove "use client" directives
+        const directiveRegex = /^(\s*)(['"]use client['"])\s*;?\s*\n?/gm;
+        let match;
+        while ((match = directiveRegex.exec(code)) !== null) {
+            const start = match.index;
+            const end = match.index + match[0].length;
+            s.remove(start, end);
+            process.env.VERBOSE &&
+                log("Removed 'use client' directive from normalizedId=%s", normalizedId);
+            break; // Only remove the first one
+        }
+        const sourceMap = s.generateMap({
+            source: normalizedId,
+            includeContent: true,
+            hires: true,
+        });
+        process.env.VERBOSE &&
+            log(":VERBOSE: SSR transformed code for %s:\n%s", normalizedId, s.toString());
+        return {
+            code: s.toString(),
+            map: sourceMap,
+        };
+    }
+    // 4. Non-SSR files: replace all implementation with registerClientReference logic
+    // Generate completely new code for worker/client environments
+    const s = new MagicString("");
+    // Add import declaration
+    s.append('import { registerClientReference } from "rwsdk/worker";\n');
+    // Compute unique computed local names first
+    const computedLocalNames = new Map(processedExports.map((info) => [getComputedLocalName(info), info]));
+    // Add registerClientReference assignments for unique names
+    for (const [computedLocalName, correspondingInfo] of computedLocalNames) {
+        log(":isEsbuild=%s: Registering client reference for named export: %s as %s", !!ctx.isEsbuild, correspondingInfo.local, correspondingInfo.exported);
+        s.append(`const ${computedLocalName} = registerClientReference("${normalizedId}", "${correspondingInfo.exported}");\n`);
+    }
+    // Add grouped export statement for named exports (preserving order and alias)
+    if (processedExports.length > 0) {
+        const exportNames = Array.from(computedLocalNames.entries()).map(([computedLocalName, correspondingInfo]) => correspondingInfo.local === correspondingInfo.exported
+            ? computedLocalName
+            : `${computedLocalName} as ${correspondingInfo.exported}`);
+        log(":isEsbuild=%s: Exporting named exports: %O", !!ctx.isEsbuild, exportNames);
+        s.append(`export { ${exportNames.join(", ")} };\n`);
+    }
+    // Add default export if present
+    if (defaultExportInfo) {
+        log(":isEsbuild=%s: Registering client reference for default export: %s", !!ctx.isEsbuild, defaultExportInfo.exported);
+        s.append(`export default registerClientReference("${normalizedId}", "${defaultExportInfo.exported}");\n`);
+    }
+    const sourceMap = s.generateMap({
+        source: normalizedId,
+        includeContent: true,
+        hires: true,
+    });
+    const finalResult = s.toString();
+    process.env.VERBOSE &&
+        log(":VERBOSE: Transformed code (env=%s, normalizedId=%s):\n%s", normalizedId, ctx.environmentName, finalResult);
+    return {
+        code: finalResult,
+        map: sourceMap,
+    };
+}

package/dist/vite/transformClientComponents.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/vite/transformClientComponents.test.mjs

@@ -0,0 +1,264 @@
+import { describe, it, expect } from "vitest";
+import { transformClientComponents } from "./transformClientComponents.mjs";
+describe("transformClientComponents", () => {
+    async function transform(code) {
+        const result = await transformClientComponents(code, "/test/file.tsx", {
+            environmentName: "worker",
+        });
+        return result?.code;
+    }
+    it("transforms arrow function component", async () => {
+        expect((await transform(`"use client"
+
+export const Component = () => {
+  return jsx('div', { children: 'Hello' });
+}
+`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Component = registerClientReference("/test/file.tsx", "Component");
+export { Component };
+`);
+    });
+    it("transforms async arrow function component", async () => {
+        expect((await transform(`"use client"
+
+export const Component = async () => {
+  return jsx('div', { children: 'Hello' });
+}
+  `)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Component = registerClientReference("/test/file.tsx", "Component");
+export { Component };
+`);
+    });
+    it("transforms function declaration component", async () => {
+        expect((await transform(`"use client"
+
+export function Component() {
+  return jsx('div', { children: 'Hello' });
+}`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Component = registerClientReference("/test/file.tsx", "Component");
+export { Component };
+`);
+    });
+    it("transforms default export arrow function component", async () => {
+        expect((await transform(`"use client"
+
+export default () => {
+  return jsx('div', { children: 'Hello' });
+}`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+export default registerClientReference("/test/file.tsx", "default");
+`);
+    });
+    it("transforms default export function declaration component", async () => {
+        expect((await transform(`"use client"
+
+export default function Component({ prop1, prop2 }) {
+  return jsx('div', { children: 'Hello' });
+}`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+export default registerClientReference("/test/file.tsx", "default");
+`);
+    });
+    it("transforms mixed export styles (inline, grouped, and default)", async () => {
+        expect((await transform(`"use client"
+
+export const First = () => {
+  return jsx('div', { children: 'First' });
+}
+
+const Second = () => {
+  return jsx('div', { children: 'Second' });
+}
+
+function Third() {
+  return jsx('div', { children: 'Third' });
+}
+
+const Fourth = () => {
+  return jsx('div', { children: 'Fourth' });
+}
+
+export default function Main() {
+  return jsx('div', { children: 'Main' });
+}
+
+export { Second, Third }
+export { Fourth as AnotherName }`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const First = registerClientReference("/test/file.tsx", "First");
+const Second = registerClientReference("/test/file.tsx", "Second");
+const Third = registerClientReference("/test/file.tsx", "Third");
+const Fourth_AnotherName = registerClientReference("/test/file.tsx", "AnotherName");
+export { First, Second, Third, Fourth_AnotherName as AnotherName };
+export default registerClientReference("/test/file.tsx", "default");
+`);
+    });
+    it("transforms function declaration that is exported default separately", async () => {
+        expect((await transform(`
+"use client"
+
+function Component({ prop1, prop2 }) {
+  return jsx('div', { children: 'Hello' });
+}
+
+export default Component;`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+export default registerClientReference("/test/file.tsx", "default");
+`);
+    });
+    it("Works in dev", async () => {
+        expect((await transform(`"use client"
+import { jsxDEV } from "react/jsx-dev-runtime";
+import { sendMessage } from "./functions";
+import { useState } from "react";
+import { consumeEventStream } from "rwsdk/client";
+
+export function Chat() {
+  const [message, setMessage] = useState("");
+  const [reply, setReply] = useState("");
+  const onClick = async () => {
+    setReply("");
+    (await sendMessage(message)).pipeTo(
+      consumeEventStream({
+        onChunk: (event) => {
+          setReply(
+            (prev) => prev + (event.data === "[DONE]" ? "" : JSON.parse(event.data).response)
+          );
+        }
+      })
+    );
+  };
+  return /* @__PURE__ */ jsxDEV("div", { children: [
+    /* @__PURE__ */ jsxDEV(
+      "input",
+      {
+        type: "text",
+        value: message,
+        placeholder: "Type a message...",
+        onChange: (e) => setMessage(e.target.value),
+        style: {
+          width: "80%",
+          padding: "10px",
+          marginRight: "8px",
+          borderRadius: "4px",
+          border: "1px solid #ccc"
+        }
+      },
+      void 0,
+      false,
+      {
+        fileName: "/Users/justin/rw/sdk/experiments/ai-stream/src/app/pages/Chat/Chat.tsx",
+        lineNumber: 28,
+        columnNumber: 7
+      },
+      this
+    ),
+    /* @__PURE__ */ jsxDEV(
+      "button",
+      {
+        onClick,
+        style: {
+          padding: "10px 20px",
+          borderRadius: "4px",
+          border: "none",
+          backgroundColor: "#007bff",
+          color: "white",
+          cursor: "pointer"
+        },
+        children: "Send"
+      },
+      void 0,
+      false,
+      {
+        fileName: "/Users/justin/rw/sdk/experiments/ai-stream/src/app/pages/Chat/Chat.tsx",
+        lineNumber: 41,
+        columnNumber: 7
+      },
+      this
+    ),
+    /* @__PURE__ */ jsxDEV("div", { children: reply }, void 0, false, {
+      fileName: "/Users/justin/rw/sdk/experiments/ai-stream/src/app/pages/Chat/Chat.tsx",
+      lineNumber: 54,
+      columnNumber: 7
+    }, this)
+  ] }, void 0, true, {
+    fileName: "/Users/justin/rw/sdk/experiments/ai-stream/src/app/pages/Chat/Chat.tsx",
+    lineNumber: 27,
+    columnNumber: 5
+  }, this);
+}
+`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Chat = registerClientReference("/test/file.tsx", "Chat");
+export { Chat };
+`);
+    });
+    it("Does not transform when 'use client' is not directive", async () => {
+        expect(await transform(`const message = "use client";`)).toEqual(undefined);
+    });
+    it("properly handles export alias", async () => {
+        expect((await transform(`"use client"
+
+const MyComponent = () => {
+  return jsx('div', { children: 'Hello' });
+}
+
+export { MyComponent as CustomName }`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const MyComponent_CustomName = registerClientReference("/test/file.tsx", "CustomName");
+export { MyComponent_CustomName as CustomName };
+`);
+    });
+    it("correctly processes multiple component exports", async () => {
+        expect((await transform(`"use client"
+
+const First = () => jsx('div', { children: 'First' });
+const Second = () => jsx('div', { children: 'Second' });
+const Third = () => jsx('div', { children: 'Third' });
+
+export { First, Second, Third }`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const First = registerClientReference("/test/file.tsx", "First");
+const Second = registerClientReference("/test/file.tsx", "Second");
+const Third = registerClientReference("/test/file.tsx", "Third");
+export { First, Second, Third };
+`);
+    });
+    it("handles combination of JSX and non-JSX exports", async () => {
+        expect((await transform(`"use client"
+
+const Component = () => jsx('div', {});
+const data = { value: 42 };
+const helper = () => console.log('helper');
+
+export { Component, data, helper }`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Component = registerClientReference("/test/file.tsx", "Component");
+const data = registerClientReference("/test/file.tsx", "data");
+const helper = registerClientReference("/test/file.tsx", "helper");
+export { Component, data, helper };
+`);
+    });
+    it("transforms multiple exports aliases for the same component", async () => {
+        expect((await transform(`"use client"
+
+export const Slot = () => {
+  return jsx('div', { children: 'Slot' });
+}
+
+export { Slot, Slot as Root }
+`)) ?? "").toEqual(`import { registerClientReference } from "rwsdk/worker";
+const Slot = registerClientReference("/test/file.tsx", "Slot");
+const Slot_Root = registerClientReference("/test/file.tsx", "Root");
+export { Slot, Slot_Root as Root };
+`);
+    });
+});
+describe("transformClientComponents logic branches (from transformClientComponents.mts)", () => {
+    it("returns code as-is if file does not start with 'use client'", async () => {
+        const code = "const foo = 1;";
+        const result = await transformClientComponents(code, "/test/file.tsx", {
+            environmentName: "worker",
+        });
+        expect(result).toBeUndefined();
+    });
+    it("removes directive but does not transform if not a virtual SSR file", async () => {
+        const code = '"use client"\nexport const foo = 1;';
+        const result = await transformClientComponents(code, "/test/file.tsx", {
+            environmentName: "ssr",
+        });
+        expect(result?.code).toEqual("export const foo = 1;");
+    });
+});

package/dist/vite/transformJsxScriptTagsPlugin.d.mts

@@ -0,0 +1,8 @@
+import { type Plugin } from "vite";
+export declare function transformJsxScriptTagsCode(code: string, manifest?: Record<string, any>): Promise<{
+    code: string;
+    map: null;
+} | undefined>;
+export declare const transformJsxScriptTagsPlugin: ({ manifestPath, }: {
+    manifestPath: string;
+}) => Plugin;