rwsdk 0.1.6 → 0.1.7-test.20250702144028

package/dist/vite/aliasedModuleResolver.mjs

@@ -1,62 +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 createAliasedModuleResolver({ getAliases, roots, conditionNames = ["workerd", "edge", "import", "default"], name = "aliasedModuleResolver", }) {
-    const log = debug("rwsdk:vite:aliased-module-resolver");
-    const logPrefix = `[${name}]`;
-    // Create a resolver instance with the provided conditionNames
-    const baseModuleResolver = enhancedResolve.create.sync({
-        conditionNames,
-    });
-    return function resolveModule(request, importer) {
-        log("%s Called with request: '%s', importer: '%s'", logPrefix, request, importer);
-        const aliasEntries = getAliases ? getAliases() : [];
-        log("%s Alias entries: %O", logPrefix, aliasEntries);
-        const normalized = applyAlias(request, aliasEntries, name);
-        log("%s After aliasing: '%s'", logPrefix, normalized);
-        const result = baseModuleResolver(normalized, path.dirname(importer));
-        if (result) {
-            log("%s Resolved %s relative to: '%s'", logPrefix, result, importer);
-            return result;
-        }
-        for (const root of roots) {
-            try {
-                const result = baseModuleResolver(root, normalized);
-                log("%s Resolved %s to: '%s' with root '%s'", logPrefix, normalized, 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/aliasedSSRResolver.d.mts

@@ -1,5 +0,0 @@
-export declare function createAliasedSSRResolver({ getResolveConfig, roots, name, }: {
-    getResolveConfig: () => any;
-    roots: string[];
-    name?: string;
-}): (request: string, importer: string) => string | false;

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 {};