rwsdk 0.1.0-alpha.8 → 0.1.0

package/dist/vite/findImportSpecifiers.mjs

@@ -24,6 +24,23 @@ export const IMPORT_PATTERNS = [
     "require('$MODULE')",
     "require(`$MODULE`)",
 ];
+// These patterns are used to match export statements for client/server component transformations
+export const EXPORT_PATTERNS = [
+    // Named exports
+    "export const $NAME = $$$",
+    "export let $NAME = $$$",
+    "export var $NAME = $$$",
+    "export function $NAME($$$) { $$$ }",
+    "export async function $NAME($$$) { $$$ }",
+    // Default exports
+    "export default function $NAME($$$) { $$$ }",
+    "export default function($$$) { $$$ }",
+    "export default $$$",
+    // Export declarations
+    "export { $$$ }",
+    'export { $$$ } from "$MODULE"',
+    "export { $$$ } from '$MODULE'",
+];
 /**
  * Finds import specifiers and their positions in the code using the provided patterns.
  * @param code The code to search for import specifiers.
@@ -74,3 +91,138 @@ export function findImportSpecifiers(id, code, ignoredImportPatterns, log) {
     }
     return results;
 }
+/**
+ * Finds export information in the code using ast-grep patterns.
+ * @param id The file identifier for language detection.
+ * @param code The code to search for exports.
+ * @param log Optional logger function for debug output.
+ * @returns Array of export information objects.
+ */
+export function findExports(id, code, log) {
+    const ext = path.extname(id).toLowerCase();
+    const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+    const logger = log ?? (() => { });
+    const results = [];
+    const seen = new Set(); // Track seen exports to avoid duplicates
+    try {
+        const root = sgParse(lang, code);
+        // Use the existing EXPORT_PATTERNS in a specific order to avoid duplicates
+        const orderedPatterns = [
+            // Handle re-exports first (most specific)
+            ...EXPORT_PATTERNS.filter((p) => p.includes('from "$MODULE"') || p.includes("from '$MODULE'")),
+            // Then named exports
+            ...EXPORT_PATTERNS.filter((p) => p.startsWith("export const") ||
+                p.startsWith("export let") ||
+                p.startsWith("export var") ||
+                p.startsWith("export function") ||
+                p.startsWith("export async function")),
+            // Then default exports
+            ...EXPORT_PATTERNS.filter((p) => p.startsWith("export default")),
+            // Finally export declarations
+            ...EXPORT_PATTERNS.filter((p) => p === "export { $$$ }"),
+        ];
+        for (const pattern of orderedPatterns) {
+            try {
+                const matches = root.root().findAll(pattern);
+                for (const match of matches) {
+                    const nameCapture = match.getMatch("NAME");
+                    const moduleCapture = match.getMatch("MODULE");
+                    const matchText = match.text();
+                    if (pattern.includes('from "$MODULE"') ||
+                        pattern.includes("from '$MODULE'")) {
+                        // Re-export from module
+                        const moduleSpecifier = moduleCapture?.text();
+                        if (!moduleSpecifier)
+                            continue;
+                        if (pattern.includes("export *")) {
+                            // Skip export * for now - too complex
+                            logger("Skipping export * from %s", moduleSpecifier);
+                            continue;
+                        }
+                        // Parse the export list
+                        const exportListMatch = matchText.match(/export\s*\{\s*([^}]+)\s*\}/);
+                        if (exportListMatch) {
+                            const exportList = exportListMatch[1];
+                            const exports = exportList.split(",").map((e) => e.trim());
+                            for (const exp of exports) {
+                                const [originalName, alias] = exp.includes(" as ")
+                                    ? exp.split(" as ").map((s) => s.trim())
+                                    : [exp.trim(), undefined];
+                                const exportName = alias || originalName;
+                                const key = `${exportName}:${originalName === "default"}:reexport:${moduleSpecifier}`;
+                                if (seen.has(key))
+                                    continue;
+                                seen.add(key);
+                                results.push({
+                                    name: exportName,
+                                    isDefault: originalName === "default",
+                                    alias: alias !== originalName ? alias : undefined,
+                                    isReExport: true,
+                                    moduleSpecifier,
+                                });
+                                logger("Found re-export: %s from %s", exportName, moduleSpecifier);
+                            }
+                        }
+                    }
+                    else if (matchText.startsWith("export default")) {
+                        // Default export
+                        const name = nameCapture?.text() || "default";
+                        const key = `${name}:true:default`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        results.push({
+                            name,
+                            isDefault: true,
+                        });
+                        logger("Found default export: %s", name);
+                    }
+                    else if (matchText.includes("export {")) {
+                        // Local export declaration
+                        const exportListMatch = matchText.match(/export\s*\{\s*([^}]+)\s*\}/);
+                        if (exportListMatch) {
+                            const exportList = exportListMatch[1];
+                            const exports = exportList.split(",").map((e) => e.trim());
+                            for (const exp of exports) {
+                                const [originalName, alias] = exp.includes(" as ")
+                                    ? exp.split(" as ").map((s) => s.trim())
+                                    : [exp.trim(), undefined];
+                                const exportName = alias || originalName;
+                                const key = `${exportName}:${originalName === "default"}:local`;
+                                if (seen.has(key))
+                                    continue;
+                                seen.add(key);
+                                results.push({
+                                    name: exportName,
+                                    isDefault: originalName === "default",
+                                    alias: alias !== originalName ? alias : undefined,
+                                });
+                                logger("Found local export: %s", exportName);
+                            }
+                        }
+                    }
+                    else if (nameCapture) {
+                        // Named export (function, const, etc.)
+                        const name = nameCapture.text();
+                        const key = `${name}:false:named`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        results.push({
+                            name,
+                            isDefault: false,
+                        });
+                        logger("Found named export: %s", name);
+                    }
+                }
+            }
+            catch (err) {
+                logger("Error processing export pattern %s: %O", pattern, err);
+            }
+        }
+    }
+    catch (err) {
+        logger("Error parsing code for exports: %O", err);
+    }
+    return results;
+}

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

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

package/dist/vite/findImportSpecifiers.test.mjs

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "vitest";
+import { findExports } from "./findImportSpecifiers.mjs";
+describe("findExports", () => {
+    it("finds named exports", () => {
+        const code = `
+export const Component = () => {};
+export function helper() {}
+export let data = {};
+`;
+        const exports = findExports("/test.tsx", code);
+        // Just check that we found the exports, order doesn't matter for our use case
+        const names = exports.map((e) => e.name).sort();
+        expect(names).toEqual(["Component", "data", "helper"]);
+        // Check that none are default
+        expect(exports.every((e) => !e.isDefault)).toBe(true);
+    });
+    it("finds default exports", () => {
+        const code = `
+export default function Component() {}
+`;
+        const exports = findExports("/test.tsx", code);
+        // Should find at least one default export
+        const defaultExports = exports.filter((e) => e.isDefault);
+        expect(defaultExports.length).toBeGreaterThan(0);
+        expect(defaultExports.some((e) => e.name === "Component")).toBe(true);
+    });
+    it("finds export declarations", () => {
+        const code = `
+const First = () => {};
+const Second = () => {};
+export { First, Second };
+`;
+        const exports = findExports("/test.tsx", code);
+        const names = exports.map((e) => e.name).sort();
+        expect(names).toEqual(["First", "Second"]);
+    });
+    it("finds export declarations with aliases", () => {
+        const code = `
+const Component = () => {};
+export { Component as MyComponent };
+`;
+        const exports = findExports("/test.tsx", code);
+        expect(exports.some((e) => e.name === "MyComponent")).toBe(true);
+    });
+    it("finds re-exports", () => {
+        const code = `
+export { sum } from './math';
+export { default as multiply } from './multiply';
+`;
+        const exports = findExports("/test.tsx", code);
+        // Should find re-exports
+        const reExports = exports.filter((e) => e.isReExport);
+        expect(reExports.length).toBeGreaterThan(0);
+        const names = reExports.map((e) => e.name).sort();
+        expect(names).toContain("sum");
+        expect(names).toContain("multiply");
+    });
+    it("handles mixed export styles", () => {
+        const code = `
+export const First = () => {};
+const Second = () => {};
+export default function Main() {}
+export { Second };
+`;
+        const exports = findExports("/test.tsx", code);
+        const names = exports.map((e) => e.name);
+        expect(names).toContain("First");
+        expect(names).toContain("Second");
+        // Should have at least one default export
+        const defaultExports = exports.filter((e) => e.isDefault);
+        expect(defaultExports.length).toBeGreaterThan(0);
+    });
+});

package/dist/vite/findSpecifiers.d.mts

@@ -0,0 +1,31 @@
+export declare const IMPORT_PATTERNS: string[];
+export declare const EXPORT_PATTERNS: string[];
+export interface ExportInfo {
+    name: string;
+    isDefault: boolean;
+    alias?: string;
+    originalName?: string;
+    isReExport?: boolean;
+    moduleSpecifier?: string;
+}
+/**
+ * Finds import specifiers and their positions in the code using the provided patterns.
+ * @param code The code to search for import specifiers.
+ * @param lang The language parser to use (TypeScript or Tsx).
+ * @param ignoredImportPatterns Array of regex patterns to ignore.
+ * @param log Optional logger function for debug output.
+ * @returns Array of objects with start, end, and raw import string.
+ */
+export declare function findImportSpecifiers(id: string, code: string, ignoredImportPatterns: RegExp[], log?: (...args: any[]) => void): Array<{
+    s: number;
+    e: number;
+    raw: string;
+}>;
+/**
+ * Finds export information in the code using ast-grep patterns.
+ * @param id The file identifier for language detection.
+ * @param code The code to search for exports.
+ * @param log Optional logger function for debug output.
+ * @returns Array of export information objects.
+ */
+export declare function findExports(id: string, code: string, log?: (...args: any[]) => void): ExportInfo[];

package/dist/vite/findSpecifiers.mjs

@@ -0,0 +1,230 @@
+import { parse as sgParse, Lang as SgLang, Lang } from "@ast-grep/napi";
+import path from "path";
+// These patterns are used to match import statements in code for SSR transformations.
+export const IMPORT_PATTERNS = [
+    'import { $$$ } from "$MODULE"',
+    "import { $$$ } from '$MODULE'",
+    'import $DEFAULT from "$MODULE"',
+    "import $DEFAULT from '$MODULE'",
+    'import * as $NS from "$MODULE"',
+    "import * as $NS from '$MODULE'",
+    'import "$MODULE"',
+    "import '$MODULE'",
+    // Static Re-exports
+    'export { $$$ } from "$MODULE"',
+    "export { $$$ } from '$MODULE'",
+    'export * from "$MODULE"',
+    "export * from '$MODULE'",
+    // Dynamic Imports
+    'import("$MODULE")',
+    "import('$MODULE')",
+    "import(`$MODULE`)",
+    // CommonJS require
+    'require("$MODULE")',
+    "require('$MODULE')",
+    "require(`$MODULE`)",
+];
+// These patterns are used to match export statements for client/server component transformations
+export const EXPORT_PATTERNS = [
+    // Named exports
+    "export const $NAME = $$$",
+    "export let $NAME = $$$",
+    "export var $NAME = $$$",
+    "export function $NAME($$$) { $$$ }",
+    "export async function $NAME($$$) { $$$ }",
+    // Default exports
+    "export default function $NAME($$$) { $$$ }",
+    "export default function($$$) { $$$ }",
+    "export default $$$",
+    // Export declarations
+    "export { $$$ }",
+    'export { $$$ } from "$MODULE"',
+    "export { $$$ } from '$MODULE'",
+];
+/**
+ * Finds import specifiers and their positions in the code using the provided patterns.
+ * @param code The code to search for import specifiers.
+ * @param lang The language parser to use (TypeScript or Tsx).
+ * @param ignoredImportPatterns Array of regex patterns to ignore.
+ * @param log Optional logger function for debug output.
+ * @returns Array of objects with start, end, and raw import string.
+ */
+export function findImportSpecifiers(id, code, ignoredImportPatterns, log) {
+    const ext = path.extname(id).toLowerCase();
+    const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+    const logger = log ?? (() => { });
+    const results = [];
+    try {
+        // sgParse and lang must be provided by the consumer
+        const root = sgParse(lang, code);
+        for (const pattern of IMPORT_PATTERNS) {
+            try {
+                const matches = root.root().findAll(pattern);
+                for (const match of matches) {
+                    const moduleCapture = match.getMatch("MODULE");
+                    if (moduleCapture) {
+                        const importPath = moduleCapture.text();
+                        if (importPath.startsWith("virtual:")) {
+                            logger(":findImportSpecifiersWithPositions: Ignoring import because it starts with 'virtual:': importPath=%s", importPath);
+                        }
+                        else if (importPath.includes("__rwsdknossr")) {
+                            logger(":findImportSpecifiersWithPositions: Ignoring import because it includes '__rwsdknossr': importPath=%s", importPath);
+                        }
+                        else if (ignoredImportPatterns.some((pattern) => pattern.test(importPath))) {
+                            logger(":findImportSpecifiersWithPositions: Ignoring import because it matches IGNORED_IMPORT_PATTERNS: importPath=%s", importPath);
+                        }
+                        else {
+                            const { start, end } = moduleCapture.range();
+                            results.push({ s: start.index, e: end.index, raw: importPath });
+                            logger(":findImportSpecifiersWithPositions: Including import specifier: importPath=%s, range=[%d, %d]", importPath, start.index, end.index);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                logger(":findImportSpecifiersWithPositions: Error processing pattern: %O", err);
+            }
+        }
+    }
+    catch (err) {
+        logger(":findImportSpecifiersWithPositions: Error parsing content: %O", err);
+    }
+    return results;
+}
+/**
+ * Finds export information in the code using ast-grep patterns.
+ * @param id The file identifier for language detection.
+ * @param code The code to search for exports.
+ * @param log Optional logger function for debug output.
+ * @returns Array of export information objects.
+ */
+export function findExports(id, code, log) {
+    const ext = path.extname(id).toLowerCase();
+    const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+    const logger = log ?? (() => { });
+    const results = [];
+    const seen = new Set(); // Track seen exports to avoid duplicates
+    try {
+        const root = sgParse(lang, code);
+        // Use the existing EXPORT_PATTERNS in a specific order to avoid duplicates
+        const orderedPatterns = [
+            // Handle re-exports first (most specific)
+            ...EXPORT_PATTERNS.filter((p) => p.includes('from "$MODULE"') || p.includes("from '$MODULE'")),
+            // Then named exports
+            ...EXPORT_PATTERNS.filter((p) => p.startsWith("export const") ||
+                p.startsWith("export let") ||
+                p.startsWith("export var") ||
+                p.startsWith("export function") ||
+                p.startsWith("export async function")),
+            // Then default exports
+            ...EXPORT_PATTERNS.filter((p) => p.startsWith("export default")),
+            // Finally export declarations
+            ...EXPORT_PATTERNS.filter((p) => p === "export { $$$ }"),
+        ];
+        for (const pattern of orderedPatterns) {
+            try {
+                const matches = root.root().findAll(pattern);
+                for (const match of matches) {
+                    const nameCapture = match.getMatch("NAME");
+                    const moduleCapture = match.getMatch("MODULE");
+                    const matchText = match.text();
+                    if (pattern.includes('from "$MODULE"') ||
+                        pattern.includes("from '$MODULE'")) {
+                        // Re-export from module
+                        const moduleSpecifier = moduleCapture?.text();
+                        if (!moduleSpecifier)
+                            continue;
+                        if (pattern.includes("export *")) {
+                            // Skip export * for now - too complex
+                            logger("Skipping export * from %s", moduleSpecifier);
+                            continue;
+                        }
+                        // Parse the export list
+                        const exportListMatch = matchText.match(/export\s*\{\s*([^}]+)\s*\}/);
+                        if (exportListMatch) {
+                            const exportList = exportListMatch[1];
+                            const exports = exportList.split(",").map((e) => e.trim());
+                            for (const exp of exports) {
+                                const [originalName, alias] = exp.includes(" as ")
+                                    ? exp.split(" as ").map((s) => s.trim())
+                                    : [exp.trim(), undefined];
+                                const exportName = alias || originalName;
+                                const key = `${exportName}:${originalName === "default"}:reexport:${moduleSpecifier}`;
+                                if (seen.has(key))
+                                    continue;
+                                seen.add(key);
+                                results.push({
+                                    name: exportName,
+                                    isDefault: originalName === "default",
+                                    alias: alias !== originalName ? alias : undefined,
+                                    originalName: originalName,
+                                    isReExport: true,
+                                    moduleSpecifier,
+                                });
+                                logger("Found re-export: %s from %s", exportName, moduleSpecifier);
+                            }
+                        }
+                    }
+                    else if (matchText.startsWith("export default")) {
+                        // Default export
+                        const name = nameCapture?.text() || "default";
+                        const key = `${name}:true:default`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        results.push({
+                            name,
+                            isDefault: true,
+                        });
+                        logger("Found default export: %s", name);
+                    }
+                    else if (matchText.includes("export {")) {
+                        // Local export declaration
+                        const exportListMatch = matchText.match(/export\s*\{\s*([^}]+)\s*\}/);
+                        if (exportListMatch) {
+                            const exportList = exportListMatch[1];
+                            const exports = exportList.split(",").map((e) => e.trim());
+                            for (const exp of exports) {
+                                const [originalName, alias] = exp.includes(" as ")
+                                    ? exp.split(" as ").map((s) => s.trim())
+                                    : [exp.trim(), undefined];
+                                const exportName = alias || originalName;
+                                const key = `${exportName}:${originalName === "default"}:local`;
+                                if (seen.has(key))
+                                    continue;
+                                seen.add(key);
+                                results.push({
+                                    name: exportName,
+                                    isDefault: originalName === "default",
+                                    alias: alias !== originalName ? alias : undefined,
+                                    originalName: originalName,
+                                });
+                                logger("Found local export: %s", exportName);
+                            }
+                        }
+                    }
+                    else if (nameCapture) {
+                        // Named export (function, const, etc.)
+                        const name = nameCapture.text();
+                        const key = `${name}:false:named`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        results.push({
+                            name,
+                            isDefault: false,
+                        });
+                        logger("Found named export: %s", name);
+                    }
+                }
+            }
+            catch (err) {
+                logger("Error processing export pattern %s: %O", pattern, err);
+            }
+        }
+    }
+    catch (err) {
+        logger("Error parsing code for exports: %O", err);
+    }
+    return results;
+}

package/dist/vite/hasDirective.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Efficiently checks if a React directive (e.g., "use server", "use client")
+ * is present in the code. Optimized for performance with a two-step approach:
+ * 1. Quick string search to see if directive exists anywhere
+ * 2. Line-by-line check only if the directive might be present
+ */
+export declare function hasDirective(code: string, directive: string): boolean;

package/dist/vite/hasDirective.mjs

@@ -0,0 +1,54 @@
+/**
+ * Efficiently checks if a React directive (e.g., "use server", "use client")
+ * is present in the code. Optimized for performance with a two-step approach:
+ * 1. Quick string search to see if directive exists anywhere
+ * 2. Line-by-line check only if the directive might be present
+ */
+export function hasDirective(code, directive) {
+    // Quick performance check: if directive doesn't exist anywhere, skip line checking
+    const singleQuoteDirective = `'${directive}'`;
+    const doubleQuoteDirective = `"${directive}"`;
+    if (!code.includes(singleQuoteDirective) &&
+        !code.includes(doubleQuoteDirective)) {
+        return false;
+    }
+    // Split into lines and check each one
+    const lines = code.split("\n");
+    let inMultiLineComment = false;
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        // Skip empty lines
+        if (trimmedLine.length === 0) {
+            continue;
+        }
+        // Handle multi-line comments
+        if (trimmedLine.startsWith("/*")) {
+            inMultiLineComment = true;
+            // Check if the comment ends on the same line
+            if (trimmedLine.includes("*/")) {
+                inMultiLineComment = false;
+            }
+            continue;
+        }
+        if (inMultiLineComment) {
+            // Check if this line ends the multi-line comment
+            if (trimmedLine.includes("*/")) {
+                inMultiLineComment = false;
+            }
+            continue;
+        }
+        // Skip single-line comments
+        if (trimmedLine.startsWith("//")) {
+            continue;
+        }
+        // Check if this line starts with the directive
+        if (trimmedLine.startsWith(doubleQuoteDirective) ||
+            trimmedLine.startsWith(singleQuoteDirective)) {
+            return true;
+        }
+        // If we hit a non-empty, non-comment line that's not a directive, we can stop
+        // (directives must be at the top of the file/scope, after comments)
+        break;
+    }
+    return false;
+}

package/dist/vite/hasOwnCloudflareVitePlugin.d.mts

@@ -0,0 +1,3 @@
+export declare function hasOwnCloudflareVitePlugin({ rootProjectDir, }: {
+    rootProjectDir: string;
+}): Promise<boolean>;

package/dist/vite/hasOwnCloudflareVitePlugin.mjs

@@ -0,0 +1,14 @@
+import { readFile } from "fs/promises";
+import path from "path";
+export async function hasOwnCloudflareVitePlugin({ rootProjectDir, }) {
+    const packageJsonPath = path.join(rootProjectDir, "package.json");
+    try {
+        const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+        return !!(packageJson.dependencies?.["@cloudflare/vite-plugin"] ||
+            packageJson.devDependencies?.["@cloudflare/vite-plugin"]);
+    }
+    catch (error) {
+        console.error("Error reading package.json:", error);
+        return false;
+    }
+}

package/dist/vite/invalidateModule.d.mts

@@ -0,0 +1,2 @@
+import type { ViteDevServer } from "vite";
+export declare const invalidateModule: (devServer: ViteDevServer, environment: string, id: string) => void;

package/dist/vite/invalidateModule.mjs

@@ -0,0 +1,14 @@
+import debug from "debug";
+const log = debug("rwsdk:vite:invalidate-module");
+const verboseLog = debug("verbose:rwsdk:vite:invalidate-module");
+export const invalidateModule = (devServer, environment, id) => {
+    const [rawId, _query] = id.split("?");
+    log("Invalidating module: id=%s, environment=%s", id, environment);
+    const moduleNode = devServer?.environments[environment]?.moduleGraph.idToModuleMap.get(rawId);
+    if (moduleNode) {
+        devServer?.environments[environment]?.moduleGraph.invalidateModule(moduleNode);
+    }
+    else {
+        verboseLog("Module not found: id=%s, environment=%s", id, environment);
+    }
+};

package/dist/vite/miniflareHMRPlugin.d.mts

@@ -0,0 +1,8 @@
+import { Plugin } from "vite";
+export declare const miniflareHMRPlugin: (givenOptions: {
+    rootDir: string;
+    viteEnvironment: {
+        name: string;
+    };
+    workerEntryPathname: string;
+}) => (Plugin | Plugin[])[];