react-on-rails-pro 16.2.0-beta.0

package/lib/RSCProvider.js

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2025 Shakacode LLC
+ *
+ * This file is NOT licensed under the MIT (open source) license.
+ * It is part of the React on Rails Pro offering and is licensed separately.
+ *
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without a valid license agreement
+ * from Shakacode LLC.
+ *
+ * For licensing terms, please see:
+ * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+ */
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { createRSCPayloadKey } from "./utils.js";
+const RSCContext = createContext(undefined);
+/**
+ * Creates a provider context for React Server Components.
+ *
+ * RSCProvider is a foundational component that:
+ * 1. Provides caching for server components to prevent redundant requests
+ * 2. Manages the fetching of server components through getComponent
+ * 3. Offers environment-agnostic access to server components
+ *
+ * This factory function accepts an environment-specific getServerComponent implementation,
+ * allowing it to work correctly in both client and server environments.
+ *
+ * @param railsContext - Context for the current request
+ * @param getServerComponent - Environment-specific function for fetching server components
+ * @returns A provider component that wraps children with RSC context
+ *
+ * @important This is an internal function. End users should not use this directly.
+ * Instead, use wrapServerComponentRenderer from 'react-on-rails/wrapServerComponentRenderer/client'
+ * for client-side rendering or 'react-on-rails/wrapServerComponentRenderer/server' for server-side rendering.
+ */
+export const createRSCProvider = ({ getServerComponent, }) => {
+    const fetchRSCPromises = {};
+    const getComponent = (componentName, componentProps) => {
+        const key = createRSCPayloadKey(componentName, componentProps);
+        if (key in fetchRSCPromises) {
+            return fetchRSCPromises[key];
+        }
+        const promise = getServerComponent({ componentName, componentProps });
+        fetchRSCPromises[key] = promise;
+        return promise;
+    };
+    const refetchComponent = (componentName, componentProps) => {
+        const key = createRSCPayloadKey(componentName, componentProps);
+        const promise = getServerComponent({
+            componentName,
+            componentProps,
+            enforceRefetch: true,
+        });
+        fetchRSCPromises[key] = promise;
+        return promise;
+    };
+    const contextValue = { getComponent, refetchComponent };
+    return ({ children }) => {
+        return _jsx(RSCContext.Provider, { value: contextValue, children: children });
+    };
+};
+/**
+ * Hook to access the RSC context within client components.
+ *
+ * This hook provides access to:
+ * - getComponent: For fetching and rendering server components
+ * - refetchComponent: For refetching server components
+ *
+ * It must be used within a component wrapped by RSCProvider (typically done
+ * automatically by wrapServerComponentRenderer).
+ *
+ * @returns The RSC context containing methods for working with server components
+ * @throws Error if used outside of an RSCProvider
+ *
+ * @example
+ * ```tsx
+ * const { getComponent } = useRSC();
+ * const serverComponent = use(getComponent('MyServerComponent', props));
+ * ```
+ */
+export const useRSC = () => {
+    const context = useContext(RSCContext);
+    if (!context) {
+        throw new Error('useRSC must be used within a RSCProvider');
+    }
+    return context;
+};
+//# sourceMappingURL=RSCProvider.js.map

package/lib/RSCRequestTracker.d.ts

@@ -0,0 +1,75 @@
+import { RSCPayloadStreamInfo, RSCPayloadCallback, RailsContextWithServerComponentMetadata } from 'react-on-rails/types';
+/**
+ * Global function provided by React on Rails Pro for generating RSC payloads.
+ *
+ * This function is injected into the global scope during server-side rendering
+ * by the RORP rendering request. It handles the actual generation of React Server
+ * Component payloads on the server side.
+ *
+ * @see https://github.com/shakacode/react_on_rails_pro/blob/master/lib/react_on_rails_pro/server_rendering_js_code.rb
+ */
+declare global {
+    function generateRSCPayload(componentName: string, props: unknown, railsContext: RailsContextWithServerComponentMetadata): Promise<NodeJS.ReadableStream>;
+}
+/**
+ * RSC Request Tracker - manages RSC payload generation and tracking for a single request.
+ *
+ * This class provides a local alternative to the global RSC payload management,
+ * allowing each request to have its own isolated tracker without sharing state.
+ * It includes both tracking functionality for the server renderer and fetching
+ * functionality for components.
+ */
+declare class RSCRequestTracker {
+    private streams;
+    private callbacks;
+    private railsContext;
+    constructor(railsContext: RailsContextWithServerComponentMetadata);
+    /**
+     * Clears all streams and callbacks for this request.
+     * Should be called when the request is complete to ensure proper cleanup,
+     * though garbage collection will handle cleanup automatically when the tracker goes out of scope.
+     *
+     * This method is safe to call multiple times and will handle any errors during cleanup gracefully.
+     */
+    clear(): void;
+    /**
+     * Registers a callback to be executed when RSC payloads are generated.
+     *
+     * This function:
+     * 1. Stores the callback function for this tracker
+     * 2. Immediately executes the callback for any existing streams
+     *
+     * This synchronous execution is critical for preventing hydration race conditions.
+     * It ensures payload array initialization happens before component HTML appears
+     * in the response stream.
+     *
+     * @param callback - Function to call when an RSC payload is generated
+     */
+    onRSCPayloadGenerated(callback: RSCPayloadCallback): void;
+    /**
+     * Generates and tracks RSC payloads for server components.
+     *
+     * getRSCPayloadStream:
+     * 1. Calls the provided generateRSCPayload function
+     * 2. Tracks streams in this tracker for later access
+     * 3. Notifies callbacks immediately to enable early payload embedding
+     *
+     * The immediate callback notification is critical for preventing hydration race conditions,
+     * as it ensures the payload array is initialized in the HTML stream before component rendering.
+     *
+     * @param componentName - Name of the server component
+     * @param props - Props for the server component
+     * @returns A stream of the RSC payload
+     * @throws Error if generateRSCPayload is not available or fails
+     */
+    getRSCPayloadStream(componentName: string, props: unknown): Promise<NodeJS.ReadableStream>;
+    /**
+     * Returns all RSC payload streams tracked by this request tracker.
+     * Used by the server renderer to access all fetched RSCs for this request.
+     *
+     * @returns Array of RSC payload stream information
+     */
+    getRSCPayloadStreams(): RSCPayloadStreamInfo[];
+}
+export default RSCRequestTracker;
+//# sourceMappingURL=RSCRequestTracker.d.ts.map

package/lib/RSCRequestTracker.js

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2025 Shakacode LLC
+ *
+ * This file is NOT licensed under the MIT (open source) license.
+ * It is part of the React on Rails Pro offering and is licensed separately.
+ *
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without a valid license agreement
+ * from Shakacode LLC.
+ *
+ * For licensing terms, please see:
+ * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+ */
+import { PassThrough } from 'stream';
+import { extractErrorMessage } from "./utils.js";
+/**
+ * RSC Request Tracker - manages RSC payload generation and tracking for a single request.
+ *
+ * This class provides a local alternative to the global RSC payload management,
+ * allowing each request to have its own isolated tracker without sharing state.
+ * It includes both tracking functionality for the server renderer and fetching
+ * functionality for components.
+ */
+class RSCRequestTracker {
+    constructor(railsContext) {
+        this.streams = [];
+        this.callbacks = [];
+        this.railsContext = railsContext;
+    }
+    /**
+     * Clears all streams and callbacks for this request.
+     * Should be called when the request is complete to ensure proper cleanup,
+     * though garbage collection will handle cleanup automatically when the tracker goes out of scope.
+     *
+     * This method is safe to call multiple times and will handle any errors during cleanup gracefully.
+     */
+    clear() {
+        // Close any active streams before clearing
+        this.streams.forEach(({ stream, componentName }, index) => {
+            try {
+                if (stream && typeof stream.destroy === 'function') {
+                    stream.destroy();
+                }
+            }
+            catch (error) {
+                // Log the error but don't throw to avoid disrupting cleanup of other streams
+                console.warn(`Warning: Error while destroying RSC stream for component "${componentName}" at index ${index}:`, error);
+            }
+        });
+        this.streams = [];
+        this.callbacks = [];
+    }
+    /**
+     * Registers a callback to be executed when RSC payloads are generated.
+     *
+     * This function:
+     * 1. Stores the callback function for this tracker
+     * 2. Immediately executes the callback for any existing streams
+     *
+     * This synchronous execution is critical for preventing hydration race conditions.
+     * It ensures payload array initialization happens before component HTML appears
+     * in the response stream.
+     *
+     * @param callback - Function to call when an RSC payload is generated
+     */
+    onRSCPayloadGenerated(callback) {
+        this.callbacks.push(callback);
+        // Call callback for any existing streams
+        this.streams.forEach(callback);
+    }
+    /**
+     * Generates and tracks RSC payloads for server components.
+     *
+     * getRSCPayloadStream:
+     * 1. Calls the provided generateRSCPayload function
+     * 2. Tracks streams in this tracker for later access
+     * 3. Notifies callbacks immediately to enable early payload embedding
+     *
+     * The immediate callback notification is critical for preventing hydration race conditions,
+     * as it ensures the payload array is initialized in the HTML stream before component rendering.
+     *
+     * @param componentName - Name of the server component
+     * @param props - Props for the server component
+     * @returns A stream of the RSC payload
+     * @throws Error if generateRSCPayload is not available or fails
+     */
+    async getRSCPayloadStream(componentName, props) {
+        // Validate that the global generateRSCPayload function is available
+        if (typeof generateRSCPayload !== 'function') {
+            throw new Error('generateRSCPayload is not defined. Please ensure that you are using at least version 4.0.0 of ' +
+                'React on Rails Pro and the Node renderer, and that ReactOnRailsPro.configuration.enable_rsc_support ' +
+                'is set to true.');
+        }
+        try {
+            const stream = await generateRSCPayload(componentName, props, this.railsContext);
+            // Tee stream to allow for multiple consumers:
+            //   1. stream1 - Used by React's runtime to perform server-side rendering
+            //   2. stream2 - Used by react-on-rails to embed the RSC payloads
+            //      into the HTML stream for client-side hydration
+            const stream1 = new PassThrough();
+            stream.pipe(stream1);
+            const stream2 = new PassThrough();
+            stream.pipe(stream2);
+            const streamInfo = {
+                componentName,
+                props,
+                stream: stream2,
+            };
+            this.streams.push(streamInfo);
+            // Notify callbacks about the new stream in a sync manner to maintain proper hydration timing
+            this.callbacks.forEach((callback) => callback(streamInfo));
+            return stream1;
+        }
+        catch (error) {
+            // Provide a more helpful error message that includes context
+            throw new Error(`Failed to generate RSC payload for component "${componentName}": ${extractErrorMessage(error)}`);
+        }
+    }
+    /**
+     * Returns all RSC payload streams tracked by this request tracker.
+     * Used by the server renderer to access all fetched RSCs for this request.
+     *
+     * @returns Array of RSC payload stream information
+     */
+    getRSCPayloadStreams() {
+        return [...this.streams]; // Return a copy to prevent external mutation
+    }
+}
+export default RSCRequestTracker;
+//# sourceMappingURL=RSCRequestTracker.js.map

package/lib/RSCRoute.d.ts

@@ -0,0 +1,30 @@
+import { type ReactNode } from 'react';
+/**
+ * Renders a React Server Component inside a React Client Component.
+ *
+ * RSCRoute provides a bridge between client and server components, allowing server components
+ * to be directly rendered inside client components. This component:
+ *
+ * 1. During initial SSR - Uses the RSC payload to render the server component and embeds the payload in the page
+ * 2. During hydration - Uses the embedded RSC payload already in the page
+ * 3. During client navigation - Fetches the RSC payload via HTTP
+ *
+ * @example
+ * ```tsx
+ * <RSCRoute componentName="MyServerComponent" componentProps={{ user }} />
+ * ```
+ *
+ * @important Only use for server components whose props change rarely. Frequent prop changes
+ * will cause network requests for each change, impacting performance.
+ *
+ * @important This component expects that the component tree that contains it is wrapped using
+ * wrapServerComponentRenderer from 'react-on-rails/wrapServerComponentRenderer/client' for client-side
+ * rendering or 'react-on-rails/wrapServerComponentRenderer/server' for server-side rendering.
+ */
+export type RSCRouteProps = {
+    componentName: string;
+    componentProps: unknown;
+};
+declare const RSCRoute: ({ componentName, componentProps }: RSCRouteProps) => ReactNode;
+export default RSCRoute;
+//# sourceMappingURL=RSCRoute.d.ts.map

package/lib/RSCRoute.js

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2025 Shakacode LLC
+ *
+ * This file is NOT licensed under the MIT (open source) license.
+ * It is part of the React on Rails Pro offering and is licensed separately.
+ *
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without a valid license agreement
+ * from Shakacode LLC.
+ *
+ * For licensing terms, please see:
+ * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+ */
+/// <reference types="react/experimental" />
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Component, use } from 'react';
+import { useRSC } from "./RSCProvider.js";
+import { ServerComponentFetchError } from "./ServerComponentFetchError.js";
+/**
+ * Error boundary component for RSCRoute that adds server component name and props to the error
+ * So, the parent ErrorBoundary can refetch the server component
+ */
+class RSCRouteErrorBoundary extends Component {
+    constructor(props) {
+        super(props);
+        this.state = { error: null };
+    }
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    render() {
+        const { error } = this.state;
+        const { componentName, componentProps, children } = this.props;
+        if (error) {
+            throw new ServerComponentFetchError(error.message, componentName, componentProps, error);
+        }
+        return children;
+    }
+}
+const PromiseWrapper = ({ promise }) => {
+    // use is available in React 18.3+
+    const promiseResult = use(promise);
+    // In case that an error happened during the rendering of the RSC payload before the rendering of the component itself starts
+    // RSC bundle will return an error object serialized inside the RSC payload
+    if (promiseResult instanceof Error) {
+        throw promiseResult;
+    }
+    return promiseResult;
+};
+const RSCRoute = ({ componentName, componentProps }) => {
+    const { getComponent } = useRSC();
+    const componentPromise = getComponent(componentName, componentProps);
+    return (_jsx(RSCRouteErrorBoundary, { componentName: componentName, componentProps: componentProps, children: _jsx(PromiseWrapper, { promise: componentPromise }) }));
+};
+export default RSCRoute;
+//# sourceMappingURL=RSCRoute.js.map

package/lib/ReactOnRails.client.d.ts

@@ -0,0 +1,4 @@
+declare const ReactOnRails: import("react-on-rails/types").ReactOnRailsInternal;
+export * from 'react-on-rails/types';
+export default ReactOnRails;
+//# sourceMappingURL=ReactOnRails.client.d.ts.map

package/lib/ReactOnRails.client.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2025 Shakacode LLC
+ *
+ * This file is NOT licensed under the MIT (open source) license.
+ * It is part of the React on Rails Pro offering and is licensed separately.
+ *
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without a valid license agreement
+ * from Shakacode LLC.
+ *
+ * For licensing terms, please see:
+ * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+ */
+import { createBaseClientObject } from 'react-on-rails/@internal/base/client';
+import createReactOnRailsPro from "./createReactOnRailsPro.js";
+const currentGlobal = globalThis.ReactOnRails || null;
+const ReactOnRails = createReactOnRailsPro(createBaseClientObject, currentGlobal);
+export * from 'react-on-rails/types';
+export default ReactOnRails;
+//# sourceMappingURL=ReactOnRails.client.js.map

package/lib/ReactOnRails.full.d.ts

@@ -0,0 +1,4 @@
+declare const ReactOnRails: import("react-on-rails/types").ReactOnRailsInternal;
+export * from 'react-on-rails/types';
+export default ReactOnRails;
+//# sourceMappingURL=ReactOnRails.full.d.ts.map

package/lib/ReactOnRails.full.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2025 Shakacode LLC
+ *
+ * This file is NOT licensed under the MIT (open source) license.
+ * It is part of the React on Rails Pro offering and is licensed separately.
+ *
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without a valid license agreement
+ * from Shakacode LLC.
+ *
+ * For licensing terms, please see:
+ * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+ */
+import { createBaseFullObject } from 'react-on-rails/@internal/base/full';
+import createReactOnRailsPro from "./createReactOnRailsPro.js";
+// Warn about bundle size when included in browser bundles
+if (typeof window !== 'undefined') {
+    console.warn('Optimization opportunity: "react-on-rails-pro" includes ~14KB of server-rendering code. ' +
+        'Browsers may not need it. See https://forum.shakacode.com/t/how-to-use-different-versions-of-a-file-for-client-and-server-rendering/1352 ' +
+        '(Requires creating a free account). Click this for the stack trace.');
+}
+const currentGlobal = globalThis.ReactOnRails || null;
+const ReactOnRails = createReactOnRailsPro(createBaseFullObject, currentGlobal);
+export * from 'react-on-rails/types';
+export default ReactOnRails;
+//# sourceMappingURL=ReactOnRails.full.js.map

package/lib/ReactOnRails.node.d.ts

@@ -0,0 +1,3 @@
+export * from './ReactOnRails.full.ts';
+export { default } from './ReactOnRails.full.ts';
+//# sourceMappingURL=ReactOnRails.node.d.ts.map

package/lib/ReactOnRails.node.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2025 Shakacode LLC
+ *
+ * This file is NOT licensed under the MIT (open source) license.
+ * It is part of the React on Rails Pro offering and is licensed separately.
+ *
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without a valid license agreement
+ * from Shakacode LLC.
+ *
+ * For licensing terms, please see:
+ * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+ */
+import ReactOnRails from "./ReactOnRails.full.js";
+import streamServerRenderedReactComponent from "./streamServerRenderedReactComponent.js";
+// Add Pro server-side streaming functionality
+ReactOnRails.streamServerRenderedReactComponent = streamServerRenderedReactComponent;
+export * from "./ReactOnRails.full.js";
+// eslint-disable-next-line no-restricted-exports -- see https://github.com/eslint/eslint/issues/15617
+export { default } from "./ReactOnRails.full.js";
+//# sourceMappingURL=ReactOnRails.node.js.map

package/lib/ReactOnRailsRSC.d.ts

@@ -0,0 +1,4 @@
+import ReactOnRails from './ReactOnRails.full.ts';
+export * from 'react-on-rails/types';
+export default ReactOnRails;
+//# sourceMappingURL=ReactOnRailsRSC.d.ts.map

package/lib/ReactOnRailsRSC.js

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2025 Shakacode LLC
+ *
+ * This file is NOT licensed under the MIT (open source) license.
+ * It is part of the React on Rails Pro offering and is licensed separately.
+ *
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without a valid license agreement
+ * from Shakacode LLC.
+ *
+ * For licensing terms, please see:
+ * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+ */
+import { buildServerRenderer } from 'react-on-rails-rsc/server.node';
+import { assertRailsContextWithServerStreamingCapabilities, } from 'react-on-rails/types';
+import { convertToError } from 'react-on-rails/serverRenderUtils';
+import handleError from "./handleErrorRSC.js";
+import ReactOnRails from "./ReactOnRails.full.js";
+import { streamServerRenderedComponent, transformRenderStreamChunksToResultObject, } from "./streamingUtils.js";
+import loadJsonFile from "./loadJsonFile.js";
+let serverRendererPromise;
+const streamRenderRSCComponent = (reactRenderingResult, options, streamingTrackers) => {
+    const { throwJsErrors } = options;
+    const { railsContext } = options;
+    assertRailsContextWithServerStreamingCapabilities(railsContext);
+    const { reactClientManifestFileName } = railsContext;
+    const renderState = {
+        result: null,
+        hasErrors: false,
+        isShellReady: true,
+    };
+    const { pipeToTransform, readableStream, emitError } = transformRenderStreamChunksToResultObject(renderState);
+    const reportError = (error) => {
+        console.error('Error in RSC stream', error);
+        if (throwJsErrors) {
+            emitError(error);
+        }
+        renderState.hasErrors = true;
+        renderState.error = error;
+    };
+    const initializeAndRender = async () => {
+        if (!serverRendererPromise) {
+            serverRendererPromise = loadJsonFile(reactClientManifestFileName)
+                .then((reactClientManifest) => buildServerRenderer(reactClientManifest))
+                .catch((err) => {
+                serverRendererPromise = undefined;
+                throw err;
+            });
+        }
+        const { renderToPipeableStream } = await serverRendererPromise;
+        const rscStream = renderToPipeableStream(await reactRenderingResult, {
+            onError: (err) => {
+                const error = convertToError(err);
+                reportError(error);
+            },
+        });
+        pipeToTransform(rscStream);
+    };
+    initializeAndRender().catch((e) => {
+        const error = convertToError(e);
+        reportError(error);
+        const errorHtml = handleError({ e: error, name: options.name, serverSide: true });
+        pipeToTransform(errorHtml);
+    });
+    readableStream.on('end', () => {
+        streamingTrackers.postSSRHookTracker.notifySSREnd();
+    });
+    return readableStream;
+};
+ReactOnRails.serverRenderRSCReactComponent = (options) => {
+    try {
+        return streamServerRenderedComponent(options, streamRenderRSCComponent, handleError);
+    }
+    finally {
+        console.history = [];
+    }
+};
+ReactOnRails.isRSCBundle = true;
+export * from 'react-on-rails/types';
+export default ReactOnRails;
+//# sourceMappingURL=ReactOnRailsRSC.js.map

package/lib/ServerComponentFetchError.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Custom error type for when there's an issue fetching or rendering a server component.
+ * This error includes information about the server component and the original error that occurred.
+ */
+export declare class ServerComponentFetchError extends Error {
+    serverComponentName: string;
+    serverComponentProps: unknown;
+    originalError: Error;
+    constructor(message: string, componentName: string, componentProps: unknown, originalError: Error);
+}
+/**
+ * Type guard to check if an error is a ServerComponentFetchError
+ */
+export declare function isServerComponentFetchError(error: unknown): error is ServerComponentFetchError;
+//# sourceMappingURL=ServerComponentFetchError.d.ts.map

package/lib/ServerComponentFetchError.js

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025 Shakacode LLC
+ *
+ * This file is NOT licensed under the MIT (open source) license.
+ * It is part of the React on Rails Pro offering and is licensed separately.
+ *
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without a valid license agreement
+ * from Shakacode LLC.
+ *
+ * For licensing terms, please see:
+ * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+ */
+/**
+ * Custom error type for when there's an issue fetching or rendering a server component.
+ * This error includes information about the server component and the original error that occurred.
+ */
+export class ServerComponentFetchError extends Error {
+    constructor(message, componentName, componentProps, originalError) {
+        super(message);
+        this.name = 'ServerComponentFetchError';
+        this.serverComponentName = componentName;
+        this.serverComponentProps = componentProps;
+        this.originalError = originalError;
+    }
+}
+/**
+ * Type guard to check if an error is a ServerComponentFetchError
+ */
+export function isServerComponentFetchError(error) {
+    return error instanceof ServerComponentFetchError;
+}
+//# sourceMappingURL=ServerComponentFetchError.js.map

package/lib/StoreRegistry.d.ts

@@ -0,0 +1,59 @@
+import type { Store, StoreGenerator } from 'react-on-rails/types';
+/**
+ * Register a store generator, a function that takes props and returns a store.
+ * @param storeGenerators { name1: storeGenerator1, name2: storeGenerator2 }
+ * @public
+ */
+export declare function register(storeGenerators: Record<string, StoreGenerator>): void;
+/**
+ * Used by components to get the hydrated store which contains props.
+ * @param name
+ * @param throwIfMissing Defaults to true. Set to false to have this call return undefined if
+ *        there is no store with the given name.
+ * @returns Redux Store, possibly hydrated
+ * @public
+ */
+export declare function getStore(name: string, throwIfMissing?: boolean): Store | undefined;
+/**
+ * Internally used function to get the store creator that was passed to `register`.
+ * @param name
+ * @returns storeCreator with given name
+ * @public
+ */
+export declare const getStoreGenerator: (name: string) => StoreGenerator;
+/**
+ * Internally used function to set the hydrated store after a Rails page is loaded.
+ * @param name
+ * @param store (not the storeGenerator, but the hydrated store)
+ */
+export declare function setStore(name: string, store: Store): void;
+/**
+ * Internally used function to completely clear hydratedStores Map.
+ * @public
+ */
+export declare function clearHydratedStores(): void;
+/**
+ * Get a Map containing all registered store generators. Useful for debugging.
+ * @returns Map where key is the component name and values are the store generators.
+ * @public
+ */
+export declare const storeGenerators: () => Map<string, StoreGenerator>;
+/**
+ * Get a Map containing all hydrated stores. Useful for debugging.
+ * @returns Map where key is the component name and values are the hydrated stores.
+ * @public
+ */
+export declare const stores: () => Map<string, Store>;
+/**
+ * Used by components to get the hydrated store, waiting for it to be hydrated if necessary.
+ * @param name Name of the store to wait for
+ * @returns Promise that resolves with the Store once hydrated
+ */
+export declare const getOrWaitForStore: (name: string) => Promise<Store>;
+/**
+ * Used by components to get the store generator, waiting for it to be registered if necessary.
+ * @param name Name of the store generator to wait for
+ * @returns Promise that resolves with the StoreGenerator once registered
+ */
+export declare const getOrWaitForStoreGenerator: (name: string) => Promise<StoreGenerator>;
+//# sourceMappingURL=StoreRegistry.d.ts.map