rwsdk 0.1.24 → 0.1.25

package/dist/lib/normalizeModulePath.d.mts

@@ -0,0 +1,26 @@
+/**
+ * Normalize a module path to a consistent form.
+ * Returns slash-prefixed paths for files within project root,
+ * or absolute paths for external files.
+ *
+ * Examples:
+ *   /Users/justin/my-app/src/page.ts      → /src/page.ts
+ *   ../shared/utils.ts                    → /Users/justin/shared/utils.ts
+ *   /src/page.ts (Vite-style)            → /src/page.ts
+ *   node_modules/foo/index.js            → /node_modules/foo/index.js
+ *
+ * With { absolute: true }:
+ *   /Users/justin/my-app/src/page.ts      → /Users/justin/my-app/src/page.ts
+ *
+ * With { isViteStyle: false }:
+ *   /opt/tools/logger.ts                  → /opt/tools/logger.ts (treated as external)
+ *   /src/page.tsx                         → /src/page.tsx (treated as external)
+ *
+ * With { isViteStyle: true }:
+ *   /opt/tools/logger.ts                  → /opt/tools/logger.ts (resolved as Vite-style)
+ *   /src/page.tsx, { absolute: true }     → /Users/justin/my-app/src/page.tsx
+ */
+export declare function normalizeModulePath(modulePath: string, projectRootDir: string, options?: {
+    absolute?: boolean;
+    isViteStyle?: boolean;
+}): string;

package/dist/lib/normalizeModulePath.mjs

@@ -0,0 +1,101 @@
+import * as path from "node:path";
+import { normalizePath as normalizePathSeparators } from "vite";
+/**
+ * Find the number of common ancestor segments between two absolute paths.
+ * Returns the count of shared directory segments from the root.
+ */
+function findCommonAncestorDepth(path1, path2) {
+    const segments1 = path1.split("/").filter(Boolean);
+    const segments2 = path2.split("/").filter(Boolean);
+    let commonLength = 0;
+    const minLength = Math.min(segments1.length, segments2.length);
+    for (let i = 0; i < minLength; i++) {
+        if (segments1[i] === segments2[i]) {
+            commonLength++;
+        }
+        else {
+            break;
+        }
+    }
+    return commonLength;
+}
+/**
+ * Normalize a module path to a consistent form.
+ * Returns slash-prefixed paths for files within project root,
+ * or absolute paths for external files.
+ *
+ * Examples:
+ *   /Users/justin/my-app/src/page.ts      → /src/page.ts
+ *   ../shared/utils.ts                    → /Users/justin/shared/utils.ts
+ *   /src/page.ts (Vite-style)            → /src/page.ts
+ *   node_modules/foo/index.js            → /node_modules/foo/index.js
+ *
+ * With { absolute: true }:
+ *   /Users/justin/my-app/src/page.ts      → /Users/justin/my-app/src/page.ts
+ *
+ * With { isViteStyle: false }:
+ *   /opt/tools/logger.ts                  → /opt/tools/logger.ts (treated as external)
+ *   /src/page.tsx                         → /src/page.tsx (treated as external)
+ *
+ * With { isViteStyle: true }:
+ *   /opt/tools/logger.ts                  → /opt/tools/logger.ts (resolved as Vite-style)
+ *   /src/page.tsx, { absolute: true }     → /Users/justin/my-app/src/page.tsx
+ */
+export function normalizeModulePath(modulePath, projectRootDir, options = {}) {
+    modulePath = normalizePathSeparators(modulePath);
+    projectRootDir = normalizePathSeparators(path.resolve(projectRootDir));
+    // Handle empty string or current directory
+    if (modulePath === "" || modulePath === ".") {
+        return options.absolute ? projectRootDir : "/";
+    }
+    // For relative paths, resolve them first
+    let resolved;
+    if (path.isAbsolute(modulePath)) {
+        if (modulePath.startsWith(projectRootDir + "/") ||
+            modulePath === projectRootDir) {
+            // Path starts with project root - it's a real absolute path inside project
+            resolved = modulePath;
+        }
+        else {
+            // Check how the path relates to the project root
+            if (options.isViteStyle !== undefined) {
+                // User explicitly specified whether this should be treated as Vite-style
+                if (options.isViteStyle) {
+                    resolved = path.resolve(projectRootDir, modulePath.slice(1));
+                }
+                else {
+                    resolved = modulePath;
+                }
+            }
+            else {
+                // Fall back to heuristics using common ancestor depth
+                const commonDepth = findCommonAncestorDepth(modulePath, projectRootDir);
+                if (commonDepth > 0) {
+                    // Paths share meaningful common ancestor - treat as real absolute path
+                    resolved = modulePath;
+                }
+                else {
+                    // No meaningful common ancestor - assume Vite-style path within project
+                    resolved = path.resolve(projectRootDir, modulePath.slice(1));
+                }
+            }
+        }
+    }
+    else {
+        resolved = path.resolve(projectRootDir, modulePath);
+    }
+    resolved = normalizePathSeparators(resolved);
+    // If absolute option is set, always return absolute paths
+    if (options.absolute) {
+        return resolved;
+    }
+    // Check if the resolved path is within the project root
+    const relative = path.relative(projectRootDir, resolved);
+    // If the path goes outside the project root (starts with ..), return absolute
+    if (relative.startsWith("..")) {
+        return resolved;
+    }
+    // Path is within project root, return as Vite-style relative path
+    const cleanRelative = relative === "." ? "" : relative;
+    return "/" + normalizePathSeparators(cleanRelative);
+}

package/dist/lib/normalizeModulePath.test.d.ts

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

package/dist/lib/normalizeModulePath.test.js

@@ -0,0 +1,203 @@
+import { describe, it, expect } from "vitest";
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+describe("normalizeModulePath", () => {
+    describe("1. Project-local paths", () => {
+        it("Relative file", () => {
+            expect(normalizeModulePath("src/page.tsx", "/Users/name/code/my-app")).toBe("/src/page.tsx");
+        });
+        it("Relative file in subdir", () => {
+            expect(normalizeModulePath("src/utils/index.ts", "/Users/name/code/my-app")).toBe("/src/utils/index.ts");
+        });
+        it("Relative file with ./", () => {
+            expect(normalizeModulePath("./src/page.tsx", "/Users/name/code/my-app")).toBe("/src/page.tsx");
+        });
+        it("Relative file with ../ (external)", () => {
+            expect(normalizeModulePath("../shared/foo.ts", "/Users/name/code/my-app")).toBe("/Users/name/code/shared/foo.ts");
+        });
+    });
+    describe("2. Vite-style absolute paths", () => {
+        it("Vite-style root import", () => {
+            expect(normalizeModulePath("/src/page.tsx", "/Users/name/code/my-app")).toBe("/src/page.tsx");
+        });
+        it("Vite-style node_modules", () => {
+            expect(normalizeModulePath("/node_modules/foo.js", "/Users/name/code/my-app")).toBe("/node_modules/foo.js");
+        });
+    });
+    describe("3. Real absolute paths inside project", () => {
+        it("Real abs path (inside)", () => {
+            expect(normalizeModulePath("/Users/name/code/my-app/src/page.tsx", "/Users/name/code/my-app")).toBe("/src/page.tsx");
+        });
+        it("Real abs path (deep inside)", () => {
+            expect(normalizeModulePath("/Users/name/code/my-app/src/features/auth.ts", "/Users/name/code/my-app")).toBe("/src/features/auth.ts");
+        });
+    });
+    describe("4. Real absolute paths outside project", () => {
+        it("External shared pkg", () => {
+            expect(normalizeModulePath("/Users/name/code/my-monorepo/packages/shared/utils.ts", "/Users/name/code/my-monorepo/packages/app")).toBe("/Users/name/code/my-monorepo/packages/shared/utils.ts");
+        });
+        it("External node_modules", () => {
+            expect(normalizeModulePath("/Users/name/code/my-monorepo/node_modules/foo/index.js", "/Users/name/code/my-monorepo/packages/app")).toBe("/Users/name/code/my-monorepo/node_modules/foo/index.js");
+        });
+        it("Completely external path", () => {
+            expect(normalizeModulePath("/opt/tools/logger.ts", "/Users/name/code/my-app")).toBe("/opt/tools/logger.ts");
+        });
+    });
+    describe("5. Absolute option", () => {
+        describe("Project-local paths with absolute option", () => {
+            it("Relative file", () => {
+                expect(normalizeModulePath("src/page.tsx", "/Users/name/code/my-app", {
+                    absolute: true,
+                })).toBe("/Users/name/code/my-app/src/page.tsx");
+            });
+            it("Relative file in subdir", () => {
+                expect(normalizeModulePath("src/utils/index.ts", "/Users/name/code/my-app", {
+                    absolute: true,
+                })).toBe("/Users/name/code/my-app/src/utils/index.ts");
+            });
+            it("Relative file with ./", () => {
+                expect(normalizeModulePath("./src/page.tsx", "/Users/name/code/my-app", {
+                    absolute: true,
+                })).toBe("/Users/name/code/my-app/src/page.tsx");
+            });
+            it("Relative file with ../ (external)", () => {
+                expect(normalizeModulePath("../shared/foo.ts", "/Users/name/code/my-app", {
+                    absolute: true,
+                })).toBe("/Users/name/code/shared/foo.ts");
+            });
+        });
+        describe("Vite-style absolute paths with absolute option", () => {
+            it("Vite-style root import", () => {
+                expect(normalizeModulePath("/src/page.tsx", "/Users/name/code/my-app", {
+                    absolute: true,
+                })).toBe("/Users/name/code/my-app/src/page.tsx");
+            });
+            it("Vite-style node_modules", () => {
+                expect(normalizeModulePath("/node_modules/foo.js", "/Users/name/code/my-app", { absolute: true })).toBe("/Users/name/code/my-app/node_modules/foo.js");
+            });
+        });
+        describe("Real absolute paths with absolute option", () => {
+            it("Real abs path (inside)", () => {
+                expect(normalizeModulePath("/Users/name/code/my-app/src/page.tsx", "/Users/name/code/my-app", { absolute: true })).toBe("/Users/name/code/my-app/src/page.tsx");
+            });
+            it("Real abs path (deep inside)", () => {
+                expect(normalizeModulePath("/Users/name/code/my-app/src/features/auth.ts", "/Users/name/code/my-app", { absolute: true })).toBe("/Users/name/code/my-app/src/features/auth.ts");
+            });
+            it("External shared pkg", () => {
+                expect(normalizeModulePath("/Users/name/code/my-monorepo/packages/shared/utils.ts", "/Users/name/code/my-monorepo/packages/app", { absolute: true })).toBe("/Users/name/code/my-monorepo/packages/shared/utils.ts");
+            });
+            it("External node_modules", () => {
+                expect(normalizeModulePath("/Users/name/code/my-monorepo/node_modules/foo/index.js", "/Users/name/code/my-monorepo/packages/app", { absolute: true })).toBe("/Users/name/code/my-monorepo/node_modules/foo/index.js");
+            });
+            it("Completely external path", () => {
+                expect(normalizeModulePath("/opt/tools/logger.ts", "/Users/name/code/my-app", {
+                    absolute: true,
+                    isViteStyle: false,
+                })).toBe("/opt/tools/logger.ts");
+            });
+        });
+        describe("Edge cases with absolute option", () => {
+            it("Empty string", () => {
+                expect(normalizeModulePath("", "/Users/name/code/my-app", {
+                    absolute: true,
+                })).toBe("/Users/name/code/my-app");
+            });
+            it("Dot current dir", () => {
+                expect(normalizeModulePath(".", "/Users/name/code/my-app", {
+                    absolute: true,
+                })).toBe("/Users/name/code/my-app");
+            });
+            it("Dot parent dir", () => {
+                expect(normalizeModulePath("..", "/Users/name/code/my-app", {
+                    absolute: true,
+                })).toBe("/Users/name/code");
+            });
+            it("Trailing slash", () => {
+                expect(normalizeModulePath("src/", "/Users/name/code/my-app", {
+                    absolute: true,
+                })).toBe("/Users/name/code/my-app/src");
+            });
+            it("Leading and trailing slashes", () => {
+                expect(normalizeModulePath("/src/", "/Users/name/code/my-app", {
+                    absolute: true,
+                })).toBe("/Users/name/code/my-app/src");
+            });
+        });
+        describe("Project root is / with absolute option", () => {
+            it("Root-based path", () => {
+                expect(normalizeModulePath("/src/index.ts", "/", { absolute: true })).toBe("/src/index.ts");
+            });
+            it("System path", () => {
+                expect(normalizeModulePath("/etc/hosts", "/", { absolute: true })).toBe("/etc/hosts");
+            });
+        });
+    });
+    describe("6. Edge and weird cases", () => {
+        it("Empty string", () => {
+            expect(normalizeModulePath("", "/Users/name/code/my-app")).toBe("/");
+        });
+        it("Dot current dir", () => {
+            expect(normalizeModulePath(".", "/Users/name/code/my-app")).toBe("/");
+        });
+        it("Dot parent dir", () => {
+            expect(normalizeModulePath("..", "/Users/name/code/my-app")).toBe("/Users/name/code");
+        });
+        it("Trailing slash", () => {
+            expect(normalizeModulePath("src/", "/Users/name/code/my-app")).toBe("/src");
+        });
+        it("Leading and trailing slashes", () => {
+            expect(normalizeModulePath("/src/", "/Users/name/code/my-app")).toBe("/src");
+        });
+    });
+    describe("7. Project root is /", () => {
+        it("Root-based path", () => {
+            expect(normalizeModulePath("/src/index.ts", "/")).toBe("/src/index.ts");
+        });
+        it("System path", () => {
+            expect(normalizeModulePath("/etc/hosts", "/")).toBe("/etc/hosts");
+        });
+    });
+    describe("8. isViteStyle option", () => {
+        describe("isViteStyle: false (treat as external)", () => {
+            it("System path that would normally be Vite-style", () => {
+                expect(normalizeModulePath("/opt/tools/logger.ts", "/Users/name/code/my-app", {
+                    isViteStyle: false,
+                })).toBe("/opt/tools/logger.ts");
+            });
+            it("Src path with isViteStyle: false", () => {
+                expect(normalizeModulePath("/src/page.tsx", "/Users/name/code/my-app", {
+                    isViteStyle: false,
+                })).toBe("/src/page.tsx");
+            });
+            it("With absolute option", () => {
+                expect(normalizeModulePath("/opt/tools/logger.ts", "/Users/name/code/my-app", {
+                    absolute: true,
+                    isViteStyle: false,
+                })).toBe("/opt/tools/logger.ts");
+            });
+        });
+        describe("isViteStyle: true (force Vite-style)", () => {
+            it("System path forced to Vite-style", () => {
+                expect(normalizeModulePath("/opt/tools/logger.ts", "/Users/name/code/my-app", {
+                    isViteStyle: true,
+                })).toBe("/opt/tools/logger.ts");
+            });
+            it("Src path with isViteStyle: true", () => {
+                expect(normalizeModulePath("/src/page.tsx", "/Users/name/code/my-app", {
+                    isViteStyle: true,
+                })).toBe("/src/page.tsx");
+            });
+            it("With absolute option", () => {
+                expect(normalizeModulePath("/src/page.tsx", "/Users/name/code/my-app", {
+                    absolute: true,
+                    isViteStyle: true,
+                })).toBe("/Users/name/code/my-app/src/page.tsx");
+            });
+            it("System path forced to Vite-style with absolute option", () => {
+                expect(normalizeModulePath("/opt/tools/logger.ts", "/Users/name/code/my-app", {
+                    absolute: true,
+                    isViteStyle: true,
+                })).toBe("/Users/name/code/my-app/opt/tools/logger.ts");
+            });
+        });
+    });
+});

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -2,7 +2,7 @@ import MagicString from "magic-string";
 import path from "path";
 import { readFile } from "fs/promises";
 import debug from "debug";
-import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { pathExists } from "fs-extra";
 import { stat } from "fs/promises";
 import { getSrcPaths } from "../lib/getSrcPaths.js";
@@ -22,7 +22,7 @@ export const findFilesContainingDirective = async ({ projectRootDir, files, dire
             process.env.VERBOSE && log("Scanning file: %s", file);
             const content = await readFile(file, "utf-8");
             if (hasDirective(content, directive)) {
-                const normalizedPath = normalizeModulePath(projectRootDir, file);
+                const normalizedPath = normalizeModulePath(file, projectRootDir);
                 log("Found '%s' directive in file: %s -> %s", directive, file, normalizedPath);
                 files.add(normalizedPath);
             }

package/dist/vite/directivesPlugin.mjs

@@ -3,7 +3,7 @@ import fs from "node:fs/promises";
 import debug from "debug";
 import { transformClientComponents } from "./transformClientComponents.mjs";
 import { transformServerFunctions } from "./transformServerFunctions.mjs";
-import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:rsc-directives-plugin");
 const getLoader = (filePath) => {
     const ext = path.extname(filePath).slice(1);
@@ -31,9 +31,10 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
     const addModule = (kind, environment, id) => {
         const files = kind === "client" ? clientFiles : serverFiles;
         const rawId = id.split("?")[0];
-        const resolvedId = rawId;
-        const relativePath = rawId.slice("/".length);
-        const fullPath = path.resolve(projectRootDir, relativePath);
+        const resolvedId = normalizeModulePath(rawId, projectRootDir);
+        const fullPath = normalizeModulePath(rawId, projectRootDir, {
+            absolute: true,
+        });
         const isNodeModule = id.includes("node_modules");
         const hadFile = files.has(id);
         log("Adding %s module to %s and invalidating cache: id=%s", kind, files, resolvedId);
@@ -77,7 +78,7 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
         async transform(code, id) {
             process.env.VERBOSE &&
                 log("Transform called for id=%s, environment=%s", id, this.environment.name);
-            const normalizedId = normalizeModulePath(projectRootDir, id);
+            const normalizedId = normalizeModulePath(id, projectRootDir);
             const clientResult = await transformClientComponents(code, normalizedId, {
                 environmentName: this.environment.name,
                 clientFiles,
@@ -112,7 +113,7 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                     build.onLoad({ filter: /\.(js|ts|jsx|tsx|mts|mjs|cjs)$/ }, async (args) => {
                         process.env.VERBOSE &&
                             log("Esbuild onLoad called for environment=%s, path=%s", env, args.path);
-                        const normalizedPath = normalizeModulePath(projectRootDir, args.path);
+                        const normalizedPath = normalizeModulePath(args.path, projectRootDir);
                         // context(justinvdm,2025-06-15): If we're in app code,
                         // we will be doing the transform work in the vite plugin hooks,
                         // the only reason we're in esbuild land for app code is for

package/dist/vite/miniflareHMRPlugin.mjs

@@ -3,7 +3,7 @@ import colors from "picocolors";
 import { readFile } from "node:fs/promises";
 import debug from "debug";
 import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
-import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { hasDirective as sourceHasDirective } from "./hasDirective.mjs";
 import { isJsFile } from "./isJsFile.mjs";
 import { invalidateModule } from "./invalidateModule.mjs";
@@ -33,7 +33,7 @@ const hasEntryAsAncestor = (module, entryFile, seen = new Set()) => {
     return false;
 };
 const isInUseClientGraph = ({ file, clientFiles, server, }) => {
-    const id = normalizeModulePath(server.config.root, file);
+    const id = normalizeModulePath(file, server.config.root);
     if (clientFiles.has(id)) {
         return true;
     }
@@ -74,7 +74,7 @@ export const miniflareHMRPlugin = (givenOptions) => [
                 }
                 invalidateModule(ctx.server, "ssr", ctx.file);
                 invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX +
-                    normalizeModulePath(givenOptions.rootDir, ctx.file));
+                    normalizeModulePath(ctx.file, givenOptions.rootDir));
                 return [];
             }
             if (!["client", environment].includes(this.environment.name)) {
@@ -159,7 +159,7 @@ export const miniflareHMRPlugin = (givenOptions) => [
                     invalidateModule(ctx.server, environment, m);
                 }
                 const virtualSSRModule = ctx.server.environments[environment].moduleGraph.idToModuleMap.get(VIRTUAL_SSR_PREFIX +
-                    normalizeModulePath(givenOptions.rootDir, ctx.file));
+                    normalizeModulePath(ctx.file, givenOptions.rootDir));
                 if (virtualSSRModule) {
                     invalidateModule(ctx.server, environment, virtualSSRModule);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {

package/dist/vite/normalizeModulePath.d.mts

@@ -1 +0,0 @@
-export declare const normalizeModulePath: (projectRootDir: string, modulePath: string) => string;

package/dist/vite/normalizeModulePath.mjs

@@ -1,13 +0,0 @@
-import path from "node:path";
-export const normalizeModulePath = (projectRootDir, modulePath) => {
-    // /Users/path/to/project/src/foo/bar.ts -> /src/foo/bar.ts
-    if (modulePath.startsWith(projectRootDir)) {
-        return "/" + path.relative(projectRootDir, modulePath);
-    }
-    // /src/foo/bar.ts -> /src/foo/bar.ts
-    if (modulePath.startsWith("/")) {
-        return modulePath;
-    }
-    // src/foo/bar.ts -> /src/foo/bar.ts
-    return "/" + modulePath;
-};