rwsdk 1.0.0-alpha.2 → 1.0.0-alpha.20-test.20250929144616

package/dist/vite/buildApp.d.mts

@@ -6,10 +6,11 @@ import type { ViteBuilder } from "vite";
  *
  * @see docs/architecture/productionBuildProcess.md
  */
-export declare function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, }: {
+export declare function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, workerEntryPathname, }: {
     builder: ViteBuilder;
     clientEntryPoints: Set<string>;
     clientFiles: Set<string>;
     serverFiles: Set<string>;
     projectRootDir: string;
+    workerEntryPathname: string;
 }): Promise<void>;

package/dist/vite/buildApp.mjs

@@ -1,5 +1,5 @@
-import { resolve } from "node:path";
 import debug from "debug";
+import { resolve } from "node:path";
 import { runDirectivesScan } from "./runDirectivesScan.mjs";
 const log = debug("rwsdk:vite:build-app");
 /**
@@ -9,13 +9,14 @@ const log = debug("rwsdk:vite:build-app");
  *
  * @see docs/architecture/productionBuildProcess.md
  */
-export async function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, }) {
+export async function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, workerEntryPathname, }) {
     const workerEnv = builder.environments.worker;
     await runDirectivesScan({
         rootConfig: builder.config,
         environments: builder.environments,
         clientFiles,
         serverFiles,
+        entries: [workerEntryPathname],
     });
     console.log("Building worker to discover used client components...");
     process.env.RWSDK_BUILD_PASS = "worker";
@@ -42,11 +43,14 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
     // Re-configure the worker environment for the linking pass
     const workerConfig = workerEnv.config;
     workerConfig.build.emptyOutDir = false;
+    // context(justinvdm, 22 Sep 2025): This is a workaround to satisfy the
+    // Cloudflare plugin's expectation of an entry chunk named `index`. The plugin
+    // now manages the worker build, so we no longer set rollup options
+    // directly. Instead, we re-point the original entry to the intermediate
+    // worker bundle from the first pass. This allows the linker pass to re-use
+    // the same plugin-driven configuration while bundling the final worker.
     workerConfig.build.rollupOptions.input = {
-        worker: resolve(projectRootDir, "dist", "worker", "worker.js"),
-    };
-    workerConfig.build.rollupOptions.output = {
-        entryFileNames: "worker.js",
+        index: resolve(projectRootDir, "dist", "worker", "index.js"),
     };
     await builder.build(workerEnv);
     console.log("Build complete!");

package/dist/vite/checkIsUsingPrisma.d.mts

@@ -1,6 +1,10 @@
 export type PrismaCheckResult = {
     isUsingPrisma: boolean;
 };
+export declare const isUsingPrisma: ({ projectRootDir, resolver, }: {
+    projectRootDir: string;
+    resolver?: (path: string, request: string) => string | false;
+}) => boolean;
 export declare const checkPrismaStatus: ({ projectRootDir, }: {
     projectRootDir: string;
 }) => PrismaCheckResult;

package/dist/vite/checkIsUsingPrisma.mjs

@@ -1,7 +1,7 @@
 import enhancedResolve from "enhanced-resolve";
-const isUsingPrisma = ({ projectRootDir }) => {
+export const isUsingPrisma = ({ projectRootDir, resolver = enhancedResolve.sync, }) => {
     try {
-        const prismaClientPath = enhancedResolve.sync(projectRootDir, "@prisma/client");
+        const prismaClientPath = resolver(projectRootDir, "@prisma/client");
         if (!prismaClientPath) {
             return false;
         }

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

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

package/dist/vite/checkIsUsingPrisma.test.mjs

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { isUsingPrisma } from "./checkIsUsingPrisma.mjs";
+describe("isUsingPrisma", () => {
+    it("should return true if prisma client is resolved", () => {
+        const resolver = () => "/path/to/prisma/client";
+        const result = isUsingPrisma({
+            projectRootDir: "/test/project",
+            resolver: resolver,
+        });
+        expect(result).toBe(true);
+    });
+    it("should return false if prisma client is not resolved", () => {
+        const resolver = () => false;
+        const result = isUsingPrisma({
+            projectRootDir: "/test/project",
+            resolver: resolver,
+        });
+        expect(result).toBe(false);
+    });
+    it("should return false if resolver throws", () => {
+        const resolver = () => {
+            throw new Error("Module not found");
+        };
+        const result = isUsingPrisma({
+            projectRootDir: "/test/project",
+            resolver: resolver,
+        });
+        expect(result).toBe(false);
+    });
+});

package/dist/vite/configPlugin.mjs

@@ -1,13 +1,11 @@
-import path, { resolve } from "node:path";
 import enhancedResolve from "enhanced-resolve";
-import debug from "debug";
+import path, { resolve } from "node:path";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import { buildApp } from "./buildApp.mjs";
 import { externalModules } from "./constants.mjs";
-const log = debug("rwsdk:vite:config");
 export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clientFiles, serverFiles, clientEntryPoints, }) => ({
     name: "rwsdk:config",
-    config: async (_) => {
+    config: async (_, { command }) => {
         const mode = process.env.NODE_ENV;
         const workerConfig = {
             resolve: {
@@ -33,7 +31,17 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
             },
             optimizeDeps: {
                 noDiscovery: false,
-                include: ["rwsdk/worker"],
+                include: [
+                    "rwsdk/__ssr_bridge",
+                    "rwsdk/auth",
+                    "rwsdk/constants",
+                    "rwsdk/db",
+                    "rwsdk/debug",
+                    "rwsdk/realtime/durableObject",
+                    "rwsdk/realtime/worker",
+                    "rwsdk/router",
+                    "rwsdk/worker",
+                ],
                 exclude: [],
                 entries: [workerEntryPathname],
                 esbuildOptions: {
@@ -49,14 +57,6 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                 emitAssets: true,
                 emptyOutDir: false,
                 ssr: true,
-                rollupOptions: {
-                    output: {
-                        inlineDynamicImports: true,
-                    },
-                    input: {
-                        worker: workerEntryPathname,
-                    },
-                },
             },
         };
         const baseConfig = {
@@ -88,7 +88,13 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                     },
                     optimizeDeps: {
                         noDiscovery: false,
-                        include: ["rwsdk/client"],
+                        include: [
+                            "rwsdk/client",
+                            "rwsdk/constants",
+                            "rwsdk/debug",
+                            "rwsdk/realtime/client",
+                            "rwsdk/turnstile",
+                        ],
                         entries: [],
                         esbuildOptions: {
                             jsx: "automatic",
@@ -115,7 +121,18 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                         noDiscovery: false,
                         entries: [workerEntryPathname],
                         exclude: externalModules,
-                        include: ["rwsdk/__ssr", "rwsdk/__ssr_bridge"],
+                        include: [
+                            "rwsdk/__ssr",
+                            "rwsdk/__ssr_bridge",
+                            "rwsdk/client",
+                            "rwsdk/constants",
+                            "rwsdk/debug",
+                            "rwsdk/realtime/client",
+                            "rwsdk/router",
+                            "rwsdk/worker",
+                            "rwsdk/realtime/durableObject",
+                            "rwsdk/realtime/worker",
+                        ],
                         esbuildOptions: {
                             jsx: "automatic",
                             jsxImportSource: "react",
@@ -136,8 +153,30 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                         outDir: path.dirname(INTERMEDIATE_SSR_BRIDGE_PATH),
                         rollupOptions: {
                             output: {
+                                // context(justinvdm, 15 Sep 2025): The SSR bundle is a
+                                // pre-compiled artifact. When the linker pass bundles it into
+                                // the intermediate worker bundle (another pre-compiled
+                                // artifact), Rollup merges their top-level scopes. Since both
+                                // may have identical minified identifiers (e.g., `l0`), this
+                                // causes a redeclaration error. To solve this, we wrap the SSR
+                                // bundle in an exporting IIFE. This creates a scope boundary,
+                                // preventing symbol collisions while producing a valid,
+                                // tree-shakeable ES module. The inline plugin below removes the
+                                // original `export` statement from the bundle to prevent syntax
+                                // errors.
                                 inlineDynamicImports: true,
+                                banner: `export const { renderHtmlStream, ssrLoadModule, ssrWebpackRequire, ssrGetModuleExport, createThenableFromReadableStream } = (function() {`,
+                                footer: `return { renderHtmlStream, ssrLoadModule, ssrWebpackRequire, ssrGetModuleExport, createThenableFromReadableStream };\n})();`,
                             },
+                            plugins: [
+                                {
+                                    name: "rwsdk:ssr-bridge-exports",
+                                    renderChunk(code) {
+                                        // Remove the original export statement as it's now handled by the banner/footer
+                                        return code.replace(/export\s*{[^}]+};?/, "");
+                                    },
+                                },
+                            ],
                         },
                     },
                 },
@@ -154,6 +193,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                         clientEntryPoints,
                         clientFiles,
                         serverFiles,
+                        workerEntryPathname,
                     });
                 },
             },

package/dist/vite/createDirectiveLookupPlugin.d.mts

@@ -1,4 +1,13 @@
 import { Plugin } from "vite";
+export declare function generateLookupMap({ files, isDev, kind, exportName, }: {
+    files: Set<string>;
+    isDev: boolean;
+    kind: "client" | "server";
+    exportName: string;
+}): {
+    code: string;
+    map: import("magic-string").SourceMap;
+};
 interface DirectiveLookupConfig {
     kind: "client" | "server";
     directive: "use client" | "use server";

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -1,7 +1,34 @@
+import debug from "debug";
 import MagicString from "magic-string";
 import path from "path";
-import debug from "debug";
 import { VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
+export function generateLookupMap({ files, isDev, kind, exportName, }) {
+    const s = new MagicString(`
+export const ${exportName} = {
+  ${Array.from(files)
+        .map((file) => {
+        if (file.includes("node_modules") && isDev) {
+            const barrelPath = kind === "client"
+                ? VENDOR_CLIENT_BARREL_EXPORT_PATH
+                : VENDOR_SERVER_BARREL_EXPORT_PATH;
+            return `
+  "${file}": () => import("${barrelPath}").then(m => m.default["${file}"]),
+`;
+        }
+        else {
+            return `
+  "${file}": () => import("${file}"),
+`;
+        }
+    })
+        .join("")}
+};
+`);
+    return {
+        code: s.toString(),
+        map: s.generateMap(),
+    };
+}
 export const createDirectiveLookupPlugin = async ({ projectRootDir, files, config, }) => {
     const debugNamespace = `rwsdk:vite:${config.pluginName}`;
     const log = debug(debugNamespace);
@@ -121,35 +148,12 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
                 log("Loading %s module with %d files", config.virtualModuleName, files.size);
                 const environment = this.environment?.name || "client";
                 log("Current environment: %s, isDev: %s", environment, isDev);
-                const s = new MagicString(`
-export const ${config.exportName} = {
-  ${Array.from(files)
-                    .map((file) => {
-                    if (file.includes("node_modules") && isDev) {
-                        const barrelPath = config.kind === "client"
-                            ? VENDOR_CLIENT_BARREL_EXPORT_PATH
-                            : VENDOR_SERVER_BARREL_EXPORT_PATH;
-                        return `
-  "${file}": () => import("${barrelPath}").then(m => m.default["${file}"]),
-`;
-                    }
-                    else {
-                        return `
-  "${file}": () => import("${file}"),
-`;
-                    }
-                })
-                    .join("")}
-};
-`);
-                const code = s.toString();
-                const map = s.generateMap();
-                log("Generated virtual module code length: %d", code.length);
-                process.env.VERBOSE && log("Generated virtual module code: %s", code);
-                return {
-                    code,
-                    map,
-                };
+                return generateLookupMap({
+                    files,
+                    isDev,
+                    kind: config.kind,
+                    exportName: config.exportName,
+                });
             }
         },
     };

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

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

package/dist/vite/createDirectiveLookupPlugin.test.mjs

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
+import { generateLookupMap } from "./createDirectiveLookupPlugin.mjs";
+describe("generateLookupMap", () => {
+    const files = new Set([
+        "src/app.js",
+        "node_modules/lib-a/index.js",
+        "src/component.tsx",
+    ]);
+    it("should generate correct map for client in dev", () => {
+        const result = generateLookupMap({
+            files,
+            isDev: true,
+            kind: "client",
+            exportName: "clientLookup",
+        });
+        expect(result.code).toContain("export const clientLookup = {");
+        expect(result.code).toContain(`"src/app.js": () => import("src/app.js")`);
+        expect(result.code).toContain(`"node_modules/lib-a/index.js": () => import("${VENDOR_CLIENT_BARREL_EXPORT_PATH}").then(m => m.default["node_modules/lib-a/index.js"])`);
+    });
+    it("should generate correct map for server in dev", () => {
+        const result = generateLookupMap({
+            files,
+            isDev: true,
+            kind: "server",
+            exportName: "serverLookup",
+        });
+        expect(result.code).toContain("export const serverLookup = {");
+        expect(result.code).toContain(`"node_modules/lib-a/index.js": () => import("${VENDOR_SERVER_BARREL_EXPORT_PATH}").then(m => m.default["node_modules/lib-a/index.js"])`);
+    });
+    it("should generate correct map for prod (isDev: false)", () => {
+        const result = generateLookupMap({
+            files,
+            isDev: false,
+            kind: "client",
+            exportName: "clientLookup",
+        });
+        expect(result.code).toContain(`"node_modules/lib-a/index.js": () => import("node_modules/lib-a/index.js")`);
+    });
+});

package/dist/vite/createViteAwareResolver.d.mts

@@ -1,5 +1,4 @@
 import resolve, { ResolveOptions } from "enhanced-resolve";
-import { ResolvedConfig } from "vite";
-import { Environment } from "vite";
+import { Environment, ResolvedConfig } from "vite";
 export declare const mapViteResolveToEnhancedResolveOptions: (viteConfig: ResolvedConfig, envName: string) => ResolveOptions;
 export declare const createViteAwareResolver: (viteConfig: ResolvedConfig, environment: Environment) => resolve.ResolveFunctionAsync;

package/dist/vite/createViteAwareResolver.mjs

@@ -1,7 +1,7 @@
+import createDebug from "debug";
 import resolve from "enhanced-resolve";
 import fs from "fs";
 import path from "path";
-import createDebug from "debug";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const debug = createDebug("rwsdk:vite:enhanced-resolve-plugin");
 // Enhanced-resolve plugin that wraps Vite plugin resolution

package/dist/vite/directiveModulesDevPlugin.d.mts

@@ -1,6 +1,9 @@
 import { Plugin } from "vite";
-export declare const directiveModulesDevPlugin: ({ clientFiles, serverFiles, projectRootDir, }: {
+export declare const generateVendorBarrelContent: (files: Set<string>, projectRootDir: string) => string;
+export declare const generateAppBarrelContent: (files: Set<string>, projectRootDir: string) => string;
+export declare const directiveModulesDevPlugin: ({ clientFiles, serverFiles, projectRootDir, workerEntryPathname, }: {
     clientFiles: Set<string>;
     serverFiles: Set<string>;
     projectRootDir: string;
+    workerEntryPathname: string;
 }) => Plugin;

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -1,10 +1,10 @@
-import path from "path";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import os from "os";
-import { writeFileSync, mkdirSync, mkdtempSync } from "node:fs";
+import path from "path";
+import { VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_CLIENT_BARREL_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_PATH, } from "../lib/constants.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
-import { VENDOR_CLIENT_BARREL_PATH, VENDOR_SERVER_BARREL_PATH, VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
 import { runDirectivesScan } from "./runDirectivesScan.mjs";
-const generateVendorBarrelContent = (files, projectRootDir) => {
+export const generateVendorBarrelContent = (files, projectRootDir) => {
     const imports = [...files]
         .filter((file) => file.includes("node_modules"))
         .map((file, i) => `import * as M${i} from '${normalizeModulePath(file, projectRootDir, {
@@ -19,7 +19,7 @@ const generateVendorBarrelContent = (files, projectRootDir) => {
         "\n};";
     return `${imports}\n\n${exports}`;
 };
-const generateAppBarrelContent = (files, projectRootDir, barrelFilePath) => {
+export const generateAppBarrelContent = (files, projectRootDir) => {
     return [...files]
         .filter((file) => !file.includes("node_modules"))
         .map((file) => {
@@ -30,7 +30,7 @@ const generateAppBarrelContent = (files, projectRootDir, barrelFilePath) => {
     })
         .join("\n");
 };
-export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
+export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, workerEntryPathname, }) => {
     const { promise: scanPromise, resolve: resolveScanPromise } = Promise.withResolvers();
     const tempDir = mkdtempSync(path.join(os.tmpdir(), "rwsdk-"));
     const APP_CLIENT_BARREL_PATH = path.join(tempDir, "app-client-barrel.js");
@@ -47,6 +47,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                 environments: server.environments,
                 clientFiles,
                 serverFiles,
+                entries: [workerEntryPathname],
             }).then(() => {
                 // context(justinvdm, 11 Sep 2025): For vendor barrels, we write the
                 // files directly to disk after the scan. For app barrels, we use a
@@ -83,7 +84,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                 env.optimizeDeps.include ??= [];
                 const entries = (env.optimizeDeps.entries = castArray(env.optimizeDeps.entries ?? []));
                 env.optimizeDeps.include.push(VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH);
-                if (envName === "client") {
+                if (envName === "client" || envName === "ssr") {
                     entries.push(APP_CLIENT_BARREL_PATH);
                 }
                 else if (envName === "worker") {
@@ -129,7 +130,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                         build.onLoad({ filter: /.*/, namespace: "rwsdk-app-barrel-ns" }, (args) => {
                             const isServerBarrel = args.path.includes("app-server-barrel");
                             const files = isServerBarrel ? serverFiles : clientFiles;
-                            const content = generateAppBarrelContent(files, projectRootDir, args.path);
+                            const content = generateAppBarrelContent(files, projectRootDir);
                             return {
                                 contents: content,
                                 loader: "js",

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

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

package/dist/vite/directiveModulesDevPlugin.test.mjs

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { generateAppBarrelContent, generateVendorBarrelContent, } from "./directiveModulesDevPlugin.mjs";
+describe("directiveModulesDevPlugin helpers", () => {
+    const projectRootDir = "/Users/test/project";
+    describe("generateVendorBarrelContent", () => {
+        it("should generate correct content for vendor files", () => {
+            const files = new Set([
+                "node_modules/lib-a/index.js",
+                "src/app.js",
+                "node_modules/lib-b/component.tsx",
+            ]);
+            const content = generateVendorBarrelContent(files, projectRootDir);
+            const expected = `import * as M0 from '${projectRootDir}/node_modules/lib-a/index.js';
+import * as M1 from '${projectRootDir}/node_modules/lib-b/component.tsx';
+
+export default {
+  '/node_modules/lib-a/index.js': M0,
+  '/node_modules/lib-b/component.tsx': M1,
+};`;
+            expect(content).toEqual(expected);
+        });
+        it("should return empty content if no vendor files", () => {
+            const files = new Set(["src/app.js", "src/component.tsx"]);
+            const content = generateVendorBarrelContent(files, projectRootDir);
+            expect(content).toEqual("\n\nexport default {\n\n};");
+        });
+        it("should handle an empty file set", () => {
+            const files = new Set();
+            const content = generateVendorBarrelContent(files, projectRootDir);
+            expect(content).toEqual("\n\nexport default {\n\n};");
+        });
+    });
+    describe("generateAppBarrelContent", () => {
+        it("should generate correct content for app files", () => {
+            const files = new Set([
+                "src/app.js",
+                "node_modules/lib-a/index.js",
+                "src/component.tsx",
+            ]);
+            const content = generateAppBarrelContent(files, projectRootDir);
+            const expected = `import "${projectRootDir}/src/app.js";
+import "${projectRootDir}/src/component.tsx";`;
+            expect(content).toEqual(expected);
+        });
+        it("should return empty content if no app files", () => {
+            const files = new Set([
+                "node_modules/lib-a/index.js",
+                "node_modules/lib-b/component.tsx",
+            ]);
+            const content = generateAppBarrelContent(files, projectRootDir);
+            expect(content).toEqual("");
+        });
+        it("should handle an empty file set", () => {
+            const files = new Set();
+            const content = generateAppBarrelContent(files, projectRootDir);
+            expect(content).toEqual("");
+        });
+    });
+});

package/dist/vite/directivesPlugin.d.mts

@@ -1,4 +1,5 @@
 import { Plugin } from "vite";
+export declare const getLoader: (filePath: string) => "jsx" | "js" | "ts" | "tsx";
 export declare const directivesPlugin: ({ projectRootDir, clientFiles, serverFiles, }: {
     projectRootDir: string;
     clientFiles: Set<string>;

package/dist/vite/directivesPlugin.mjs

@@ -1,11 +1,11 @@
-import path from "node:path";
-import fs from "node:fs/promises";
 import debug from "debug";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { transformClientComponents } from "./transformClientComponents.mjs";
 import { transformServerFunctions } from "./transformServerFunctions.mjs";
-import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:rsc-directives-plugin");
-const getLoader = (filePath) => {
+export const getLoader = (filePath) => {
     const ext = path.extname(filePath).slice(1);
     switch (ext) {
         case "mjs":

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

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

package/dist/vite/directivesPlugin.test.mjs

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { getLoader } from "./directivesPlugin.mjs";
+describe("getLoader", () => {
+    const testCases = [
+        { path: "file.js", expected: "js" },
+        { path: "file.mjs", expected: "js" },
+        { path: "file.cjs", expected: "js" },
+        { path: "file.ts", expected: "ts" },
+        { path: "file.mts", expected: "ts" },
+        { path: "file.cts", expected: "ts" },
+        { path: "file.jsx", expected: "jsx" },
+        { path: "file.tsx", expected: "tsx" },
+        { path: "/path/to/component.ts", expected: "ts" },
+        { path: "../relative/path.jsx", expected: "jsx" },
+        { path: "file.css", expected: "js" }, // default case
+        { path: "file.json", expected: "js" }, // default case
+        { path: "file", expected: "js" }, // no extension
+    ];
+    testCases.forEach(({ path, expected }) => {
+        it(`should return "${expected}" for "${path}"`, () => {
+            expect(getLoader(path)).toBe(expected);
+        });
+    });
+});

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

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

package/dist/vite/ensureAliasArray.test.mjs

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { ensureAliasArray } from "./ensureAliasArray.mjs";
+describe("ensureAliasArray", () => {
+    it("should create resolve and alias array if resolve is undefined", () => {
+        const config = {};
+        const result = ensureAliasArray(config);
+        expect(result).toEqual([]);
+        expect(config.resolve?.alias).toEqual([]);
+        expect(result).toBe(config.resolve?.alias);
+    });
+    it("should create alias array if alias is undefined", () => {
+        const config = { resolve: {} };
+        const result = ensureAliasArray(config);
+        expect(result).toEqual([]);
+        expect(config.resolve?.alias).toEqual([]);
+        expect(result).toBe(config.resolve?.alias);
+    });
+    it("should convert an alias object to an array", () => {
+        const config = {
+            resolve: {
+                alias: {
+                    find: "/replacement",
+                    another: "/another-replacement",
+                },
+            },
+        };
+        const result = ensureAliasArray(config);
+        const expected = [
+            { find: "find", replacement: "/replacement" },
+            { find: "another", replacement: "/another-replacement" },
+        ];
+        expect(result).toEqual(expected);
+        expect(config.resolve?.alias).toEqual(expected);
+        expect(result).toBe(config.resolve?.alias);
+    });
+    it("should return a clone of an existing alias array", () => {
+        const originalAlias = [{ find: "find", replacement: "/replacement" }];
+        const config = {
+            resolve: {
+                alias: originalAlias,
+            },
+        };
+        const result = ensureAliasArray(config);
+        expect(result).toEqual(originalAlias);
+        expect(result).not.toBe(originalAlias);
+        expect(config.resolve?.alias).toEqual(originalAlias);
+        expect(config.resolve?.alias).not.toBe(originalAlias);
+    });
+    it("should handle an empty alias object", () => {
+        const config = {
+            resolve: {
+                alias: {},
+            },
+        };
+        const result = ensureAliasArray(config);
+        expect(result).toEqual([]);
+        expect(config.resolve?.alias).toEqual([]);
+    });
+    it("should handle an empty alias array", () => {
+        const config = {
+            resolve: {
+                alias: [],
+            },
+        };
+        const originalAlias = config.resolve?.alias;
+        const result = ensureAliasArray(config);
+        expect(result).toEqual([]);
+        expect(config.resolve?.alias).toEqual([]);
+        expect(result).not.toBe(originalAlias);
+    });
+});