@uniformdev/canvas-next-rsc 19.173.1-alpha.17 → 19.173.2-alpha.210

package/dist/components/nodes/ParagraphRichTextNode.d.ts

@@ -0,0 +1,2 @@
+import { RichTextRendererComponent } from '../types';
+export declare const ParagraphRichTextNode: RichTextRendererComponent;

package/dist/components/nodes/ParagraphRichTextNode.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { isPureDirection, isPureTextAlign } from '@uniformdev/richtext';
+export const ParagraphRichTextNode = ({ children, node }) => {
+    const { format, direction } = node;
+    return (_jsx("p", { dir: isPureDirection(direction) ? direction : undefined, style: isPureTextAlign(format) ? { textAlign: format } : undefined, children: children }));
+};

package/dist/components/nodes/TabRichTextNode.d.ts

@@ -0,0 +1,2 @@
+import { RichTextRendererComponent } from '../types';
+export declare const TabRichTextNode: RichTextRendererComponent;

package/dist/components/nodes/TabRichTextNode.js

@@ -0,0 +1,4 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+export const TabRichTextNode = () => {
+    return _jsx(_Fragment, { children: '\t' });
+};

package/dist/components/nodes/TextRichTextNode.d.ts

@@ -0,0 +1,2 @@
+import { RichTextRendererComponent } from '../types';
+export declare const TextRichTextNode: RichTextRendererComponent;

package/dist/components/nodes/TextRichTextNode.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { getRichTextTagsFromTextFormat } from '@uniformdev/richtext';
+export const TextRichTextNode = ({ node }) => {
+    const { text, format } = node;
+    const tags = getRichTextTagsFromTextFormat(format);
+    return (_jsx(_Fragment, { children: tags.length > 0
+            ? tags.reduceRight((children, Tag) => _jsx(Tag, { children: children }), text)
+            : text }));
+};

package/dist/components/renderComponent.d.ts

@@ -0,0 +1,26 @@
+import { ComponentInstance } from '@uniformdev/canvas';
+import { SystemRenderConfig, UniformSlotProps } from '@uniformdev/canvas-react';
+import { Key } from 'react';
+
+import { CompositionContext } from './UniformComponent';
+export declare function renderComponent({
+  component,
+  context,
+  resolveSystem,
+  key,
+  indexInSlot,
+  slotName,
+  parentComponent,
+  slotChildrenCount,
+  emptyPlaceholder,
+}: {
+  component: ComponentInstance;
+  context: CompositionContext;
+  resolveSystem: SystemRenderConfig;
+  key?: Key;
+  indexInSlot?: number;
+  slotName?: string;
+  parentComponent?: ComponentInstance;
+  slotChildrenCount?: number;
+  emptyPlaceholder?: UniformSlotProps<any>['emptyPlaceholder'];
+}): JSX.Element | null;

package/dist/components/renderComponent.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { CANVAS_LOCALE_TAG_PARAM, CANVAS_PERSONALIZE_SLOT, CANVAS_PERSONALIZE_TYPE, CANVAS_TEST_SLOT, CANVAS_TEST_TYPE, IN_CONTEXT_EDITOR_COMPONENT_START_ROLE, isComponentPlaceholderId, } from '@uniformdev/canvas';
+import { componentStoreResolver } from '../register/componentStoreResolver';
+import { isIncontextEditingEnabled } from '../utils/draft';
+import { convertComponentToProps } from './convertComponentToProps';
+import { UniformComponent } from './UniformComponent';
+export function renderComponent({ component, context, resolveSystem, key = 0, indexInSlot, slotName, parentComponent, slotChildrenCount, emptyPlaceholder, }) {
+    var _a, _b, _c, _d;
+    const RenderComponent = componentStoreResolver(component);
+    // custom handling for tests and personalizes
+    if (component.type === CANVAS_TEST_TYPE) {
+        return resolveSystem.test(component, key, (variantComponent, key) => {
+            var _a, _b;
+            return renderComponent({
+                component: variantComponent,
+                context,
+                resolveSystem,
+                key,
+                parentComponent: component,
+                slotName: CANVAS_TEST_SLOT,
+                slotChildrenCount: (_a = component === null || component === void 0 ? void 0 : component.slots) === null || _a === void 0 ? void 0 : _a[CANVAS_TEST_SLOT].length,
+                indexInSlot: (_b = component === null || component === void 0 ? void 0 : component.slots) === null || _b === void 0 ? void 0 : _b[CANVAS_TEST_SLOT].findIndex(({ _id }) => variantComponent._id === _id),
+            });
+        });
+    }
+    else if (component.type === CANVAS_PERSONALIZE_TYPE) {
+        return resolveSystem.personalization(component, key, (variantComponent, key) => {
+            var _a, _b;
+            return renderComponent({
+                component: variantComponent,
+                context,
+                resolveSystem,
+                key,
+                parentComponent: component,
+                slotName: CANVAS_PERSONALIZE_SLOT,
+                slotChildrenCount: (_a = component === null || component === void 0 ? void 0 : component.slots) === null || _a === void 0 ? void 0 : _a[CANVAS_PERSONALIZE_SLOT].length,
+                indexInSlot: (_b = component === null || component === void 0 ? void 0 : component.slots) === null || _b === void 0 ? void 0 : _b[CANVAS_PERSONALIZE_SLOT].findIndex(({ _id }) => variantComponent._id === _id),
+            });
+        });
+    }
+    else if (RenderComponent) {
+        const props = convertComponentToProps({
+            component,
+            context,
+        });
+        const shouldRenderContextualEditingTags = Boolean(component._id) && isIncontextEditingEnabled(context);
+        const isPlaceholder = isComponentPlaceholderId(component._id);
+        const isReadOnly = false;
+        return (_jsx(UniformComponent, { data: component, context: context, children: _jsxs(_Fragment, { children: [!shouldRenderContextualEditingTags ? null : (_jsx("script", { "data-role": IN_CONTEXT_EDITOR_COMPONENT_START_ROLE, "data-parent-id": parentComponent === null || parentComponent === void 0 ? void 0 : parentComponent._id, "data-parent-type": parentComponent === null || parentComponent === void 0 ? void 0 : parentComponent.type, "data-component-id": component._id, "data-slot-name": slotName !== null && slotName !== void 0 ? slotName : '', "data-component-index": indexInSlot !== null && indexInSlot !== void 0 ? indexInSlot : '', "data-total-components": slotChildrenCount !== null && slotChildrenCount !== void 0 ? slotChildrenCount : '', "data-component-name": component.type, "data-is-placeholder": isPlaceholder ? 'true' : undefined, "data-is-localized": ((_a = component.parameters) === null || _a === void 0 ? void 0 : _a[CANVAS_LOCALE_TAG_PARAM]) ? 'true' : undefined, "data-component-title": (_d = (_c = (_b = component.parameters) === null || _b === void 0 ? void 0 : _b.title) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : '', "data-is-readonly": isReadOnly }, key)), isPlaceholder && emptyPlaceholder !== undefined ? (emptyPlaceholder) : (_jsx(RenderComponent, { ...props })), !shouldRenderContextualEditingTags ? null : _jsx("script", { "data-role": "component-end" })] }) }, key));
+    }
+    return null;
+}

package/dist/components/resolvePath.d.ts

@@ -0,0 +1,5 @@
+export declare const resolvePath: (options: {
+  params: {
+    slug: string | string[];
+  };
+}) => string;

package/dist/components/resolvePath.js

@@ -0,0 +1,34 @@
+const resolveSlugFromString = (originalSlug) => {
+    if (!originalSlug) {
+        return [''];
+    }
+    const slug = decodeURIComponent(originalSlug);
+    if (slug.includes('/')) {
+        return slug.split('/');
+    }
+    return [slug || ''];
+};
+const resolveSlugFromArray = (slug) => {
+    const slugPieces = [];
+    for (let i = 0; i < slug.length; i++) {
+        const decoded = decodeURIComponent(slug[i]);
+        if (decoded.includes('/')) {
+            slugPieces.push(...decoded.split('/'));
+        }
+        else {
+            slugPieces.push(decoded);
+        }
+    }
+    return slugPieces;
+};
+export const resolvePath = (options) => {
+    const { params: { slug }, } = options;
+    const definedSlug = !Array.isArray(slug)
+        ? resolveSlugFromString(slug)
+        : resolveSlugFromArray(slug);
+    let joined = `/${Array.isArray(definedSlug) ? definedSlug.join('/') : definedSlug}`;
+    if (joined === '/index') {
+        joined = '/';
+    }
+    return joined;
+};

package/dist/components/retrieveRoute.d.ts

@@ -0,0 +1,198 @@
+import { ResolvedRouteGetResponse, RouteGetResponseRedirect } from '@uniformdev/canvas';
+
+import { UniformCompositionProps } from './UniformComposition';
+export type ResolveRouteOptions = {
+  path: string;
+  state?: number;
+  searchParams:
+    | {
+        [key: string]: string | undefined;
+      }
+    | undefined;
+};
+export declare const resolveComposition: ({
+  searchParams,
+  params,
+  update,
+}: Pick<UniformCompositionProps, 'searchParams' | 'params' | 'update'>) => Promise<{
+  type: 'composition';
+  matchedRoute: string;
+  dynamicInputs?:
+    | {
+        [key: string]: string;
+      }
+    | undefined;
+  composition: {
+    type: string;
+    parameters?:
+      | {
+          [key: string]: {
+            value: unknown;
+            type: string;
+            connectedData?:
+              | {
+                  pointer: string;
+                  syntax: 'jptr';
+                }
+              | undefined;
+          };
+        }
+      | undefined;
+    variant?: string | undefined;
+    projectMapNodes?:
+      | {
+          id: string;
+          path: string;
+          projectMapId: string;
+        }[]
+      | undefined;
+    slots?:
+      | {
+          [key: string]: {
+            type: string;
+            parameters?:
+              | {
+                  [key: string]: {
+                    value: unknown;
+                    type: string;
+                    connectedData?:
+                      | {
+                          pointer: string;
+                          syntax: 'jptr';
+                        }
+                      | undefined;
+                  };
+                }
+              | undefined;
+            variant?: string | undefined;
+            slots?:
+              | {
+                  [key: string]: any[];
+                }
+              | undefined;
+            _id?: string | undefined;
+            _pattern?: string | undefined;
+            _dataResources?:
+              | {
+                  [key: string]: {
+                    type: string;
+                    isPatternParameter?: boolean | undefined;
+                    ignorePatternParameterDefault?: boolean | undefined;
+                    variables?:
+                      | {
+                          [key: string]: string;
+                        }
+                      | undefined;
+                  };
+                }
+              | undefined;
+            _patternDataResources?:
+              | {
+                  [key: string]: {
+                    type: string;
+                    isPatternParameter?: boolean | undefined;
+                    ignorePatternParameterDefault?: boolean | undefined;
+                    variables?:
+                      | {
+                          [key: string]: string;
+                        }
+                      | undefined;
+                  };
+                }
+              | undefined;
+            _patternError?: 'NOTFOUND' | 'CYCLIC' | undefined;
+            _overrides?:
+              | {
+                  [key: string]: {
+                    parameters?:
+                      | {
+                          [key: string]: {
+                            value: unknown;
+                            type: string;
+                            connectedData?:
+                              | {
+                                  pointer: string;
+                                  syntax: 'jptr';
+                                }
+                              | undefined;
+                          };
+                        }
+                      | undefined;
+                    variant?: string | undefined;
+                  };
+                }
+              | undefined;
+            _overridability?:
+              | {
+                  parameters?:
+                    | {
+                        [key: string]: 'yes' | 'no';
+                      }
+                    | undefined;
+                  variants?: boolean | undefined;
+                }
+              | undefined;
+          }[];
+        }
+      | undefined;
+    _id: string;
+    _slug?: string | null | undefined;
+    _name: string;
+    _dataResources?:
+      | {
+          [key: string]: {
+            type: string;
+            isPatternParameter?: boolean | undefined;
+            ignorePatternParameterDefault?: boolean | undefined;
+            variables?:
+              | {
+                  [key: string]: string;
+                }
+              | undefined;
+          };
+        }
+      | undefined;
+    _overrides?:
+      | {
+          [key: string]: {
+            parameters?:
+              | {
+                  [key: string]: {
+                    value: unknown;
+                    type: string;
+                    connectedData?:
+                      | {
+                          pointer: string;
+                          syntax: 'jptr';
+                        }
+                      | undefined;
+                  };
+                }
+              | undefined;
+            variant?: string | undefined;
+          };
+        }
+      | undefined;
+    _overridability?:
+      | {
+          parameters?:
+            | {
+                [key: string]: 'yes' | 'no';
+              }
+            | undefined;
+          variants?: boolean | undefined;
+        }
+      | undefined;
+  };
+  cookieValue: string | undefined;
+  path: string;
+  searchParams:
+    | {
+        [key: string]: string | undefined;
+      }
+    | undefined;
+  isCanvasEditing: boolean;
+  seenComponents: import('../models').SeenUniformComponent[];
+}>;
+export declare const retrieveRoute: (data: ResolveRouteOptions) => Promise<ResolvedRouteGetResponse>;
+export declare const resolveRedirectHref: (resolveResult: RouteGetResponseRedirect, path: string) => string;

package/dist/components/retrieveRoute.js

@@ -0,0 +1,146 @@
+import { CANVAS_DRAFT_STATE, CANVAS_EDITOR_STATE, CANVAS_PUBLISHED_STATE, } from '@uniformdev/canvas';
+import { RedirectClient } from '@uniformdev/redirect';
+import { get } from '@vercel/edge-config';
+import { cookies, headers } from 'next/headers';
+import { notFound, redirect } from 'next/navigation';
+import { getManifestFromApi } from '../client/manifestClient';
+import { getRouteClient } from '../client/routeClient';
+import { getRouteRevalidateInterval, getServerConfig } from '../config/helpers';
+import { isDevelopmentEnvironment, isDraftModeEnabled, isIncontextEditingEnabled, isOnVercelPreviewEnvironment, } from '../utils/draft';
+import { buildPathTag } from '../utils/tag';
+import { getBaseUrl } from '../utils/url';
+import { evaluateComposition } from './evaluateComposition';
+import { resolvePath } from './resolvePath';
+export const resolveComposition = async ({ searchParams, params, update, }) => {
+    // prefetch manifest immediately
+    void getManifestFromApi({
+        searchParams,
+    });
+    const draftMode = isDraftModeEnabled({ searchParams });
+    const previewEnvironment = isOnVercelPreviewEnvironment();
+    const isDevelopment = isDevelopmentEnvironment();
+    const isCanvasEditing = isIncontextEditingEnabled({
+        searchParams,
+    });
+    // resolve the path from provided params
+    const path = resolvePath({
+        params,
+    });
+    let state;
+    if (isCanvasEditing) {
+        state = CANVAS_EDITOR_STATE;
+    }
+    else {
+        state = draftMode || previewEnvironment || isDevelopment ? CANVAS_DRAFT_STATE : CANVAS_PUBLISHED_STATE;
+    }
+    // resolve the route from the path
+    const resolveResult = await retrieveRoute({
+        path,
+        state,
+        searchParams,
+    });
+    // if the route is a redirect, redirect
+    if (resolveResult.type === 'redirect') {
+        const href = resolveRedirectHref(resolveResult, path);
+        redirect(href);
+    }
+    // if the route is not found, return 404
+    if (resolveResult.type === 'notFound') {
+        notFound();
+    }
+    const { compositionApiResponse, ...rest } = resolveResult;
+    // evaluate the composition
+    const { cookieValue, composition: evaluatedComposition, seenComponents, } = await evaluateComposition({
+        root: compositionApiResponse.composition,
+        params,
+        searchParams: searchParams !== null && searchParams !== void 0 ? searchParams : {},
+        dynamicInputs: rest.dynamicInputs,
+        headers: headers(),
+        cookies: cookies()
+            .getAll()
+            .reduce((acc, cookie) => {
+            acc[cookie.name] = cookie.value;
+            return acc;
+        }, {}),
+        update,
+    });
+    return {
+        composition: evaluatedComposition,
+        cookieValue,
+        path,
+        searchParams,
+        isCanvasEditing,
+        seenComponents,
+        ...rest,
+    };
+};
+export const retrieveRoute = async (data) => {
+    void resolveRouteByEdgeConfig(data);
+    void resolveRouteByRouteApi(data);
+    const edgeConfigValue = await resolveRouteByEdgeConfig(data);
+    let result;
+    if (edgeConfigValue) {
+        result = edgeConfigValue;
+    }
+    else {
+        const routeApiValue = await resolveRouteByRouteApi(data);
+        result = routeApiValue;
+    }
+    // fall back to draft if requesting editor state
+    if (result.type === 'notFound' && data.state === CANVAS_EDITOR_STATE) {
+        return retrieveRoute({
+            ...data,
+            state: CANVAS_DRAFT_STATE,
+        });
+    }
+    return result;
+};
+export const resolveRedirectHref = (resolveResult, path) => {
+    let href;
+    if (resolveResult.redirect.targetProjectMapNodeId) {
+        const requestUrl = `${getBaseUrl()}${path}`;
+        const expandedUrl = RedirectClient.getTargetVariableExpandedUrl(requestUrl, resolveResult.redirect);
+        const url = new URL(expandedUrl);
+        href = url.pathname;
+    }
+    else {
+        href = resolveResult.redirect.targetUrl;
+    }
+    return href;
+};
+const resolveRouteByEdgeConfig = async (data) => {
+    var _a;
+    const config = getServerConfig();
+    if (!((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeRedirects) || !process.env.EDGE_CONFIG) {
+        return undefined;
+    }
+    const sourcePathKey = buildPathTag(data.path);
+    const key = sourcePathKey.replace(/\W+/g, '');
+    let edgeConfig;
+    try {
+        edgeConfig = await get(key);
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.warn('Failed to retrieve edge config', e);
+    }
+    if (!edgeConfig) {
+        return undefined;
+    }
+    return edgeConfig;
+};
+const resolveRouteByRouteApi = async (data) => {
+    var _a;
+    const routeClient = getRouteClient({
+        revalidate: getRouteRevalidateInterval({
+            searchParams: data.searchParams,
+        }),
+    });
+    const routeResult = await routeClient.getRoute({
+        path: data.path,
+        state: data.state,
+        withComponentIDs: data.state === CANVAS_DRAFT_STATE || data.state === CANVAS_EDITOR_STATE,
+        withContentSourceMap: isOnVercelPreviewEnvironment() && ((_a = getServerConfig().experimental) === null || _a === void 0 ? void 0 : _a.vercelVisualEditing),
+    });
+    return routeResult;
+};

package/dist/components/types.d.ts

@@ -0,0 +1,15 @@
+import { RichTextNode } from '@uniformdev/richtext';
+import React, { PropsWithChildren } from 'react';
+export type RichTextComponentProps<TNode extends RichTextNode = RichTextNode> = {
+  node: TNode;
+};
+export type RichTextRendererComponent<TNode extends RichTextNode = RichTextNode> = React.ComponentType<
+  PropsWithChildren<RichTextComponentProps<TNode>>
+>;
+/**
+ * Function that maps a Rich Text node instance to its React component to render it.
+ * The resolver would commonly inspect the `type` of the component to decide.
+ */
+export type RenderRichTextComponentResolver = (
+  node: RichTextNode
+) => RichTextRendererComponent | null | undefined;

package/dist/components/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config/helpers.d.ts

@@ -0,0 +1,23 @@
+import { UniformServerConfig } from './models';
+export declare const getCanvasRevalidateInterval: (options: {
+  searchParams:
+    | {
+        [key: string]: string | undefined;
+      }
+    | undefined;
+}) => number | undefined;
+export declare const getManifestRevalidateInterval: (options: {
+  searchParams:
+    | {
+        [key: string]: string | undefined;
+      }
+    | undefined;
+}) => number | undefined;
+export declare const getRouteRevalidateInterval: (options: {
+  searchParams:
+    | {
+        [key: string]: string | undefined;
+      }
+    | undefined;
+}) => number | undefined;
+export declare const getServerConfig: () => UniformServerConfig;

package/dist/config/helpers.js

@@ -0,0 +1,34 @@
+import { isDraftModeEnabled, isOnVercelPreviewEnvironment } from '../utils/draft';
+export const getCanvasRevalidateInterval = (options) => {
+    if (isDraftModeEnabled({ searchParams: options.searchParams }) || isOnVercelPreviewEnvironment()) {
+        return -1;
+    }
+    const config = getServerConfig();
+    return 'canvasRevalidateInterval' in config ? config.canvasRevalidateInterval : undefined;
+};
+export const getManifestRevalidateInterval = (options) => {
+    if (isDraftModeEnabled({ searchParams: options.searchParams }) || isOnVercelPreviewEnvironment()) {
+        return -1;
+    }
+    const config = getServerConfig();
+    return 'manifestRevalidateInterval' in config ? config.manifestRevalidateInterval : undefined;
+};
+export const getRouteRevalidateInterval = (options) => {
+    if (isDraftModeEnabled({ searchParams: options.searchParams }) || isOnVercelPreviewEnvironment()) {
+        return -1;
+    }
+    const config = getServerConfig();
+    return 'routeRevalidateInterval' in config ? config.routeRevalidateInterval : undefined;
+};
+export const getServerConfig = () => {
+    let serverConfig;
+    try {
+        serverConfig = require('uniform.server.config.js');
+    }
+    catch (e) {
+        serverConfig = {
+            defaultConsent: false,
+        };
+    }
+    return serverConfig;
+};

package/dist/config/models.d.ts

@@ -0,0 +1,51 @@
+export type UniformServerConfig = {
+  /**
+   * Sets the default value of storage consent for new unknown visitors.
+   *
+   * @default false
+   */
+  defaultConsent?: boolean;
+  /**
+   * Interval to revalidate the manifest at.
+   *
+   * @default 60
+   */
+  manifestRevalidateInterval?: number;
+  /**
+   * Interval to revalidate route data at.
+   *
+   * @default 10
+   */
+  routeRevalidateInterval?: number;
+  /**
+   * Interval to revalidate canvas data at.
+   *
+   * @default 10
+   */
+  canvasRevalidateInterval?: number;
+  /**
+   * 😅
+   */
+  experimental?: {
+    /**
+     * Enables edge cache of redirects.
+     *
+     * @default false
+     */
+    edgeRedirects?: boolean;
+    /**
+     * Enables edge cache of compositions.
+     *
+     * @default false
+     */
+    edgeCompositions?: boolean;
+    /**
+     * Dynamic tokens names that should be used for localization.
+     */
+    localeDynamicInputs?: string[];
+    /**
+     * Enables visual editing mode.
+     */
+    vercelVisualEditing?: boolean;
+  };
+};

package/dist/config/models.js

@@ -0,0 +1 @@
+export {};

package/dist/config/uniform.server.config.d.ts

@@ -0,0 +1,3 @@
+import { UniformServerConfig } from './models';
+declare const config: UniformServerConfig;
+export default config;

package/dist/config/uniform.server.config.js

@@ -0,0 +1,4 @@
+/** @type {import('@uniformdev/canvas-next-rsc/config').UniformServerConfig} */
+module.exports = {
+  defaultConsent: true,
+};

package/dist/cookie/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Sets the Uniform cookie with the provided value.
+ */
+export declare const setUniformCookie: (value: string) => void;
+/**
+ * Determine if the Uniform cookie is present.
+ */
+export declare const hasUniformCookie: () => boolean;
+/**
+ * Gets the Uniform cookie value.
+ */
+export declare const removeUniformCookie: () => void;