@uniformdev/canvas-next-rsc 19.99.0 → 19.100.0

package/dist/UniformComposition-38e22896.d.ts

@@ -0,0 +1,61 @@
+import * as React$1 from 'react';
+import { ComponentType, ReactNode } from 'react';
+import { CompositionResolvedGetResponse, ComponentInstance } from '@uniformdev/canvas';
+import { PageParameters, ComponentProps, CompositionContext, AppDirectoryServerContext } from '@uniformdev/canvas-next-rsc-shared';
+
+type UniformStaticCompositionProps = {
+    /**
+     * How to render the composition.
+     */
+    mode: 'static';
+};
+type UniformServerCompositionProps = {
+    /**
+     * How to render the composition.
+     */
+    mode: 'server';
+    /**
+     * The Context instance to use for server-side rendering.
+     */
+    serverContext?: AppDirectoryServerContext;
+};
+type UniformCompositionProps = PageParameters & {
+    composition?: CompositionResolvedGetResponse;
+    /**
+     * Function to map composition components to React components.
+     */
+    resolveComponent: ResolveComponentFunction;
+} & (UniformStaticCompositionProps | UniformServerCompositionProps);
+declare const UniformComposition: React.FC<UniformCompositionProps>;
+type ResolveComponentFunction = (options: {
+    component: ComponentInstance;
+}) => ResolveComponentResult;
+type ResolveComponentResult = {
+    component: ComponentType<ComponentProps<any, any>> | null;
+    includeContext?: boolean;
+};
+declare const resolveComposition: (props: Omit<ResolveComponentsOptions, 'slotName' | 'slotIndex' | 'target'> & {
+    composition: ComponentInstance;
+    compositionContext: CompositionContext;
+}) => React$1.FunctionComponentElement<{
+    children?: ReactNode;
+}> | null;
+type ResolveComponentsOptions = {
+    serverContext?: AppDirectoryServerContext;
+    target: {
+        type: 'root';
+        composition: ComponentInstance;
+    } | {
+        type: 'slot';
+        components: ComponentInstance[];
+        parent: ComponentInstance;
+        root: ComponentInstance;
+    };
+    slotName: string | undefined;
+    slotIndex: number | undefined;
+    resolveComponent: ResolveComponentFunction;
+    compositionContext: CompositionContext;
+    mode: UniformCompositionProps['mode'];
+};
+
+export { ResolveComponentFunction as R, UniformCompositionProps as U, UniformComposition as a, ResolveComponentResult as b, resolveComposition as r };

package/dist/UniformComposition-d178d865.d.ts

@@ -0,0 +1,64 @@
+import * as React$1 from 'react';
+import { ComponentType, ReactNode } from 'react';
+import { ResolvedRouteGetResponse, ComponentInstance } from '@uniformdev/canvas';
+import { PageParameters, ComponentProps, CompositionContext, AppDirectoryServerContext } from '@uniformdev/canvas-next-rsc-shared';
+
+type UniformStaticCompositionProps = {
+    /**
+     * How to render the composition.
+     */
+    mode: 'static';
+};
+type UniformServerCompositionProps = {
+    /**
+     * How to render the composition.
+     */
+    mode: 'server';
+    /**
+     * The Context instance to use for server-side rendering.
+     */
+    serverContext?: AppDirectoryServerContext;
+};
+type UniformCompositionProps = PageParameters & {
+    /**
+     * The route data to render.
+     */
+    route: ResolvedRouteGetResponse | undefined;
+    /**
+     * Function to map composition components to React components.
+     */
+    resolveComponent: ResolveComponentFunction;
+} & (UniformStaticCompositionProps | UniformServerCompositionProps);
+declare const UniformComposition: React.FC<UniformCompositionProps>;
+type ResolveComponentFunction = (options: {
+    component: ComponentInstance;
+}) => ResolveComponentResult;
+type ResolveComponentResult = {
+    component: ComponentType<ComponentProps<any, any>> | null;
+    includeContext?: boolean;
+};
+declare const resolveComposition: (props: Omit<ResolveComponentsOptions, 'slotName' | 'slotIndex' | 'target'> & {
+    composition: ComponentInstance;
+    compositionContext: CompositionContext;
+}) => React$1.FunctionComponentElement<{
+    children?: ReactNode;
+}> | null;
+type ResolveComponentsOptions = {
+    serverContext?: AppDirectoryServerContext;
+    target: {
+        type: 'root';
+        composition: ComponentInstance;
+    } | {
+        type: 'slot';
+        components: ComponentInstance[];
+        parent: ComponentInstance;
+        root: ComponentInstance;
+    };
+    slotName: string | undefined;
+    slotIndex: number | undefined;
+    resolveComponent: ResolveComponentFunction;
+    compositionContext: CompositionContext;
+    mode: UniformCompositionProps['mode'];
+};
+
+export { ResolveComponentFunction as R, UniformCompositionProps as U, UniformComposition as a, ResolveComponentResult as b, resolveComposition as r };

package/dist/actions/updateContext.d.ts

@@ -0,0 +1,2 @@
+import { ContextState } from '@uniformdev/context';
+export declare const updateContextAction: (options: Partial<ContextState>) => Promise<void>;

package/dist/actions/updateContext.js

@@ -0,0 +1,17 @@
+'use server';
+import { UNIFORM_DEFAULT_COOKIE_NAME } from '@uniformdev/context';
+import { cookies } from 'next/headers';
+import { getUniformContext } from '../components/getUniformContext';
+import { serializeCookie } from '../score';
+export const updateContextAction = async (options) => {
+    var _a;
+    const context = await getUniformContext({
+        cookieValue: (_a = cookies().get(UNIFORM_DEFAULT_COOKIE_NAME)) === null || _a === void 0 ? void 0 : _a.value,
+    });
+    if (!context.storage.data.consent) {
+        return;
+    }
+    await context.update(options);
+    const scoreCookie = serializeCookie(context.storage.data);
+    cookies().set(UNIFORM_DEFAULT_COOKIE_NAME, scoreCookie);
+};

package/dist/client/canvasClient.d.ts

@@ -0,0 +1,5 @@
+import { CanvasClient } from '@uniformdev/canvas';
+export type GetCanvasClientOptions = {
+    revalidate?: number;
+};
+export declare const getCanvasClient: (options?: GetCanvasClientOptions) => CanvasClient;

package/dist/client/canvasClient.js

@@ -0,0 +1,52 @@
+import { CanvasClient } from '@uniformdev/canvas';
+import { buildCompositionTag } from '../utils/tag';
+export const getCanvasClient = (options) => {
+    return new CanvasClient({
+        projectId: process.env.UNIFORM_PROJECT_ID,
+        apiHost: process.env.UNIFORM_API_HOST,
+        apiKey: process.env.UNIFORM_API_KEY,
+        edgeApiHost: process.env.UNIFORM_EDGE_API_HOST,
+        fetch: (req, init) => {
+            let requestedUrl;
+            if (typeof req === 'string') {
+                requestedUrl = new URL(req);
+            }
+            else if (req instanceof URL) {
+                requestedUrl = req;
+            }
+            else {
+                requestedUrl = new URL(req.url);
+            }
+            const tags = [];
+            if (requestedUrl) {
+                // this is here so this code breaks if parameters change here
+                const compositionIdKey = 'compositionId';
+                const compositionIdsKey = 'compositionIDs';
+                const compositionId = requestedUrl.searchParams.get(compositionIdKey);
+                const compositionIds = requestedUrl.searchParams.get(compositionIdsKey);
+                if (compositionId) {
+                    tags.push(buildCompositionTag(compositionId));
+                }
+                if (compositionIds) {
+                    const ids = compositionIds.split(',');
+                    for (let i = 0; i < ids.length; i++) {
+                        tags.push(buildCompositionTag(ids[i]));
+                    }
+                }
+            }
+            let revalidate = options === null || options === void 0 ? void 0 : options.revalidate;
+            let noCache = false;
+            if (revalidate === -1) {
+                noCache = true;
+                revalidate = undefined;
+            }
+            return fetch(req, {
+                ...init,
+                cache: noCache ? 'no-cache' : 'force-cache',
+                next: {
+                    revalidate,
+                },
+            });
+        },
+    });
+};

package/dist/client/manifestClient.d.ts

@@ -0,0 +1,161 @@
+import { ManifestClient } from '@uniformdev/context/api';
+export type GetManifestClientOptions = {
+    revalidate?: number;
+};
+export declare const getManifestClient: (options?: GetManifestClientOptions) => ManifestClient;
+export declare const getManifestFromApi: (options: {
+    searchParams: {
+        [key: string]: string | undefined;
+    } | undefined;
+}) => Promise<{
+    project: {
+        id?: string | undefined;
+        name?: string | undefined;
+        ui_version?: number | undefined;
+        pz?: {
+            sig?: {
+                [key: string]: {
+                    str: number;
+                    cap: number;
+                    dur: "p" | "s" | "t";
+                    crit: {
+                        type: "G";
+                        op?: "&" | "|" | undefined;
+                        clauses: ({
+                            type: "G";
+                            op?: "&" | "|" | undefined;
+                            clauses: (any | {
+                                type: "CK";
+                                cookieName: string;
+                                match: {
+                                    rhs: string;
+                                    op: "~" | "=" | "//" | "!=" | "!~" | "!//";
+                                    cs?: boolean | undefined;
+                                } | {
+                                    op: "*" | "!*";
+                                };
+                            } | {
+                                type: "QS";
+                                queryName: string;
+                                match: {
+                                    rhs: string;
+                                    op: "~" | "=" | "//" | "!=" | "!~" | "!//";
+                                    cs?: boolean | undefined;
+                                } | {
+                                    op: "*" | "!*";
+                                };
+                            } | {
+                                type: "QK";
+                                key: string;
+                                match: {
+                                    rhs: string;
+                                    op: "~" | "=" | "//" | "!=" | "!~" | "!//";
+                                    cs?: boolean | undefined;
+                                } | {
+                                    op: "*" | "!*";
+                                };
+                            } | {
+                                type: "EVT";
+                                event: {
+                                    rhs: string;
+                                    op: "~" | "=" | "//" | "!=" | "!~" | "!//";
+                                    cs?: boolean | undefined;
+                                } | {
+                                    op: "*" | "!*";
+                                };
+                            } | {
+                                type: "PV";
+                                path: {
+                                    rhs: string;
+                                    op: "~" | "=" | "//" | "!=" | "!~" | "!//";
+                                    cs?: boolean | undefined;
+                                } | {
+                                    op: "*" | "!*";
+                                };
+                            } | {
+                                type: "PVC";
+                                match: {
+                                    rhs: number;
+                                    op: "=" | "!=" | "<" | ">";
+                                };
+                            })[];
+                        } | {
+                            type: "CK";
+                            cookieName: string;
+                            match: {
+                                rhs: string;
+                                op: "~" | "=" | "//" | "!=" | "!~" | "!//";
+                                cs?: boolean | undefined;
+                            } | {
+                                op: "*" | "!*";
+                            };
+                        } | {
+                            type: "QS";
+                            queryName: string;
+                            match: {
+                                rhs: string;
+                                op: "~" | "=" | "//" | "!=" | "!~" | "!//";
+                                cs?: boolean | undefined;
+                            } | {
+                                op: "*" | "!*";
+                            };
+                        } | {
+                            type: "QK";
+                            key: string;
+                            match: {
+                                rhs: string;
+                                op: "~" | "=" | "//" | "!=" | "!~" | "!//";
+                                cs?: boolean | undefined;
+                            } | {
+                                op: "*" | "!*";
+                            };
+                        } | {
+                            type: "EVT";
+                            event: {
+                                rhs: string;
+                                op: "~" | "=" | "//" | "!=" | "!~" | "!//";
+                                cs?: boolean | undefined;
+                            } | {
+                                op: "*" | "!*";
+                            };
+                        } | {
+                            type: "PV";
+                            path: {
+                                rhs: string;
+                                op: "~" | "=" | "//" | "!=" | "!~" | "!//";
+                                cs?: boolean | undefined;
+                            } | {
+                                op: "*" | "!*";
+                            };
+                        } | {
+                            type: "PVC";
+                            match: {
+                                rhs: number;
+                                op: "=" | "!=" | "<" | ">";
+                            };
+                        })[];
+                    };
+                };
+            } | undefined;
+            enr?: {
+                [key: string]: {
+                    cap: number;
+                };
+            } | undefined;
+            agg?: {
+                [key: string]: {
+                    inputs: {
+                        dim: string;
+                        sign?: "-" | "+" | "c" | undefined;
+                    }[];
+                };
+            } | undefined;
+            control?: number | undefined;
+        } | undefined;
+        test?: {
+            [key: string]: {
+                wv?: string | undefined;
+            };
+        } | undefined;
+    };
+}>;

package/dist/client/manifestClient.js

@@ -0,0 +1,32 @@
+import { ManifestClient } from '@uniformdev/context/api';
+import { getManifestRevalidateInterval } from '../config/helpers';
+export const getManifestClient = (options) => {
+    const manifestClient = new ManifestClient({
+        apiHost: process.env.UNIFORM_API_HOST || process.env.UNIFORM_CLI_BASE_URL,
+        apiKey: process.env.UNIFORM_API_KEY,
+        projectId: process.env.UNIFORM_PROJECT_ID,
+        fetch: (req, init) => {
+            let revalidate = options === null || options === void 0 ? void 0 : options.revalidate;
+            let noCache = false;
+            if (revalidate === -1) {
+                noCache = true;
+                revalidate = undefined;
+            }
+            return fetch(req, {
+                ...init,
+                cache: noCache ? 'no-cache' : 'force-cache',
+                next: {
+                    revalidate,
+                    tags: ['manifest'],
+                },
+            });
+        },
+    });
+    return manifestClient;
+};
+export const getManifestFromApi = (options) => {
+    const manifestClient = getManifestClient({
+        revalidate: getManifestRevalidateInterval(options),
+    });
+    return manifestClient.get();
+};

package/dist/client/projectMapClient.d.ts

@@ -0,0 +1,5 @@
+import { ProjectMapClient } from '@uniformdev/project-map';
+export type GetProjectMapClientOptions = {
+    revalidate?: number;
+};
+export declare const getProjectMapClient: (options?: GetProjectMapClientOptions) => ProjectMapClient;

package/dist/client/projectMapClient.js

@@ -0,0 +1,17 @@
+import { ProjectMapClient } from '@uniformdev/project-map';
+export const getProjectMapClient = (options) => {
+    const manifestClient = new ProjectMapClient({
+        apiHost: process.env.UNIFORM_API_HOST || process.env.UNIFORM_CLI_BASE_URL,
+        apiKey: process.env.UNIFORM_API_KEY,
+        projectId: process.env.UNIFORM_PROJECT_ID,
+        fetch: (req, init) => {
+            return fetch(req, {
+                ...init,
+                next: {
+                    revalidate: options === null || options === void 0 ? void 0 : options.revalidate,
+                },
+            });
+        },
+    });
+    return manifestClient;
+};

package/dist/client/routeClient.d.ts

@@ -0,0 +1,5 @@
+import { RouteClient } from '@uniformdev/canvas';
+export type GetRouteClientOptions = {
+    revalidate?: number;
+};
+export declare const getRouteClient: (options?: GetRouteClientOptions) => RouteClient;

package/dist/client/routeClient.js

@@ -0,0 +1,56 @@
+import { RouteClient } from '@uniformdev/canvas';
+import { buildPathTag } from '../utils/tag';
+export const getRouteClient = (options) => {
+    const client = new RouteClient({
+        projectId: process.env.UNIFORM_PROJECT_ID,
+        apiKey: process.env.UNIFORM_API_KEY,
+        edgeApiHost: process.env.UNIFORM_EDGE_API_HOST,
+        fetch: (req, init) => {
+            let requestedUrl;
+            if (typeof req === 'string') {
+                requestedUrl = new URL(req);
+            }
+            else if (req instanceof URL) {
+                requestedUrl = req;
+            }
+            else {
+                requestedUrl = new URL(req.url);
+            }
+            const tags = [];
+            if (requestedUrl) {
+                // this is here so this code breaks if parameters change here
+                const pathKey = 'path';
+                const path = requestedUrl.searchParams.get(pathKey);
+                if (path) {
+                    // at this point, we do not know if this path is dynamic or not
+                    // so apply each segment as a tag so we can clear any segment, ie:
+                    // /authors/alex would add /authors and /authors/alex as tags
+                    const pieces = path.split('/');
+                    for (let i = 0; i < pieces.length; i++) {
+                        const segmentPieces = pieces.slice(0, i + 1);
+                        const segment = segmentPieces.join('/');
+                        tags.push(buildPathTag(segment));
+                    }
+                }
+            }
+            let revalidate;
+            let noCache = false;
+            if (options === null || options === void 0 ? void 0 : options.revalidate) {
+                revalidate = options.revalidate;
+            }
+            if (revalidate === -1) {
+                noCache = true;
+                revalidate = undefined;
+            }
+            return fetch(req, {
+                ...init,
+                cache: noCache ? 'no-cache' : 'force-cache',
+                next: {
+                    revalidate,
+                    tags: tags.length ? tags : undefined,
+                },
+            });
+        },
+    });
+    return client;
+};

package/dist/components/DefaultNotImplementedComponent.d.ts

@@ -0,0 +1,2 @@
+import { ComponentProps } from './UniformComponent';
+export declare function DefaultNotImplementedComponent(props: ComponentProps): JSX.Element | null;

package/dist/components/DefaultNotImplementedComponent.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CANVAS_LOCALIZATION_TYPE } from '@uniformdev/canvas';
+const wrapperStyles = {
+    display: 'flex',
+    flexDirection: 'column',
+    gap: '0.5rem',
+    borderLeft: '4px solid #e42535',
+    padding: '16px',
+    fontSize: '16px',
+    borderRadius: '0 8px 8px 0',
+    margin: '8px',
+    backgroundColor: 'rgba(255, 255, 255, 0.45)',
+    color: '#1d3557',
+};
+export function DefaultNotImplementedComponent(props) {
+    var _a, _b, _c;
+    const componentType = (_a = props.component) === null || _a === void 0 ? void 0 : _a.type;
+    if (!componentType) {
+        return null;
+    }
+    if (componentType === CANVAS_LOCALIZATION_TYPE) {
+        return (_jsx("div", { style: wrapperStyles, children: _jsxs("p", { children: ["Seems like localization is not enabled in your application. Please read our documentation on how to", ' ', _jsx("a", { href: "https://docs.uniform.app/guides/composition/localization#activate-front-end", target: "_blank", style: { fontWeight: 'bolder', textDecoration: 'underline' }, rel: "noreferrer", children: "enable localization in your front-end application." })] }) }));
+    }
+    const proposedFileName = `${componentType[0].toUpperCase()}${componentType.substring(1)}`;
+    const probableProps = Object.keys((_b = props.component.parameters) !== null && _b !== void 0 ? _b : {});
+    const probableSlots = Object.keys((_c = props.component.slots) !== null && _c !== void 0 ? _c : {});
+    return (_jsxs("div", { style: wrapperStyles, children: [_jsx("h2", { style: { fontSize: '1.2rem' }, children: "Unknown Component" }), _jsxs("p", { children: ["Received request from Uniform to render a component with the public ID: ", _jsx("code", { children: componentType }), "."] }), _jsxs("p", { children: [_jsx("code", { children: "<UniformComposition />" }), " does not have ", _jsx("code", { children: componentType }), " mapped to a React component yet."] }), _jsx("p", { children: "To teach your app how to render this component:" }), ' ', _jsxs("ul", { style: {
+                    listStyleType: 'disc',
+                    marginLeft: '1rem',
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: '0.5rem',
+                }, children: [_jsxs("li", { children: ["Create a React component and register it with Uniform, for example", _jsx("pre", { children: `function ${proposedFileName}(${probableProps.length > 0 ? `{ ${probableProps.join(', ')} }` : ''}) {
+  return (
+    <div>
+      ${proposedFileName}!
+      ${probableSlots.length > 0
+                                    ? probableSlots.map((slot) => `<UniformSlot name="${slot}" />`).join('\n      ')
+                                    : ''}
+    </div>
+  )
+}
+
+registerUniformComponent({ type: "${componentType}", component: ${proposedFileName} })` }), _jsxs("details", { children: [_jsx("summary", { style: { cursor: 'pointer' }, children: "Props that your React component will receive" }), _jsx("pre", { children: JSON.stringify(props, null, 2) })] })] }), _jsxs("li", { children: ["Import the component into the file where ", _jsx("code", { children: "<UniformComposition />" }), " is defined, for example ", _jsx("pre", { children: `import "../components/${proposedFileName}.tsx"` })] })] }), ' ', _jsxs("p", { children: ["Need more help?", ' ', _jsx("a", { href: "https://docs.uniform.app/docs/guides/composition/rendering", target: "_blank", rel: "noreferrer", style: { textDecoration: 'underline' }, children: "Check out the documentation." })] })] }));
+}

package/dist/components/GoogleTagManagerAnalytics.d.ts

@@ -0,0 +1,3 @@
+export declare const GoogleTagManagerAnalytics: (props?: {
+    measurementId?: string;
+}) => JSX.Element;

package/dist/components/GoogleTagManagerAnalytics.js

@@ -0,0 +1,44 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import Script from 'next/script';
+import { useEffect } from 'react';
+import { useUniformContext } from '../hooks/useUniformContext';
+const isGtagConfigured = () => {
+    return typeof window !== 'undefined' && typeof window.gtag === 'function';
+};
+export const GoogleTagManagerAnalytics = (props) => {
+    const { seenComponents } = useUniformContext();
+    useEffect(() => {
+        if (!(seenComponents === null || seenComponents === void 0 ? void 0 : seenComponents.length)) {
+            return;
+        }
+        if (!isGtagConfigured()) {
+            // eslint-disable-next-line no-console
+            console.warn('Google Tag Manager is not configured. Please add the gtag script to your site.');
+            return;
+        }
+        seenComponents.forEach((component) => {
+            var _a, _b, _c, _d, _e;
+            if (component.type === 'personalization') {
+                (_b = (_a = window).gtag) === null || _b === void 0 ? void 0 : _b.call(_a, 'event', component.id, {
+                    event_category: 'Uniform Personalization',
+                    event_label: component.variants.join(', '),
+                    is_control_group: component.control ? 1 : 0,
+                });
+            }
+            else if (component.type === 'test') {
+                (_d = (_c = window).gtag) === null || _d === void 0 ? void 0 : _d.call(_c, 'event', component.id, {
+                    event_category: 'Uniform AB Testing',
+                    event_label: (_e = component.variant) !== null && _e !== void 0 ? _e : 'No Variant',
+                });
+            }
+        });
+    }, [seenComponents]);
+    return (_jsx(_Fragment, { children: Boolean(props === null || props === void 0 ? void 0 : props.measurementId) && (_jsxs(_Fragment, { children: [_jsx(Script, { src: `https://www.googletagmanager.com/gtag/js?id=${props.measurementId}`, strategy: "afterInteractive" }), _jsx(Script, { id: "google-analytics", strategy: "afterInteractive", children: `
+      window.dataLayer = window.dataLayer || [];
+      function gtag(){window.dataLayer.push(arguments);}
+      gtag('js', new Date());
+
+      gtag('config', '${props.measurementId}');
+    ` })] })) }));
+};

package/dist/components/UniformComponent.d.ts

@@ -0,0 +1,22 @@
+import { type ComponentInstance, type RootComponentInstance } from '@uniformdev/canvas';
+import { ReactNode } from 'react';
+export type CompositionContext = {
+    composition: RootComponentInstance;
+    path: string;
+    state?: number;
+    searchParams: {
+        [key: string]: string | undefined;
+    } | undefined;
+};
+export type ComponentProps<TProps = unknown> = TProps & {
+    component: ComponentInstance;
+    context: CompositionContext;
+};
+export type UniformComponentProps<TRenderProps = unknown> = {
+    data: ComponentInstance;
+    context: CompositionContext;
+    children?: ReactNode | ((props: ComponentProps<TRenderProps>) => JSX.Element);
+};
+export declare function UniformComponent({ data, children, context }: UniformComponentProps): import("react").FunctionComponentElement<{
+    children?: ReactNode;
+}>;

package/dist/components/UniformComponent.js

@@ -0,0 +1,14 @@
+import { createElement, Fragment } from 'react';
+import { componentStoreResolver } from '../register/componentStoreResolver';
+import { resolveChildren } from '../resolve/resolveChildren';
+export function UniformComponent({ data, children, context }) {
+    const resolvedChildren = resolveChildren({
+        children,
+        data,
+        context,
+        hasParentLayout: false,
+        resolveRenderer: componentStoreResolver,
+    });
+    const childrenToRender = [resolvedChildren];
+    return createElement(Fragment, {}, childrenToRender);
+}

package/dist/components/UniformComposition.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode } from 'react';
+export type SuspenseOptions = {
+    mode: 'off';
+} | {
+    mode: 'fallback';
+    fallback: React.ReactNode;
+};
+export type UniformCompositionProps = {
+    /**
+     * The params object from Next.js router. Used to resolve a composition.
+     */
+    params: {
+        slug: string | string[];
+    };
+    /**
+     * The searchParams object from Next.js router. Used for signal evaluation.
+     */
+    searchParams?: {
+        [key: string]: string | undefined;
+    };
+    /**
+     * Behavior of root Suspense component.
+     */
+    suspense?: {
+        mode: 'off';
+    } | {
+        mode: 'fallback';
+        fallback: React.ReactNode;
+    };
+    /**
+     * The children of the UniformComposition component.
+     */
+    children?: ReactNode;
+};
+export declare const UniformComposition: ({ suspense, ...props }: UniformCompositionProps) => JSX.Element;