rwsdk 0.1.5 → 0.1.6-test.20250702132719

package/dist/vite/moduleResolver.mjs

@@ -1,74 +0,0 @@
-import path from "path";
-import enhancedResolve from "enhanced-resolve";
-import debug from "debug";
-function applyAlias(request, aliasEntries, name) {
-    if (!aliasEntries)
-        return request;
-    const logPrefix = `:${name}:`;
-    // Support both array and object forms
-    const entries = Array.isArray(aliasEntries)
-        ? aliasEntries
-        : Object.entries(aliasEntries).map(([find, replacement]) => ({
-            find,
-            replacement,
-        }));
-    for (const entry of entries) {
-        const { find, replacement } = entry;
-        if (typeof find === "string") {
-            if (request === find || request.startsWith(find + "/")) {
-                debug("rwsdk:vite:aliased-module-resolver")("%s :applyAlias: Matched string alias: '%s' -> '%s' for request '%s'", logPrefix, find, replacement, request);
-                return replacement + request.slice(find.length);
-            }
-        }
-        else if (find instanceof RegExp) {
-            if (find.test(request)) {
-                debug("rwsdk:vite:aliased-module-resolver")("%s :applyAlias: Matched RegExp alias: %O -> '%s' for request '%s'", logPrefix, find, replacement, request);
-                return request.replace(find, replacement);
-            }
-        }
-    }
-    return request;
-}
-export function createModuleResolver({ getAliases, roots, conditionNames = ["workerd", "edge", "import", "default"], name, }) {
-    const log = debug("rwsdk:vite:aliased-module-resolver");
-    const logPrefix = `:${name}:`;
-    const baseModuleResolver = enhancedResolve.create.sync({
-        conditionNames,
-        extensions: [".mjs", ".js", ".ts", ".jsx", ".tsx"],
-    });
-    const attemptResolve = (from, request) => {
-        try {
-            return baseModuleResolver(from, request);
-        }
-        catch {
-            return false;
-        }
-    };
-    return function resolveModule(request, importer) {
-        log("%s Called with request=%s, importer=%s", logPrefix, request, importer);
-        const aliasEntries = getAliases ? getAliases() : [];
-        const normalized = applyAlias(request, aliasEntries, name);
-        log("%s After aliasing: %s", logPrefix, normalized);
-        if (importer != null) {
-            const result = attemptResolve(path.dirname(importer), normalized);
-            if (result) {
-                log("%s Resolved module=%s relative to: importer=%s", logPrefix, result, importer);
-                return result;
-            }
-        }
-        for (const root of roots) {
-            try {
-                log("%s Attempting to resolve module=%s relative to: root=%s", logPrefix, normalized, root);
-                const result = attemptResolve(root, normalized);
-                if (result) {
-                    log("%s Resolved module=%s relative to: root=%s", logPrefix, result, importer);
-                    return result;
-                }
-            }
-            catch (err) {
-                log("%s Resolution failed for normalized=%s from root=%s: %O", logPrefix, normalized, root, err);
-            }
-        }
-        return false;
-    };
-}

package/dist/vite/resolveModuleId.d.mts

@@ -1,6 +0,0 @@
-/**
- * Resolves a module ID consistently across client and server transformations.
- * For node modules, uses the /rwsdk:kind/relativePath format.
- * For regular files, uses the raw ID.
- */
-export declare function resolveModuleId(id: string, kind: "client" | "server", projectRootDir: string): string;

package/dist/vite/resolveModuleId.mjs

@@ -1,14 +0,0 @@
-import { normalizeModulePath } from "./normalizeModulePath.mjs";
-/**
- * Resolves a module ID consistently across client and server transformations.
- * For node modules, uses the /rwsdk:kind/relativePath format.
- * For regular files, uses the raw ID.
- */
-export function resolveModuleId(id, kind, projectRootDir) {
-    const modulePath = normalizeModulePath(projectRootDir, id);
-    return modulePath.includes("node_modules")
-        ? modulePath.includes("__rwsdk_kind")
-            ? modulePath
-            : `${modulePath}?__rwsdk_kind=${kind}`
-        : modulePath;
-}

package/dist/vite/rscDirectivesPlugin.d.mts

@@ -1,6 +0,0 @@
-import { Plugin } from "vite";
-export declare const rscDirectivesPlugin: ({ projectRootDir, clientFiles, serverFiles, }: {
-    projectRootDir: string;
-    clientFiles: Set<string>;
-    serverFiles: Set<string>;
-}) => Plugin;

package/dist/vite/rscDirectivesPlugin.mjs

@@ -1,80 +0,0 @@
-import debug from "debug";
-import { transformClientComponents } from "./transformClientComponents.mjs";
-import { transformServerFunctions } from "./transformServerFunctions.mjs";
-import { normalizeModulePath } from "./normalizeModulePath.mjs";
-const log = debug("rwsdk:vite:rsc-directives-plugin");
-const verboseLog = debug("verbose:rwsdk:vite:rsc-directives-plugin");
-export const rscDirectivesPlugin = ({ projectRootDir, clientFiles, serverFiles, }) => ({
-    name: "rwsdk:rsc-directives",
-    async transform(code, id) {
-        verboseLog("Transform called for id=%s, environment=%s", id, this.environment.name);
-        const normalizedId = normalizeModulePath(projectRootDir, id);
-        const clientResult = await transformClientComponents(code, normalizedId, {
-            environmentName: this.environment.name,
-            clientFiles,
-        });
-        if (clientResult) {
-            log("Client component transformation successful for id=%s", id);
-            return {
-                code: clientResult.code,
-                map: clientResult.map,
-            };
-        }
-        const serverResult = transformServerFunctions(code, normalizedId, this.environment.name, serverFiles);
-        if (serverResult) {
-            log("Server function transformation successful for id=%s", id);
-            return {
-                code: serverResult.code,
-                map: serverResult.map,
-            };
-        }
-        verboseLog("No transformation applied for id=%s", id);
-    },
-    configEnvironment(env, config) {
-        log("Configuring environment: env=%s", env);
-        config.optimizeDeps ??= {};
-        config.optimizeDeps.esbuildOptions ??= {};
-        config.optimizeDeps.esbuildOptions.plugins ??= [];
-        config.optimizeDeps.esbuildOptions.plugins.push({
-            name: "rsc-directives-esbuild-transform",
-            setup(build) {
-                log("Setting up esbuild plugin for environment: %s", env);
-                build.onLoad({ filter: /.*\.js$/ }, async (args) => {
-                    verboseLog("Esbuild onLoad called for path=%s", args.path);
-                    const fs = await import("node:fs/promises");
-                    const path = await import("node:path");
-                    let code;
-                    try {
-                        code = await fs.readFile(args.path, "utf-8");
-                    }
-                    catch {
-                        verboseLog("Failed to read file: %s", args.path);
-                        return undefined;
-                    }
-                    const clientResult = await transformClientComponents(code, normalizeModulePath(projectRootDir, args.path), {
-                        environmentName: env,
-                        clientFiles,
-                        isEsbuild: true,
-                    });
-                    if (clientResult) {
-                        log("Esbuild client component transformation successful for path=%s", args.path);
-                        return {
-                            contents: clientResult.code,
-                            loader: path.extname(args.path).slice(1),
-                        };
-                    }
-                    const serverResult = transformServerFunctions(code, normalizeModulePath(projectRootDir, args.path), env, serverFiles);
-                    if (serverResult) {
-                        log("Esbuild server function transformation successful for path=%s", args.path);
-                        return {
-                            contents: serverResult.code,
-                            loader: path.extname(args.path).slice(1),
-                        };
-                    }
-                    verboseLog("Esbuild no transformation applied for path=%s", args.path);
-                });
-            },
-        });
-        log("Environment configuration complete for env=%s", env);
-    },
-});

package/dist/vite/transformServerReferences.d.mts

@@ -1,11 +0,0 @@
-export interface TransformServerEnv {
-    environmentName: string;
-    isEsbuild?: boolean;
-    isSSR?: boolean;
-    topLevelRoot?: string;
-}
-export interface TransformResult {
-    code: string;
-    map?: any;
-}
-export declare function transformServerReferences(code: string, id: string, env: TransformServerEnv): Promise<TransformResult | undefined>;

package/dist/vite/transformServerReferences.mjs

@@ -1,74 +0,0 @@
-import { relative } from "node:path";
-import MagicString from "magic-string";
-import debug from "debug";
-import { parse } from "es-module-lexer";
-import { ensureNoSSRNamespace, ensureSSRNamespace, } from "./virtualizedSSRPlugin.mjs";
-const logVite = debug("rwsdk:vite:transform-server-references:vite");
-const logEsbuild = debug("rwsdk:vite:transform-server-references:esbuild");
-export async function transformServerReferences(code, id, env) {
-    const log = env.isEsbuild ? logEsbuild : logVite;
-    log("Called transformServerReferences for id: id=%s, env: %O", id, env);
-    // Only transform files that start with 'use server'
-    const cleanCode = code.trimStart();
-    const hasUseServer = cleanCode.startsWith('"use server"') ||
-        cleanCode.startsWith("'use server'");
-    if (!hasUseServer) {
-        log("Skipping: no 'use server' directive in id=%s", id);
-        return;
-    }
-    log("Processing 'use server' module: id=%s", id);
-    // Remove all 'use server' directives
-    let s = new MagicString(code);
-    s.replaceAll("'use server'", "");
-    s.replaceAll('"use server"', "");
-    s.trim();
-    // Parse exports
-    await import("es-module-lexer"); // ensure parse is initialized
-    const [_, exports] = parse(code);
-    log("Parsed exports for id=%s: %O", id, exports);
-    // Compute relativeId for registration
-    let relativeId = id;
-    if (env.topLevelRoot) {
-        try {
-            relativeId = `/${relative(env.topLevelRoot, id)}`;
-            log("Computed relativeId for id=%s: %s", id, relativeId);
-        }
-        catch (e) {
-            log("Error computing relativeId for id=%s: %O", id, e);
-        }
-    }
-    let importLines = [];
-    let exportLines = [];
-    if (env.isSSR) {
-        log("SSR import detected for id=%s", id);
-        // Just re-export everything from the original module in SSR
-        importLines.push(`export * from ${JSON.stringify(ensureNoSSRNamespace(id))};`);
-        exportLines = [];
-    }
-    else if (env.environmentName === "worker") {
-        log("Worker environment detected for id=%s", id);
-        importLines.push('import { registerServerReference } from "rwsdk/worker";');
-        importLines.push(`import ${JSON.stringify(ensureSSRNamespace(id))};`);
-        for (const e of exports) {
-            log("Registering server reference for export: %O in id=%s", e, id);
-            exportLines.push(`registerServerReference(${e.ln}, ${JSON.stringify(relativeId)}, ${JSON.stringify(e.ln)});`);
-        }
-    }
-    else if (env.environmentName === "client") {
-        log("Client environment detected for id=%s", id);
-        importLines.push('import { createServerReference } from "rwsdk/client";');
-        for (const e of exports) {
-            log("Creating client server reference for export: %O in id=%s", e, id);
-            exportLines.push(`export const ${e.ln} = createServerReference(${JSON.stringify(relativeId)}, ${JSON.stringify(e.ln)});`);
-        }
-    }
-    log("Processing complete for id=%s", id);
-    const result = [...importLines, ...exportLines].join("\n");
-    if (process.env.VERBOSE) {
-        log(":VERBOSE: Transformed code for id=%s:\n%s", id, result);
-    }
-    return {
-        code: result + "\n",
-        map: s.generateMap({ hires: true }),
-    };
-}

package/dist/vite/useClientPlugin.d.mts

@@ -1,8 +0,0 @@
-import { Plugin } from "vite";
-interface TransformResult {
-    code: string;
-    map?: any;
-}
-export declare function transformUseClientCode(code: string, relativeId: string): Promise<TransformResult | undefined>;
-export declare const useClientPlugin: () => Plugin;
-export {};

package/dist/vite/useClientPlugin.mjs

@@ -1,299 +0,0 @@
-import { relative } from "node:path";
-import { Project, Node, SyntaxKind, } from "ts-morph";
-function isJsxFunction(text) {
-    return (text.includes("jsx(") || text.includes("jsxs(") || text.includes("jsxDEV("));
-}
-export async function transformUseClientCode(code, relativeId) {
-    if (code.indexOf("use client") === -1) {
-        return;
-    }
-    const project = new Project({
-        useInMemoryFileSystem: true,
-        compilerOptions: {
-            sourceMap: true,
-            target: 2, // ES6
-            module: 1, // CommonJS
-            jsx: 2, // React
-        },
-    });
-    const sourceFile = project.createSourceFile("temp.tsx", code);
-    const firstString = sourceFile.getFirstDescendantByKind(SyntaxKind.StringLiteral);
-    if (firstString?.getText().indexOf("use client") === -1 &&
-        firstString?.getStart() !== sourceFile.getStart() // `getStart` does not include the leading comments + whitespace
-    ) {
-        return;
-    }
-    // Add import declaration properly through the AST
-    sourceFile.addImportDeclaration({
-        moduleSpecifier: "rwsdk/worker",
-        namedImports: [{ name: "registerClientReference" }],
-    });
-    const components = new Map();
-    let anonymousDefaultCount = 0;
-    // Pass 1: Collect all component information
-    // Handle function declarations
-    sourceFile
-        .getDescendantsOfKind(SyntaxKind.FunctionDeclaration)
-        .forEach((node) => {
-        const name = node.getName() || `DefaultComponent${anonymousDefaultCount++}`;
-        if (!name)
-            return;
-        // Only track if it's a component (has JSX return)
-        if (isJsxFunction(node.getText())) {
-            const ssrName = `${name}SSR`;
-            const isInlineExport = node.hasModifier(SyntaxKind.ExportKeyword);
-            // Check if this function is used in a default export
-            const isDefault = node.hasModifier(SyntaxKind.DefaultKeyword) ||
-                sourceFile
-                    .getDescendantsOfKind(SyntaxKind.ExportAssignment)
-                    .some((exp) => exp.getExpression().getText() === name);
-            components.set(name, {
-                name,
-                ssrName,
-                isDefault,
-                isInlineExport,
-            });
-        }
-    });
-    // Handle arrow functions and anonymous default exports
-    sourceFile
-        .getDescendantsOfKind(SyntaxKind.VariableStatement)
-        .forEach((statement) => {
-        const declarations = statement.getDeclarationList().getDeclarations();
-        declarations.forEach((varDecl) => {
-            const arrowFunc = varDecl.getFirstDescendantByKind(SyntaxKind.ArrowFunction);
-            if (!arrowFunc)
-                return;
-            // Only track if it's a component (has JSX return)
-            if (isJsxFunction(arrowFunc.getText())) {
-                const name = varDecl.getName();
-                const isDefault = !!statement.getFirstAncestorByKind(SyntaxKind.ExportAssignment);
-                const isInlineExport = statement.hasModifier(SyntaxKind.ExportKeyword);
-                if (!name &&
-                    (isDefault || statement.getText().includes("export default"))) {
-                    // Handle anonymous default export
-                    const anonName = `DefaultComponent${anonymousDefaultCount++}`;
-                    components.set(anonName, {
-                        name: anonName,
-                        ssrName: anonName,
-                        isDefault: true,
-                        isInlineExport: true,
-                        isAnonymousDefault: true,
-                    });
-                }
-                else if (name) {
-                    components.set(name, {
-                        name,
-                        ssrName: `${name}SSR`,
-                        isDefault,
-                        isInlineExport,
-                    });
-                }
-            }
-        });
-    });
-    // Pass 2: handle exports
-    // Remove use client directives
-    sourceFile.getDescendantsOfKind(SyntaxKind.StringLiteral).forEach((node) => {
-        if (node.getText() === "'use client'" ||
-            node.getText() === '"use client"') {
-            const parentExpr = node.getFirstAncestorByKind(SyntaxKind.ExpressionStatement);
-            if (parentExpr) {
-                parentExpr.remove();
-            }
-        }
-    });
-    // Create lists of nodes to modify before making any changes
-    const functionsToModify = [];
-    const variableStatementsToModify = [];
-    const exportDeclarationsToModify = [];
-    const exportAssignmentsToModify = [];
-    // Collect function declarations to modify
-    sourceFile
-        .getDescendantsOfKind(SyntaxKind.FunctionDeclaration)
-        .forEach((node) => {
-        const name = node.getName();
-        if (!name || !components.has(name))
-            return;
-        const component = components.get(name);
-        if (component.isInlineExport) {
-            functionsToModify.push({
-                node,
-                nodeText: node.getText(),
-                component,
-            });
-        }
-    });
-    // Collect variable statements to modify
-    sourceFile
-        .getDescendantsOfKind(SyntaxKind.VariableStatement)
-        .forEach((statement) => {
-        if (!statement.hasModifier(SyntaxKind.ExportKeyword))
-            return;
-        const declarations = statement.getDeclarationList().getDeclarations();
-        let hasComponent = false;
-        declarations.forEach((varDecl) => {
-            const name = varDecl.getName();
-            if (name && components.has(name)) {
-                hasComponent = true;
-            }
-        });
-        if (hasComponent) {
-            variableStatementsToModify.push({
-                node: statement,
-                stmtText: statement.getText(),
-            });
-        }
-    });
-    // Collect export declarations to modify
-    sourceFile
-        .getDescendantsOfKind(SyntaxKind.ExportDeclaration)
-        .forEach((node) => {
-        const namedExports = node.getNamedExports();
-        const nonComponentExports = namedExports.filter((exp) => !components.has(exp.getName()));
-        if (nonComponentExports.length !== namedExports.length) {
-            exportDeclarationsToModify.push({
-                node,
-                nonComponentExports,
-            });
-        }
-    });
-    // Collect export assignments to modify
-    sourceFile
-        .getDescendantsOfKind(SyntaxKind.ExportAssignment)
-        .forEach((node) => {
-        const expression = node.getExpression();
-        if (Node.isArrowFunction(expression)) {
-            exportAssignmentsToModify.push({
-                node,
-                expression,
-            });
-        }
-        else {
-            exportAssignmentsToModify.push({
-                node,
-                expression: null,
-            });
-        }
-    });
-    // Now apply all modifications in sequence to avoid operating on removed nodes
-    // Modify function declarations
-    functionsToModify.forEach(({ node, nodeText, component }) => {
-        const newText = nodeText.replace(/^export\s+(default\s+)?(async\s+)?function/, "$2function");
-        node.replaceWithText(newText);
-    });
-    // Modify variable statements
-    variableStatementsToModify.forEach(({ node, stmtText }) => {
-        const newText = stmtText.replace(/^export\s+/, "");
-        node.replaceWithText(newText);
-    });
-    // Modify export declarations
-    exportDeclarationsToModify.forEach(({ node, nonComponentExports }) => {
-        if (nonComponentExports.length === 0) {
-            // If all exports were components, remove the declaration
-            node.remove();
-        }
-        else {
-            // If some exports were components, update the export declaration
-            const newExports = nonComponentExports
-                .map((exp) => exp.getText())
-                .join(", ");
-            node.replaceWithText(`export { ${newExports} };`);
-        }
-    });
-    // Handle export assignments with arrow functions
-    exportAssignmentsToModify.forEach(({ node, expression }) => {
-        if (expression && Node.isArrowFunction(expression)) {
-            const anonName = `DefaultComponent${anonymousDefaultCount++}`;
-            const ssrName = `${anonName}SSR`;
-            // First add declarations
-            sourceFile.addStatements(`const ${ssrName} = ${expression.getText()}`);
-            sourceFile.addStatements(`const ${anonName} = registerClientReference("${relativeId}", "default", ${ssrName});`);
-            // Store info for later export
-            components.set(anonName, {
-                name: anonName,
-                ssrName,
-                isDefault: true,
-                isInlineExport: true,
-                isAnonymousDefault: true,
-            });
-        }
-        // Remove the original export default node
-        node.remove();
-    });
-    // Pass 4: rename all identifiers to SSR version - collect first
-    const identifiersToRename = [];
-    components.forEach(({ name, ssrName, isAnonymousDefault }) => {
-        if (isAnonymousDefault)
-            return;
-        // Find function declarations by name
-        const funcDecls = sourceFile.getDescendantsOfKind(SyntaxKind.FunctionDeclaration);
-        const funcNode = funcDecls.find((decl) => decl.getName() === name);
-        if (funcNode) {
-            identifiersToRename.push({ node: funcNode, newName: ssrName });
-            return;
-        }
-        // Find variable declarations by name
-        const varDecls = sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
-        const varNode = varDecls.find((decl) => decl.getName() === name);
-        if (varNode) {
-            const identifier = varNode.getFirstChildByKind(SyntaxKind.Identifier);
-            if (identifier) {
-                identifiersToRename.push({ node: identifier, newName: ssrName });
-            }
-        }
-    });
-    // Now apply the renames
-    identifiersToRename.forEach(({ node, newName }) => {
-        node.rename(newName);
-    });
-    // Pass 5: Add client reference registrations
-    // Add all declarations first
-    components.forEach(({ name, ssrName, isDefault, isAnonymousDefault }) => {
-        if (!isAnonymousDefault) {
-            sourceFile.addStatements(`const ${name} = registerClientReference("${relativeId}", "${isDefault ? "default" : name}", ${ssrName});`);
-        }
-    });
-    // Pass 6: add new exports
-    // Then add all exports after declarations
-    components.forEach(({ name, ssrName, isDefault }) => {
-        if (isDefault) {
-            // Export the registerClientReference version as default
-            sourceFile.addStatements(`export { ${name} as default, ${ssrName} };`);
-        }
-        else {
-            sourceFile.addStatements(`export { ${ssrName}, ${name} };`);
-        }
-    });
-    // Clean up any remaining export assignments
-    sourceFile
-        .getDescendantsOfKind(SyntaxKind.ExportAssignment)
-        .forEach((node) => {
-        // If it's not an arrow function (which we handle separately),
-        // just remove the export assignment
-        node.remove();
-    });
-    const emitOutput = sourceFile.getEmitOutput();
-    let sourceMap;
-    for (const outputFile of emitOutput.getOutputFiles()) {
-        if (outputFile.getFilePath().endsWith(".js.map")) {
-            sourceMap = JSON.parse(outputFile.getText());
-        }
-    }
-    return {
-        code: sourceFile.getFullText(),
-        map: sourceMap,
-    };
-}
-export const useClientPlugin = () => ({
-    name: "rwsdk:use-client",
-    async transform(code, id) {
-        if (id.includes(".vite/deps") ||
-            id.includes("node_modules") ||
-            this.environment.name !== "worker") {
-            return;
-        }
-        const relativeId = `/${relative(this.environment.getTopLevelConfig().root, id)}`;
-        return transformUseClientCode(code, relativeId);
-    },
-});

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

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