waku 0.21.3 → 0.21.4

package/README.md

@@ -574,7 +574,7 @@ export default async function HomePage() {
   return (
     <>
       <title>Waku</title>
-      <meta property="description" content="The minimal React framework" />
+      <meta name="description" content="The minimal React framework" />
       <h1>Waku</h1>
       <div>Hello world!</div>
     </>
@@ -607,7 +607,7 @@ const Head = async () => {
   return (
     <>
       <title>{metadata.title}</title>
-      <meta property="description" content={metadata.description} />
+      <meta name="description" content={metadata.description} />
     </>
   );
 };

package/dist/client.d.ts

@@ -1,66 +1,150 @@
-import { Component } from 'react';
-import type { ReactNode } from 'react';
-declare global {
-    interface ImportMeta {
-        readonly env: Record<string, string>;
-    }
-}
-type Elements = Promise<Record<string, ReactNode>> & {
-    prev?: Record<string, ReactNode> | undefined;
-};
-type SetElements = (updater: (prev: Elements) => Elements) => void;
-type EnhanceCreateData = (createData: (responsePromise: Promise<Response>) => Promise<Record<string, ReactNode>>) => (responsePromise: Promise<Response>) => Promise<Record<string, ReactNode>>;
-declare const ENTRY = "e";
-declare const SET_ELEMENTS = "s";
-declare const ENHANCE_CREATE_DATA = "d";
-type FetchCache = {
-    [ENTRY]?: [input: string, params: unknown, elements: Elements];
-    [SET_ELEMENTS]?: SetElements;
-    [ENHANCE_CREATE_DATA]?: EnhanceCreateData | undefined;
-};
-/**
- * callServer callback
- * This is not a public API.
- */
-export declare const callServerRSC: (actionId: string, args?: unknown[], fetchCache?: FetchCache) => Promise<bigint | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | import("react").AwaitedReactNode>;
-export declare const fetchRSC: (input: string, params?: unknown, fetchCache?: FetchCache) => Elements;
-export declare const prefetchRSC: (input: string, params?: unknown) => void;
-export declare const Root: ({ initialInput, initialParams, fetchCache, unstable_enhanceCreateData, children, }: {
-    initialInput?: string;
-    initialParams?: unknown;
-    fetchCache?: FetchCache;
-    unstable_enhanceCreateData?: EnhanceCreateData;
-    children: ReactNode;
-}) => import("react").FunctionComponentElement<import("react").ProviderProps<(input: string, params?: unknown) => void>>;
-export declare const useRefetch: () => (input: string, params?: unknown) => void;
-type OuterSlotProps = {
-    elementsPromise: Elements;
-    shouldRenderPrev: ((err: unknown) => boolean) | undefined;
-    renderSlot: (elements: Record<string, ReactNode>) => ReactNode;
-    children?: ReactNode;
-};
-declare class OuterSlot extends Component<OuterSlotProps, {
-    error?: unknown;
-}> {
-    constructor(props: OuterSlotProps);
-    static getDerivedStateFromError(error: unknown): {
-        error: unknown;
-    };
-    render(): ReactNode;
-}
+/** @deprecated */
+export declare const Children: () => import("react").ReactNode;
+/** @deprecated */
 export declare const Slot: ({ id, children, fallback, unstable_shouldRenderPrev, }: {
     id: string;
-    children?: ReactNode;
-    fallback?: ReactNode;
+    children?: import("react").ReactNode;
+    fallback?: import("react").ReactNode;
     unstable_shouldRenderPrev?: (err: unknown) => boolean;
-}) => import("react").CElement<OuterSlotProps, OuterSlot>;
-export declare const Children: () => ReactNode;
-/**
- * ServerRoot for SSR
- * This is not a public API.
- */
+}) => import("react").CElement<{
+    elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+        prev?: Record<string, import("react").ReactNode> | undefined;
+    };
+    shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+    renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+    children?: import("react").ReactNode;
+}, {
+    render(): import("react").ReactNode;
+    context: unknown;
+    setState<K extends "error">(state: {
+        error?: unknown;
+    } | ((prevState: Readonly<{
+        error?: unknown;
+    }>, props: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>) => {
+        error?: unknown;
+    } | Pick<{
+        error?: unknown;
+    }, K> | null) | Pick<{
+        error?: unknown;
+    }, K> | null, callback?: (() => void) | undefined): void;
+    forceUpdate(callback?: (() => void) | undefined): void;
+    readonly props: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>;
+    state: Readonly<{
+        error?: unknown;
+    }>;
+    refs: {
+        [key: string]: import("react").ReactInstance;
+    };
+    componentDidMount?(): void;
+    shouldComponentUpdate?(nextProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, nextState: Readonly<{
+        error?: unknown;
+    }>, nextContext: any): boolean;
+    componentWillUnmount?(): void;
+    componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+    getSnapshotBeforeUpdate?(prevProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, prevState: Readonly<{
+        error?: unknown;
+    }>): any;
+    componentDidUpdate?(prevProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, prevState: Readonly<{
+        error?: unknown;
+    }>, snapshot?: any): void;
+    componentWillMount?(): void;
+    UNSAFE_componentWillMount?(): void;
+    componentWillReceiveProps?(nextProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, nextContext: any): void;
+    UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, nextContext: any): void;
+    componentWillUpdate?(nextProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, nextState: Readonly<{
+        error?: unknown;
+    }>, nextContext: any): void;
+    UNSAFE_componentWillUpdate?(nextProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, nextState: Readonly<{
+        error?: unknown;
+    }>, nextContext: any): void;
+}>;
+/** @deprecated */
+export declare const Root: ({ initialRscPath, initialRscParams, fetchCache, unstable_enhanceCreateData, children, }: {
+    initialRscPath?: string;
+    initialRscParams?: unknown;
+    fetchCache?: {
+        e?: [rscPath: string, rscParams: unknown, elements: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        }];
+        s?: (updater: (prev: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        }) => Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        }) => void;
+        d?: ((createData: (responsePromise: Promise<Response>) => Promise<Record<string, import("react").ReactNode>>) => (responsePromise: Promise<Response>) => Promise<Record<string, import("react").ReactNode>>) | undefined;
+    };
+    unstable_enhanceCreateData?: (createData: (responsePromise: Promise<Response>) => Promise<Record<string, import("react").ReactNode>>) => (responsePromise: Promise<Response>) => Promise<Record<string, import("react").ReactNode>>;
+    children: import("react").ReactNode;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<(rscPath: string, rscParams?: unknown) => void>>;
+/** @deprecated */
 export declare const ServerRoot: ({ elements, children, }: {
-    elements: Elements;
-    children: ReactNode;
-}) => import("react").FunctionComponentElement<import("react").ProviderProps<Elements | null>>;
-export {};
+    elements: Promise<Record<string, import("react").ReactNode>> & {
+        prev?: Record<string, import("react").ReactNode> | undefined;
+    };
+    children: import("react").ReactNode;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<(Promise<Record<string, import("react").ReactNode>> & {
+    prev?: Record<string, import("react").ReactNode> | undefined;
+}) | null>>;

package/dist/client.js

@@ -1,205 +1,5 @@
-/// <reference types="react/canary" />
-'use client';
-import { Component, createContext, createElement, memo, use, useCallback, useEffect, useState } from 'react';
-import RSDWClient from 'react-server-dom-webpack/client';
-import { encodeInput, encodeActionId } from './lib/renderers/utils.js';
-const { createFromFetch, encodeReply } = RSDWClient;
-const BASE_PATH = `${import.meta.env?.WAKU_CONFIG_BASE_PATH}${import.meta.env?.WAKU_CONFIG_RSC_PATH}/`;
-const checkStatus = async (responsePromise)=>{
-    const response = await responsePromise;
-    if (!response.ok) {
-        const err = new Error(response.statusText);
-        err.statusCode = response.status;
-        throw err;
-    }
-    return response;
-};
-const getCached = (c, m, k)=>(m.has(k) ? m : m.set(k, c())).get(k);
-const cache1 = new WeakMap();
-const mergeElements = (a, b)=>{
-    const getResult = ()=>{
-        const promise = new Promise((resolve, reject)=>{
-            Promise.all([
-                a,
-                b
-            ]).then(([a, b])=>{
-                const nextElements = {
-                    ...a,
-                    ...b
-                };
-                delete nextElements._value;
-                promise.prev = a;
-                resolve(nextElements);
-            }).catch((e)=>{
-                a.then((a)=>{
-                    promise.prev = a;
-                    reject(e);
-                }, ()=>{
-                    promise.prev = a.prev;
-                    reject(e);
-                });
-            });
-        });
-        return promise;
-    };
-    const cache2 = getCached(()=>new WeakMap(), cache1, a);
-    return getCached(getResult, cache2, b);
-};
-const ENTRY = 'e';
-const SET_ELEMENTS = 's';
-const ENHANCE_CREATE_DATA = 'd';
-const defaultFetchCache = {};
-/**
- * callServer callback
- * This is not a public API.
- */ export const callServerRSC = async (actionId, args, fetchCache = defaultFetchCache)=>{
-    const enhanceCreateData = fetchCache[ENHANCE_CREATE_DATA] || ((d)=>d);
-    const createData = (responsePromise)=>createFromFetch(checkStatus(responsePromise), {
-            callServer: (actionId, args)=>callServerRSC(actionId, args, fetchCache)
-        });
-    const url = BASE_PATH + encodeInput(encodeActionId(actionId));
-    const responsePromise = args === undefined ? fetch(url) : encodeReply(args).then((body)=>fetch(url, {
-            method: 'POST',
-            body
-        }));
-    const data = enhanceCreateData(createData)(responsePromise);
-    // FIXME this causes rerenders even if data is empty
-    fetchCache[SET_ELEMENTS]?.((prev)=>mergeElements(prev, data));
-    return (await data)._value;
-};
-const prefetchedParams = new WeakMap();
-const fetchRSCInternal = (url, params)=>params === undefined ? fetch(url) : typeof params === 'string' ? fetch(url, {
-        headers: {
-            'X-Waku-Params': params
-        }
-    }) : encodeReply(params).then((body)=>fetch(url, {
-            method: 'POST',
-            body
-        }));
-export const fetchRSC = (input, params, fetchCache = defaultFetchCache)=>{
-    const entry = fetchCache[ENTRY];
-    if (entry && entry[0] === input && entry[1] === params) {
-        return entry[2];
-    }
-    const enhanceCreateData = fetchCache[ENHANCE_CREATE_DATA] || ((d)=>d);
-    const createData = (responsePromise)=>createFromFetch(checkStatus(responsePromise), {
-            callServer: (actionId, args)=>callServerRSC(actionId, args, fetchCache)
-        });
-    const prefetched = globalThis.__WAKU_PREFETCHED__ ||= {};
-    const url = BASE_PATH + encodeInput(input);
-    const hasValidPrefetchedResponse = !!prefetched[url] && // HACK .has() is for the initial hydration
-    // It's limited and may result in a wrong result. FIXME
-    (!prefetchedParams.has(prefetched[url]) || prefetchedParams.get(prefetched[url]) === params);
-    const responsePromise = hasValidPrefetchedResponse ? prefetched[url] : fetchRSCInternal(url, params);
-    delete prefetched[url];
-    const data = enhanceCreateData(createData)(responsePromise);
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    fetchCache[ENTRY] = [
-        input,
-        params,
-        data
-    ];
-    return data;
-};
-export const prefetchRSC = (input, params)=>{
-    const prefetched = globalThis.__WAKU_PREFETCHED__ ||= {};
-    const url = BASE_PATH + encodeInput(input);
-    if (!(url in prefetched)) {
-        prefetched[url] = fetchRSCInternal(url, params);
-        prefetchedParams.set(prefetched[url], params);
-    }
-};
-const RefetchContext = createContext(()=>{
-    throw new Error('Missing Root component');
-});
-const ElementsContext = createContext(null);
-export const Root = ({ initialInput, initialParams, fetchCache = defaultFetchCache, unstable_enhanceCreateData, children })=>{
-    fetchCache[ENHANCE_CREATE_DATA] = unstable_enhanceCreateData;
-    const [elements, setElements] = useState(()=>fetchRSC(initialInput || '', initialParams, fetchCache));
-    useEffect(()=>{
-        fetchCache[SET_ELEMENTS] = setElements;
-    }, [
-        fetchCache,
-        setElements
-    ]);
-    const refetch = useCallback((input, params)=>{
-        // clear cache entry before fetching
-        delete fetchCache[ENTRY];
-        const data = fetchRSC(input, params, fetchCache);
-        setElements((prev)=>mergeElements(prev, data));
-    }, [
-        fetchCache
-    ]);
-    return createElement(RefetchContext.Provider, {
-        value: refetch
-    }, createElement(ElementsContext.Provider, {
-        value: elements
-    }, children));
-};
-export const useRefetch = ()=>use(RefetchContext);
-const ChildrenContext = createContext(undefined);
-const ChildrenContextProvider = memo(ChildrenContext.Provider);
-class OuterSlot extends Component {
-    constructor(props){
-        super(props);
-        this.state = {};
-    }
-    static getDerivedStateFromError(error) {
-        return {
-            error
-        };
-    }
-    render() {
-        if ('error' in this.state) {
-            const e = this.state.error;
-            if (e instanceof Error && !('statusCode' in e)) {
-                // HACK we assume any error as Not Found,
-                // probably caused by history api fallback
-                e.statusCode = 404;
-            }
-            if (this.props.shouldRenderPrev?.(e) && this.props.elementsPromise.prev) {
-                const elements = this.props.elementsPromise.prev;
-                return this.props.renderSlot(elements);
-            } else {
-                throw e;
-            }
-        }
-        return this.props.children;
-    }
-}
-const InnerSlot = ({ elementsPromise, renderSlot })=>{
-    const elements = use(elementsPromise);
-    return renderSlot(elements);
-};
-export const Slot = ({ id, children, fallback, unstable_shouldRenderPrev })=>{
-    const elementsPromise = use(ElementsContext);
-    if (!elementsPromise) {
-        throw new Error('Missing Root component');
-    }
-    const renderSlot = (elements)=>{
-        if (!(id in elements)) {
-            if (fallback) {
-                return fallback;
-            }
-            throw new Error('Not found: ' + id);
-        }
-        return createElement(ChildrenContextProvider, {
-            value: children
-        }, elements[id]);
-    };
-    return createElement(OuterSlot, {
-        elementsPromise,
-        shouldRenderPrev: unstable_shouldRenderPrev,
-        renderSlot
-    }, createElement(InnerSlot, {
-        elementsPromise,
-        renderSlot
-    }));
-};
-export const Children = ()=>use(ChildrenContext);
-/**
- * ServerRoot for SSR
- * This is not a public API.
- */ export const ServerRoot = ({ elements, children })=>createElement(ElementsContext.Provider, {
-        value: elements
-    }, children);
+import { Children as ChildrenOrig, Slot as SlotOrig, Root as RootOrig, ServerRootInternal as ServerRootOrig } from './minimal/client.js';
+/** @deprecated */ export const Children = ChildrenOrig;
+/** @deprecated */ export const Slot = SlotOrig;
+/** @deprecated */ export const Root = RootOrig;
+/** @deprecated */ export const ServerRoot = ServerRootOrig;

package/dist/config.d.ts

@@ -31,16 +31,16 @@ export interface Config {
      */
     privateDir?: string;
     /**
-     * Prefix for HTTP requests to indicate RSC requests.
+     * Bse path for HTTP requests to indicate RSC requests.
      * Defaults to "RSC".
      */
-    rscPath?: string;
+    rscBase?: string;
     /**
      * Middleware to use
      * Defaults to:
      * () => [
+     *   import('waku/middleware/context'),
      *   import('waku/middleware/dev-server'),
-     *   import('waku/middleware/headers'),
      *   import('waku/middleware/rsc'),
      *   import('waku/middleware/ssr'),
      * ]