rwsdk 0.1.23 → 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/runtime/client.d.ts

@@ -6,12 +6,14 @@ export type ActionResponse<Result> = {
 };
 type TransportContext = {
     setRscPayload: <Result>(v: Promise<ActionResponse<Result>>) => void;
+    handleResponse?: (response: Response) => boolean;
 };
 export type Transport = (context: TransportContext) => CallServerCallback;
 export type CreateCallServer = (context: TransportContext) => <Result>(id: null | string, args: null | unknown[]) => Promise<Result>;
 export declare const fetchTransport: Transport;
-export declare const initClient: ({ transport, hydrateRootOptions, }?: {
+export declare const initClient: ({ transport, hydrateRootOptions, handleResponse, }?: {
     transport?: Transport;
     hydrateRootOptions?: HydrationOptions;
+    handleResponse?: (response: Response) => boolean;
 }) => Promise<void>;
 export {};

package/dist/runtime/client.js

@@ -11,21 +11,41 @@ export const fetchTransport = (transportContext) => {
         if (id != null) {
             url.searchParams.set("__rsc_action_id", id);
         }
-        const streamData = createFromFetch(fetch(url, {
+        const fetchPromise = fetch(url, {
             method: "POST",
             body: args != null ? await encodeReply(args) : null,
-        }), { callServer: fetchCallServer });
+        });
+        // If there's a response handler, check the response first
+        if (transportContext.handleResponse) {
+            const response = await fetchPromise;
+            const shouldContinue = transportContext.handleResponse(response);
+            if (!shouldContinue) {
+                return;
+            }
+            // Continue with the response if handler returned true
+            const streamData = createFromFetch(Promise.resolve(response), {
+                callServer: fetchCallServer,
+            });
+            transportContext.setRscPayload(streamData);
+            const result = await streamData;
+            return result.actionResult;
+        }
+        // Original behavior when no handler is present
+        const streamData = createFromFetch(fetchPromise, {
+            callServer: fetchCallServer,
+        });
         transportContext.setRscPayload(streamData);
         const result = await streamData;
         return result.actionResult;
     };
     return fetchCallServer;
 };
-export const initClient = async ({ transport = fetchTransport, hydrateRootOptions, } = {}) => {
+export const initClient = async ({ transport = fetchTransport, hydrateRootOptions, handleResponse, } = {}) => {
     const React = await import("react");
     const { hydrateRoot } = await import("react-dom/client");
     const transportContext = {
         setRscPayload: () => { },
+        handleResponse,
     };
     let transportCallServer = transport(transportContext);
     const callServer = (id, args) => transportCallServer(id, args);

package/dist/runtime/clientNavigation.d.ts

@@ -1,4 +1,6 @@
 export declare function validateClickEvent(event: MouseEvent, target: HTMLElement): boolean;
 export declare function initClientNavigation(opts?: {
     onNavigate: () => void;
-}): void;
+}): {
+    handleResponse: (response: Response) => boolean;
+};

package/dist/runtime/clientNavigation.js

@@ -50,4 +50,15 @@ export function initClientNavigation(opts = {
     window.addEventListener("popstate", async function handlePopState() {
         await opts.onNavigate();
     });
+    // Return a handleResponse function for use with initClient
+    return {
+        handleResponse: function handleResponse(response) {
+            if (!response.ok) {
+                // Redirect to the current page (window.location) to show the error
+                window.location.href = window.location.href;
+                return false;
+            }
+            return true;
+        },
+    };
 }

package/dist/runtime/lib/realtime/client.d.ts

@@ -1,7 +1,9 @@
 import { type Transport } from "../../client";
-export declare const initRealtimeClient: ({ key, }?: {
+export declare const initRealtimeClient: ({ key, handleResponse, }?: {
     key?: string;
+    handleResponse?: (response: Response) => boolean;
 }) => Promise<void>;
-export declare const realtimeTransport: ({ key }: {
+export declare const realtimeTransport: ({ key, handleResponse, }: {
     key?: string;
+    handleResponse?: (response: Response) => boolean;
 }) => Transport;