rwsdk 0.1.5 → 0.1.6-test.20250702132719

package/dist/vite/aliasedSSRResolver.mjs

@@ -1,74 +0,0 @@
-import path from "path";
-import enhancedResolve from "enhanced-resolve";
-import debug from "debug";
-const baseSSRResolver = enhancedResolve.create.sync({
-    conditionNames: ["workerd", "edge", "import", "default"],
-});
-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-ssr-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-ssr-resolver")("%s [applyAlias] Matched RegExp alias: %O -> '%s' for request '%s'", logPrefix, find, replacement, request);
-                return request.replace(find, replacement);
-            }
-        }
-    }
-    return request;
-}
-export function createAliasedSSRResolver({ getResolveConfig, roots, name = "aliasedSSRResolver", }) {
-    const log = debug("rwsdk:vite:aliased-ssr-resolver");
-    const logPrefix = `[${name}]`;
-    return function resolveModule(request, importer) {
-        log("%s Called with request: '%s', importer: '%s'", logPrefix, request, importer);
-        let normalized = request;
-        const resolveConfig = getResolveConfig?.() || {};
-        const aliasEntries = resolveConfig.alias;
-        log("%s Alias entries: %O", logPrefix, aliasEntries);
-        normalized = applyAlias(normalized, aliasEntries, name);
-        log("%s After aliasing: '%s'", logPrefix, normalized);
-        let rootsToTry = roots && roots.length > 0 ? roots : [];
-        // If leading slash, treat as first root-rooted (for compatibility)
-        if (normalized.startsWith("/")) {
-            if (rootsToTry.length > 0) {
-                const rooted = path.join(rootsToTry[0], normalized);
-                log("%s Leading slash detected, resolving as root[0]-rooted: '%s'", logPrefix, rooted);
-                normalized = rooted;
-                rootsToTry = [rootsToTry[0]];
-            }
-        }
-        const isAbsolute = path.isAbsolute(normalized);
-        if (isAbsolute) {
-            log("%s Resolving absolute path: '%s'", logPrefix, normalized);
-            return normalized;
-        }
-        for (const root of rootsToTry) {
-            try {
-                log("%s Trying root: '%s'", logPrefix, root);
-                const result = baseSSRResolver(root, normalized);
-                log("%s Resolved to: '%s' with root '%s'", logPrefix, result, root);
-                return result;
-            }
-            catch (err) {
-                log("%s Resolution failed for '%s' from root '%s': %O", logPrefix, normalized, root, err);
-            }
-        }
-        return false;
-    };
-}

package/dist/vite/copyPrismaWasmPlugin.d.mts

@@ -1,4 +0,0 @@
-import { Plugin } from "vite";
-export declare const copyPrismaWasmPlugin: ({ rootDir, }: {
-    rootDir: string;
-}) => Plugin;

package/dist/vite/copyPrismaWasmPlugin.mjs

@@ -1,32 +0,0 @@
-import { copy, pathExists } from "fs-extra";
-import { resolve } from "node:path";
-import MagicString from "magic-string";
-import path from "path";
-export const copyPrismaWasmPlugin = ({ rootDir, }) => ({
-    name: "rwsdk:copy-prisma-wasm",
-    enforce: "post",
-    apply: "build",
-    async writeBundle() {
-        const wasmFilePath = resolve(rootDir, "node_modules/.prisma/client/query_engine_bg.wasm");
-        const fileName = path.basename(wasmFilePath);
-        const outputPath = path.resolve(rootDir, "dist", "worker", fileName);
-        if (await pathExists(wasmFilePath)) {
-            await copy(wasmFilePath, outputPath);
-            console.log(`✅ Copied ${fileName} from ${wasmFilePath} to ${outputPath}`);
-        }
-    },
-    renderChunk(code) {
-        if (!code.includes(".wasm")) {
-            return;
-        }
-        const s = new MagicString(code);
-        s.replace(/import\(["'](.+?\.wasm)["']\)/g, (_, filePath) => {
-            const fileName = path.basename(filePath);
-            return `import("./${fileName}")`;
-        });
-        return {
-            code: s.toString(),
-            map: s.generateMap(),
-        };
-    },
-});

package/dist/vite/ensureConfigArrays.d.mts

@@ -1 +0,0 @@
-export declare const ensureConfigArrays: (config: any) => void;

package/dist/vite/ensureConfigArrays.mjs

@@ -1,12 +0,0 @@
-export const ensureConfigArrays = (config) => {
-    config.optimizeDeps ??= {};
-    config.optimizeDeps.include ??= [];
-    config.optimizeDeps.esbuildOptions ??= {};
-    config.optimizeDeps.esbuildOptions.plugins ??= [];
-    config.resolve ??= {};
-    config.resolve.alias ??= [];
-    if (!Array.isArray(config.resolve.alias)) {
-        const aliasObj = config.resolve.alias;
-        config.resolve.alias = Object.entries(aliasObj).map(([find, replacement]) => ({ find, replacement }));
-    }
-};

package/dist/vite/findImportSpecifiers.d.mts

@@ -1,30 +0,0 @@
-export declare const IMPORT_PATTERNS: string[];
-export declare const EXPORT_PATTERNS: string[];
-export interface ExportInfo {
-    name: string;
-    isDefault: boolean;
-    alias?: 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/findImportSpecifiers.mjs

@@ -1,228 +0,0 @@
-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,
-                                    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.mjs

@@ -1,73 +0,0 @@
-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/isBareImport.d.mts

@@ -1 +0,0 @@
-export declare function isBareImport(importPath: string): boolean;

package/dist/vite/isBareImport.mjs

@@ -1,5 +0,0 @@
-export function isBareImport(importPath) {
-    return (!importPath.startsWith(".") &&
-        !importPath.startsWith("/") &&
-        !importPath.startsWith("virtual:"));
-}

package/dist/vite/miniflarePlugin.d.mts

@@ -1,9 +0,0 @@
-import { Plugin } from "vite";
-import { cloudflare } from "@cloudflare/vite-plugin";
-type BasePluginOptions = Parameters<typeof cloudflare>[0];
-type MiniflarePluginOptions = BasePluginOptions & {};
-export declare const miniflarePlugin: (givenOptions: MiniflarePluginOptions & {
-    rootDir: string;
-    workerEntryPathname: string;
-}) => (Plugin | Plugin[])[];
-export {};

package/dist/vite/miniflarePlugin.mjs

@@ -1,135 +0,0 @@
-import { cloudflare } from "@cloudflare/vite-plugin";
-import { resolve } from "node:path";
-import colors from "picocolors";
-import { readFile } from "node:fs/promises";
-import { getShortName } from "../lib/getShortName.mjs";
-import { pathExists } from "fs-extra";
-const hasEntryAsAncestor = (module, entryFile, seen = new Set()) => {
-    // Prevent infinite recursion
-    if (seen.has(module))
-        return false;
-    seen.add(module);
-    // Check direct importers
-    for (const importer of module.importers) {
-        if (importer.file === entryFile)
-            return true;
-        // Recursively check importers
-        if (hasEntryAsAncestor(importer, entryFile, seen))
-            return true;
-    }
-    return false;
-};
-// Cache for "use client" status results
-const useClientCache = new Map();
-// Function to invalidate cache for a file
-const invalidateUseClientCache = (file) => {
-    useClientCache.delete(file);
-};
-const isUseClientModule = async (ctx, file, seen = new Set()) => {
-    // Prevent infinite recursion
-    if (seen.has(file))
-        return false;
-    seen.add(file);
-    try {
-        // Check cache first
-        if (useClientCache.has(file)) {
-            return useClientCache.get(file);
-        }
-        // Read and check the file
-        const content = (await pathExists(file))
-            ? await readFile(file, "utf-8")
-            : "";
-        const hasUseClient = content.includes("'use client'") || content.includes('"use client"');
-        if (hasUseClient) {
-            useClientCache.set(file, true);
-            return true;
-        }
-        // Get the module from the module graph to find importers
-        const module = ctx.server.moduleGraph.getModuleById(file);
-        if (!module) {
-            useClientCache.set(file, false);
-            return false;
-        }
-        // Check all importers recursively
-        for (const importer of module.importers) {
-            if (await isUseClientModule(ctx, importer.url, seen)) {
-                useClientCache.set(file, true);
-                return true;
-            }
-        }
-        useClientCache.set(file, false);
-        return false;
-    }
-    catch (error) {
-        useClientCache.set(file, false);
-        return false;
-    }
-};
-export const miniflarePlugin = (givenOptions) => [
-    cloudflare(givenOptions),
-    {
-        name: "rwsdk:miniflare-hmr",
-        async hotUpdate(ctx) {
-            const environment = givenOptions.viteEnvironment?.name ?? "worker";
-            const entry = givenOptions.workerEntryPathname;
-            if (!["client", environment].includes(this.environment.name)) {
-                return;
-            }
-            // todo(justinvdm, 12 Dec 2024): Skip client references
-            const modules = Array.from(ctx.server.environments[environment].moduleGraph.getModulesByFile(ctx.file) ?? []);
-            const isWorkerUpdate = ctx.file === entry ||
-                modules.some((module) => hasEntryAsAncestor(module, entry));
-            // The worker doesnt need an update
-            // => Short circuit HMR
-            if (!isWorkerUpdate) {
-                return [];
-            }
-            // The worker needs an update, but this is the client environment
-            // => Notify for HMR update of any css files imported by in worker, that are also in the client module graph
-            // Why: There may have been changes to css classes referenced, which might css modules to change
-            if (this.environment.name === "client") {
-                const cssModules = [];
-                for (const [_, module] of ctx.server.environments[environment]
-                    .moduleGraph.idToModuleMap) {
-                    // todo(justinvdm, 13 Dec 2024): We check+update _all_ css files in worker module graph,
-                    // but it could just be a subset of css files that are actually affected, depending
-                    // on the importers and imports of the changed file. We should be smarter about this.
-                    if (module.file && module.file.endsWith(".css")) {
-                        const clientModules = ctx.server.environments.client.moduleGraph.getModulesByFile(module.file);
-                        if (clientModules) {
-                            cssModules.push(...clientModules.values());
-                        }
-                    }
-                }
-                invalidateUseClientCache(ctx.file);
-                return (await isUseClientModule(ctx, ctx.file))
-                    ? [...ctx.modules, ...cssModules]
-                    : cssModules;
-            }
-            // The worker needs an update, and the hot check is for the worker environment
-            // => Notify for custom RSC-based HMR update, then short circuit HMR
-            if (isWorkerUpdate && this.environment.name === environment) {
-                const shortName = getShortName(ctx.file, ctx.server.config.root);
-                this.environment.logger.info(`${colors.green(`worker update`)} ${colors.dim(shortName)}`, {
-                    clear: true,
-                    timestamp: true,
-                });
-                const m = ctx.server.environments.client.moduleGraph
-                    .getModulesByFile(resolve(givenOptions.rootDir, "src", "app", "style.css"))
-                    ?.values()
-                    .next().value;
-                if (m) {
-                    ctx.server.environments.client.moduleGraph.invalidateModule(m, new Set(), ctx.timestamp, true);
-                }
-                ctx.server.environments.client.hot.send({
-                    type: "custom",
-                    event: "rsc:update",
-                    data: {
-                        file: ctx.file,
-                    },
-                });
-                return [];
-            }
-        },
-    },
-];

package/dist/vite/moduleResolver.d.mts

@@ -1,10 +0,0 @@
-export type ModuleResolver = ReturnType<typeof createModuleResolver>;
-export declare function createModuleResolver({ getAliases, roots, conditionNames, name, }: {
-    getAliases?: () => Array<{
-        find: string | RegExp;
-        replacement: string;
-    }>;
-    roots: string[];
-    conditionNames?: string[];
-    name: string;
-}): (request: string, importer?: string) => string | false;