@uniformdev/canvas-next-rsc 20.31.1-alpha.1 → 20.31.1-alpha.185

package/dist/UniformComposition-IWWzoI_H.d.mts

@@ -0,0 +1,82 @@
+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;
+    /**
+     * Function to map empty placeholders to React components.
+     */
+    resolveEmptyPlaceholder?: ResolveEmptyPlaceholderFunction;
+} & (UniformStaticCompositionProps | UniformServerCompositionProps);
+declare const UniformComposition: React.FC<UniformCompositionProps>;
+type ResolveComponentFunction = (options: {
+    component: ComponentInstance;
+}) => ResolveComponentResult;
+type ResolveEmptyPlaceholderFunction = (options: ResolveEmptyPlaceholderOptions) => ResolveEmptyPlaceholderResult;
+type ResolveEmptyPlaceholderOptions = {
+    parentComponent: ComponentInstance | undefined;
+    component: ComponentInstance;
+    slotName: string;
+    slotIndex: number;
+};
+type ResolveComponentResult = {
+    component: ComponentType<ComponentProps<any, any>> | null;
+    includeContext?: boolean;
+    suspense?: {
+        fallback: ComponentType<any> | undefined;
+    };
+};
+type ResolveEmptyPlaceholderResult = {
+    component: ComponentType<ComponentProps<any, any>> | null;
+};
+declare const resolveComposition: (props: Omit<ResolveComponentsOptions, "slotName" | "slotIndex" | "target"> & {
+    composition: ComponentInstance;
+    compositionContext: CompositionContext;
+}) => React$1.FunctionComponentElement<{
+    children?: ReactNode | undefined;
+}> | 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;
+    resolveEmptyPlaceholder: ResolveEmptyPlaceholderFunction | undefined;
+    compositionContext: CompositionContext;
+    mode: UniformCompositionProps['mode'];
+};
+
+export { type ResolveComponentFunction as R, type UniformCompositionProps as U, type ResolveComponentResult as a, UniformComposition as b, resolveComposition as r };

package/dist/UniformComposition-IWWzoI_H.d.ts

@@ -0,0 +1,82 @@
+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;
+    /**
+     * Function to map empty placeholders to React components.
+     */
+    resolveEmptyPlaceholder?: ResolveEmptyPlaceholderFunction;
+} & (UniformStaticCompositionProps | UniformServerCompositionProps);
+declare const UniformComposition: React.FC<UniformCompositionProps>;
+type ResolveComponentFunction = (options: {
+    component: ComponentInstance;
+}) => ResolveComponentResult;
+type ResolveEmptyPlaceholderFunction = (options: ResolveEmptyPlaceholderOptions) => ResolveEmptyPlaceholderResult;
+type ResolveEmptyPlaceholderOptions = {
+    parentComponent: ComponentInstance | undefined;
+    component: ComponentInstance;
+    slotName: string;
+    slotIndex: number;
+};
+type ResolveComponentResult = {
+    component: ComponentType<ComponentProps<any, any>> | null;
+    includeContext?: boolean;
+    suspense?: {
+        fallback: ComponentType<any> | undefined;
+    };
+};
+type ResolveEmptyPlaceholderResult = {
+    component: ComponentType<ComponentProps<any, any>> | null;
+};
+declare const resolveComposition: (props: Omit<ResolveComponentsOptions, "slotName" | "slotIndex" | "target"> & {
+    composition: ComponentInstance;
+    compositionContext: CompositionContext;
+}) => React$1.FunctionComponentElement<{
+    children?: ReactNode | undefined;
+}> | 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;
+    resolveEmptyPlaceholder: ResolveEmptyPlaceholderFunction | undefined;
+    compositionContext: CompositionContext;
+    mode: UniformCompositionProps['mode'];
+};
+
+export { type ResolveComponentFunction as R, type UniformCompositionProps as U, type ResolveComponentResult as a, UniformComposition as b, resolveComposition as r };

package/dist/UniformComposition-d178d865.d.ts

@@ -0,0 +1,77 @@
+import { ComponentInstance, ResolvedRouteGetResponse } from '@uniformdev/canvas';
+import {
+  AppDirectoryServerContext,
+  ComponentProps,
+  CompositionContext,
+  PageParameters,
+} from '@uniformdev/canvas-next-rsc-shared';
+import * as React$1 from 'react';
+import { ComponentType, ReactNode } from 'react';
+
+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 {
+  UniformComposition as a,
+  ResolveComponentResult as b,
+  ResolveComponentFunction as R,
+  resolveComposition as r,
+  UniformCompositionProps as U,
+};

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,53 @@
+import { CanvasClient } from '@uniformdev/canvas';
+import { isDevelopmentEnvironment } from '../utils/draft';
+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 || isDevelopmentEnvironment()) {
+                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,209 @@
+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,33 @@
+import { ManifestClient } from '@uniformdev/context/api';
+import { getManifestRevalidateInterval } from '../config/helpers';
+import { isDevelopmentEnvironment } from '../utils/draft';
+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 || isDevelopmentEnvironment()) {
+                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,68 @@
+import { CANVAS_EDITOR_STATE, RouteClient } from '@uniformdev/canvas';
+import { isDevelopmentEnvironment } from '../utils/draft';
+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 = [];
+            let state;
+            if (requestedUrl) {
+                // this is here so this code breaks if parameters change here
+                const pathKey = 'path';
+                const stateKey = 'state';
+                const path = requestedUrl.searchParams.get(pathKey);
+                state = parseInt(requestedUrl.searchParams.get(stateKey) || '', 10);
+                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 || isDevelopmentEnvironment()) {
+                noCache = true;
+                revalidate = undefined;
+            }
+            const extraHeaders = {};
+            if (state === CANVAS_EDITOR_STATE) {
+                extraHeaders['x-bypass-cache'] = 'true';
+            }
+            return fetch(req, {
+                ...init,
+                cache: noCache ? 'no-cache' : 'force-cache',
+                next: {
+                    revalidate,
+                    tags: tags.length ? tags : undefined,
+                },
+                headers: {
+                    ...((init === null || init === void 0 ? void 0 : init.headers) || {}),
+                    ...extraHeaders,
+                },
+            });
+        },
+    });
+    return client;
+};

package/dist/components/DefaultNotImplementedComponent.d.ts

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