@uniformdev/canvas-next-rsc 19.49.0 → 19.49.4-alpha.67

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/routeClient.js

@@ -1,4 +1,4 @@
-import { RouteClient } from '@uniformdev/canvas';
+import { CANVAS_EDITOR_STATE, RouteClient } from '@uniformdev/canvas';
 import { isDevelopmentEnvironment } from '../utils/draft';
 import { buildPathTag } from '../utils/tag';
 export const getRouteClient = (options) => {
@@ -18,10 +18,13 @@ export const getRouteClient = (options) => {
                 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:
@@ -43,6 +46,10 @@ export const getRouteClient = (options) => {
                 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',
@@ -50,6 +57,10 @@ export const getRouteClient = (options) => {
                     revalidate,
                     tags: tags.length ? tags : undefined,
                 },
+                headers: {
+                    ...((init === null || init === void 0 ? void 0 : init.headers) || {}),
+                    ...extraHeaders,
+                },
             });
         },
     });

package/dist/components/DefaultNotImplementedComponent.d.ts

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

package/dist/components/GoogleTagManagerAnalytics.d.ts

@@ -1,3 +1,3 @@
 export declare const GoogleTagManagerAnalytics: (props?: {
     measurementId?: string;
-}) => JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/UniformComponent.d.ts

@@ -7,6 +7,9 @@ export type CompositionContext = Omit<RouteGetResponseComposition, 'compositionA
     searchParams: {
         [key: string]: string | undefined;
     } | undefined;
+    cookieValue: string | undefined;
+    isDraftMode: boolean;
+    isContextualEditing: boolean;
 };
 export type ComponentProps<TProps = unknown> = TProps & {
     component: ComponentInstance;

package/dist/components/UniformComposition.d.ts

@@ -1,3 +1,4 @@
+import { ContextState } from '@uniformdev/context';
 import { ReactNode } from 'react';
 export type SuspenseOptions = {
     mode: 'off';
@@ -25,11 +26,15 @@ export type UniformCompositionProps = {
         mode: 'off';
     } | {
         mode: 'fallback';
-        fallback: React.ReactNode;
+        fallback: ReactNode;
     };
+    /**
+     * Update state that should be added to the call to update before composition evaluation
+     */
+    update?: Partial<ContextState>;
     /**
      * The children of the UniformComposition component.
      */
     children?: ReactNode;
 };
-export declare const UniformComposition: ({ suspense, ...props }: UniformCompositionProps) => JSX.Element;
+export declare const UniformComposition: ({ suspense, ...props }: UniformCompositionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/UniformComposition.js

@@ -1,13 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { CANVAS_DRAFT_STATE, CANVAS_EDITOR_STATE, CANVAS_PUBLISHED_STATE } from '@uniformdev/canvas';
-import { cookies, headers } from 'next/headers';
-import { notFound, redirect } from 'next/navigation';
 import { Suspense } from 'react';
-import { getManifestFromApi } from '../client/manifestClient';
-import { isDevelopmentEnvironment, isDraftModeEnabled, isIncontextEditingEnabled, isOnVercelPreviewEnvironment, } from '../utils/draft';
-import { evaluateComposition } from './evaluateComposition';
-import { resolvePath } from './resolvePath';
-import { resolveRedirectHref, retrieveRoute } from './retrieveRoute';
+import { isDraftModeEnabled, isIncontextEditingEnabled } from '../utils/draft';
+import { resolveComposition } from './retrieveRoute';
 import { UniformComponent } from './UniformComponent';
 import { UniformProvider } from './UniformContext';
 import { UniformScript } from './UniformScript';
@@ -20,67 +14,21 @@ const ConditionalWrapper = ({ children, options }) => {
     }
     return _jsx(Suspense, { fallback: options.fallback, children: children });
 };
-const UniformCompositionInner = async ({ params, searchParams, children }) => {
-    // 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({
+const UniformCompositionInner = async ({ params, searchParams, update, children, }) => {
+    const { composition: evaluatedComposition, cookieValue, path, searchParams: evaluatedSearchParams, seenComponents, isCanvasEditing, ...rest } = await resolveComposition({
         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;
-    // retrieve the manifest
-    const manifest = await getManifestFromApi({
-        searchParams,
-    });
-    // evaluate the composition
-    const { cookieValue, composition: evaluatedComposition, seenComponents, } = await evaluateComposition({
-        root: compositionApiResponse.composition,
-        params,
-        searchParams: searchParams !== null && searchParams !== void 0 ? searchParams : {},
-        dynamicInputs: rest.dynamicInputs,
-        manifest,
-        headers: headers(),
-        cookies: cookies()
-            .getAll()
-            .reduce((acc, cookie) => {
-            acc[cookie.name] = cookie.value;
-            return acc;
-        }, {}),
+        update,
     });
     const context = {
         composition: evaluatedComposition,
         path,
         searchParams,
+        cookieValue,
+        isDraftMode: isDraftModeEnabled({ searchParams }),
+        isContextualEditing: isIncontextEditingEnabled({
+            searchParams,
+        }),
         ...rest,
     };
     return (_jsxs(UniformProvider, { cookieValue: cookieValue, seenComponents: seenComponents, children: [_jsx(UniformScript, { enabled: isCanvasEditing }), _jsx(UniformComponent, { data: evaluatedComposition, context: context }), Boolean(children) && children] }));

package/dist/components/UniformContext.d.ts

@@ -5,7 +5,4 @@ export type UniformContextProps = {
     seenComponents: SeenUniformComponent[] | undefined;
 };
 export declare const UniformContext: import("react").Context<UniformContextProps>;
-export declare const UniformProvider: ({ children, cookieValue, seenComponents, }: PropsWithChildren<{
-    cookieValue: string | undefined;
-    seenComponents: SeenUniformComponent[] | undefined;
-}>) => JSX.Element;
+export declare const UniformProvider: ({ children, cookieValue, seenComponents, }: PropsWithChildren<UniformContextProps>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/UniformRichTextNode.d.ts

@@ -7,4 +7,4 @@ export type UniformRichTextNodeProps = {
 /**
  * Render a single RichText node
  */
-export declare function UniformRichTextNode({ node, ...props }: UniformRichTextNodeProps): JSX.Element | null;
+export declare function UniformRichTextNode({ node, ...props }: UniformRichTextNodeProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/UniformScript.d.ts

@@ -1,3 +1,3 @@
 export declare const UniformScript: ({ enabled }: {
     enabled: boolean;
-}) => JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/UniformText.d.ts

@@ -1,14 +1,6 @@
-/// <reference types="react" />
-import { ComponentInstance } from '@uniformdev/canvas';
+import { type PureUniformTextProps } from '@uniformdev/canvas-react/core';
+import { CompositionContext } from './UniformComponent';
 export type UniformTextProps = {
-    /**
-     * The name of the  HTML tag to render.
-     * @default "span"
-     */
-    as?: React.ElementType;
-    /** The ID of the parameter. */
-    parameterId: string;
-    /** The component instance. */
-    component: ComponentInstance;
-} & Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'>;
-export declare const UniformText: ({ as: Tag, parameterId, component, ...rest }: UniformTextProps) => JSX.Element | null;
+    context: CompositionContext;
+} & Omit<PureUniformTextProps, 'skipCustomRendering' | 'isContextualEditing'>;
+export declare const UniformText: ({ context, ...rest }: UniformTextProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/UniformText.js

@@ -1,9 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-export const UniformText = ({ as: Tag = 'span', parameterId, component, ...rest }) => {
-    var _a;
-    const parameter = (_a = component === null || component === void 0 ? void 0 : component.parameters) === null || _a === void 0 ? void 0 : _a[parameterId];
-    if (!parameter) {
-        return null;
-    }
-    return _jsx(Tag, { ...rest, children: parameter.value });
+import { PureUniformText } from '@uniformdev/canvas-react/core';
+export const UniformText = ({ context, ...rest }) => {
+    return (_jsx(PureUniformText, { ...rest, isContextualEditing: context.isContextualEditing, skipCustomRendering: context.isContextualEditing }));
 };

package/dist/components/__tests__/evaluateComposition.spec.js

@@ -1,7 +1,17 @@
 import { CANVAS_LOCALE_TAG_PARAM, CANVAS_LOCALIZATION_SLOT, CANVAS_LOCALIZATION_TYPE, } from '@uniformdev/canvas';
+import { Context } from '@uniformdev/context';
 import { evaluateComposition } from '../evaluateComposition';
+jest.mock('../getUniformContext', () => ({
+    getUniformContext: () => {
+        return new Context({
+            manifest: {
+                project: {},
+            },
+        });
+    },
+}));
 describe('evaluateComposition', () => {
-    it('should localize a compoisition when dynmaic inputs include locale token', async () => {
+    it('should localize a composition when dynmaic inputs include locale token', async () => {
         var _a, _b;
         const root = {
             _id: 'root',
@@ -61,9 +71,7 @@ describe('evaluateComposition', () => {
                     localeDynamicInputs: ['lang'],
                 },
             },
-            manifest: {
-                project: {},
-            },
+            update: undefined,
         });
         const localizedHero = (_a = root.slots) === null || _a === void 0 ? void 0 : _a['content'][0];
         expect(localizedHero).toBeDefined();

package/dist/components/evaluateComposition.d.ts

@@ -1,8 +1,8 @@
 import { RootComponentInstance, RouteGetResponseComposition } from '@uniformdev/canvas';
-import { ManifestV2 } from '@uniformdev/context';
+import { ContextState } from '@uniformdev/context';
 import { UniformServerConfig } from '../config';
 import { SeenUniformComponent } from '../models';
-export declare const evaluateComposition: ({ root, params, searchParams, dynamicInputs, manifest, headers, cookies, config, }: {
+export declare const evaluateComposition: ({ root, params, searchParams, dynamicInputs, headers, cookies, update, config, }: {
     root: RootComponentInstance;
     params: {
         slug: string | string[];
@@ -11,9 +11,9 @@ export declare const evaluateComposition: ({ root, params, searchParams, dynamic
         [key: string]: string | undefined;
     };
     dynamicInputs: RouteGetResponseComposition['dynamicInputs'];
-    manifest: ManifestV2;
     headers: Headers;
     cookies: Record<string, string>;
+    update: Partial<ContextState> | undefined;
     config?: UniformServerConfig | undefined;
 }) => Promise<{
     composition: RootComponentInstance;

package/dist/components/evaluateComposition.js

@@ -1,23 +1,20 @@
-import { CANVAS_PERSONALIZATION_PARAM, CANVAS_PERSONALIZE_TYPE, CANVAS_TEST_TYPE, localize, mapSlotToPersonalizedVariations, mapSlotToTestVariations, walkComponentTree, } from '@uniformdev/canvas';
-import { Context, CookieTransitionDataStore, UNIFORM_DEFAULT_COOKIE_NAME, } from '@uniformdev/context';
-import serverConfig from '../config/uniform.server.config';
+import { CANVAS_PERSONALIZATION_PARAM, CANVAS_PERSONALIZE_TYPE, CANVAS_TEST_TYPE, localize, mapSlotToPersonalizedVariations, mapSlotToTestVariations, walkNodeTree, } from '@uniformdev/canvas';
+import { UNIFORM_DEFAULT_COOKIE_NAME } from '@uniformdev/context';
+import { getServerConfig } from '../config/helpers';
 import { serializeCookie } from '../score';
+import { isIncontextEditingEnabled } from '../utils/draft';
 import { getBaseUrl } from '../utils/url';
 import { getEnrichmentTags } from './getEnrichmentTags';
+import { getUniformContext } from './getUniformContext';
 import { resolvePath } from './resolvePath';
-export const evaluateComposition = async ({ root, params, searchParams, dynamicInputs, manifest, headers, cookies, config = serverConfig, }) => {
-    // retrieve the score from the cookie, if any
-    const score = cookies[UNIFORM_DEFAULT_COOKIE_NAME];
+export const evaluateComposition = async ({ root, params, searchParams, dynamicInputs, headers, cookies, update, config = getServerConfig(), }) => {
     // resolve the path from route params
     const path = resolvePath({
         params,
     });
-    // create a context
-    const context = new Context({
-        manifest,
-        transitionStore: new CookieTransitionDataStore({
-            serverCookieValue: score,
-        }),
+    const context = await getUniformContext({
+        searchParams,
+        cookieValue: cookies[UNIFORM_DEFAULT_COOKIE_NAME] || undefined,
     });
     // generate the current URL for the request
     const url = new URL(`${getBaseUrl()}${path}`);
@@ -27,15 +24,21 @@ export const evaluateComposition = async ({ root, params, searchParams, dynamicI
         }
     }
     const missingQuirkValue = 'unknown';
+    const { cookies: updateCookies, quirks: updateQuirks, ...restOfUpdate } = update || {};
     // update context to update scores
     await context.update({
-        cookies,
+        cookies: {
+            ...cookies,
+            ...(updateCookies || {}),
+        },
         url,
         quirks: {
             'vc-country': headers.get('x-vercel-ip-country') || missingQuirkValue,
             'vc-region': headers.get('x-vercel-ip-country-region') || missingQuirkValue,
             'vc-city': headers.get('x-vercel-ip-city') || missingQuirkValue,
+            ...(updateQuirks || {}),
         },
+        ...restOfUpdate,
     });
     const composition = root;
     const resolvedLocaleKey = Object.keys(dynamicInputs || {}).find((key) => {
@@ -53,8 +56,13 @@ export const evaluateComposition = async ({ root, params, searchParams, dynamicI
     }
     const enrichmentTags = [];
     const seenComponents = [];
-    walkComponentTree(composition, (component, _ancestors, actions) => {
+    walkNodeTree(composition, ({ type, node: component, actions }) => {
         var _a, _b, _c, _d, _e, _f;
+        if (type !== 'component') {
+            // we ignore blocks for now
+            actions.stopProcessingDescendants();
+            return;
+        }
         let replacementComponents;
         // evaluate personalization components
         if (component.type === CANVAS_PERSONALIZE_TYPE) {
@@ -116,12 +124,12 @@ export const evaluateComposition = async ({ root, params, searchParams, dynamicI
         if (typeof replacementComponents !== 'undefined') {
             // if no variants were selected, just remove the current component. no matches.
             if (replacementComponents.length === 0) {
-                actions.removeComponent();
+                actions.remove();
             }
             else {
                 const [first, ...rest] = replacementComponents;
                 // replace the first component
-                actions.replaceComponent(first);
+                actions.replace(first);
                 // if there are other components, insert them after the first
                 if (rest.length) {
                     actions.insertAfter(rest);
@@ -137,6 +145,29 @@ export const evaluateComposition = async ({ root, params, searchParams, dynamicI
             }
         }
     });
+    // when we post compositions to CANVAS_EDITOR_STATE, we have to remove all
+    // contextual editing objects that have been attached to parameters in order
+    // to pass API validation. walk the composition and add them back in, assume
+    // everything is editable.
+    if (isIncontextEditingEnabled({ searchParams })) {
+        walkNodeTree(composition, ({ node: component, actions, type }) => {
+            if (type !== 'component') {
+                actions.stopProcessingDescendants();
+                return;
+            }
+            if (component.parameters) {
+                const params = Object.keys(component.parameters);
+                params.forEach((key) => {
+                    const param = component.parameters[key];
+                    if (param.type === 'text' && typeof param._contextualEditing === 'undefined') {
+                        param._contextualEditing = {
+                            isEditable: true,
+                        };
+                    }
+                });
+            }
+        });
+    }
     // if we've seen any enrichment tags, update the context with them
     if (enrichmentTags.length) {
         await context.update({

package/dist/components/getUniformContext.d.ts

@@ -0,0 +1,6 @@
+import { Context } from '@uniformdev/context';
+import { UniformCompositionProps } from './UniformComposition';
+export declare const getUniformContext: ({ searchParams, cookieValue, }: {
+    searchParams?: UniformCompositionProps['searchParams'];
+    cookieValue: string | undefined;
+}) => Promise<Context>;

package/dist/components/getUniformContext.js

@@ -0,0 +1,17 @@
+import { Context, CookieTransitionDataStore } from '@uniformdev/context';
+import { getManifestFromApi } from '../client/manifestClient';
+import { getServerConfig } from '../config/helpers';
+export const getUniformContext = async ({ searchParams, cookieValue, }) => {
+    const manifest = await getManifestFromApi({
+        searchParams,
+    });
+    const config = getServerConfig();
+    const context = new Context({
+        manifest,
+        defaultConsent: config.defaultConsent,
+        transitionStore: new CookieTransitionDataStore({
+            serverCookieValue: cookieValue,
+        }),
+    });
+    return context;
+};

package/dist/components/renderComponent.js

@@ -1,10 +1,11 @@
 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, PLACEHOLDER_ID, } from '@uniformdev/canvas';
+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, _e;
+    var _a, _b, _c, _d;
     const RenderComponent = componentStoreResolver(component);
     // custom handling for tests and personalizes
     if (component.type === CANVAS_TEST_TYPE) {
@@ -42,12 +43,10 @@ export function renderComponent({ component, context, resolveSystem, key = 0, in
             component,
             context,
         });
-        const shouldRenderContextualEditingTags = Boolean(component._id);
-        const isPlaceholder = component._id === PLACEHOLDER_ID;
-        const isReadOnly = ((_a = component === null || component === void 0 ? void 0 : component._contextualEditing) === null || _a === void 0 ? void 0 : _a.isEditable)
-            ? undefined
-            : 'true';
-        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": ((_b = component.parameters) === null || _b === void 0 ? void 0 : _b[CANVAS_LOCALE_TAG_PARAM]) ? 'true' : undefined, "data-component-title": (_e = (_d = (_c = component.parameters) === null || _c === void 0 ? void 0 : _c.title) === null || _d === void 0 ? void 0 : _d.value) !== null && _e !== void 0 ? _e : '', "data-is-readonly": isReadOnly }, key)), isPlaceholder && emptyPlaceholder !== undefined ? (emptyPlaceholder) : (_jsx(RenderComponent, { ...props })), !shouldRenderContextualEditingTags ? null : _jsx("script", { "data-role": "component-end" })] }) }, key));
+        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/retrieveRoute.d.ts

@@ -1,4 +1,5 @@
 import { ResolvedRouteGetResponse, RouteGetResponseRedirect } from '@uniformdev/canvas';
+import { UniformCompositionProps } from './UniformComposition';
 export type ResolveRouteOptions = {
     path: string;
     state?: number;
@@ -6,5 +7,135 @@ export type ResolveRouteOptions = {
         [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

@@ -1,12 +1,79 @@
-import { CANVAS_DRAFT_STATE, CANVAS_EDITOR_STATE, } from '@uniformdev/canvas';
+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 } from '../config/helpers';
-import config from '../config/uniform.server.config';
-import { isOnVercelPreviewEnvironment } from '../utils/draft';
+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);
@@ -43,6 +110,7 @@ export const resolveRedirectHref = (resolveResult, path) => {
 };
 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;
     }
@@ -62,6 +130,7 @@ const resolveRouteByEdgeConfig = async (data) => {
     return edgeConfig;
 };
 const resolveRouteByRouteApi = async (data) => {
+    var _a;
     const routeClient = getRouteClient({
         revalidate: getRouteRevalidateInterval({
             searchParams: data.searchParams,
@@ -71,7 +140,7 @@ const resolveRouteByRouteApi = async (data) => {
         path: data.path,
         state: data.state,
         withComponentIDs: data.state === CANVAS_DRAFT_STATE || data.state === CANVAS_EDITOR_STATE,
-        withContentSourceMap: isOnVercelPreviewEnvironment(),
+        withContentSourceMap: isOnVercelPreviewEnvironment() && ((_a = getServerConfig().experimental) === null || _a === void 0 ? void 0 : _a.vercelVisualEditing),
     });
     return routeResult;
 };

package/dist/config/helpers.d.ts

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

package/dist/config/helpers.js

@@ -1,20 +1,34 @@
 import { isDraftModeEnabled, isOnVercelPreviewEnvironment } from '../utils/draft';
-import config from './uniform.server.config';
 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

@@ -43,5 +43,9 @@ export type UniformServerConfig = {
          * Dynamic tokens names that should be used for localization.
          */
         localeDynamicInputs?: string[];
+        /**
+         * Enables visual editing mode.
+         */
+        vercelVisualEditing?: boolean;
     };
 };

package/dist/config.js

@@ -1,14 +1,11 @@
-const { existsSync, lstatSync, readFileSync, writeFileSync, readlinkSync } = require('fs');
-const { join, dirname, isAbsolute } = require('path');
-const getPackagePath = () => join(process.cwd(), 'node_modules', '@uniformdev/canvas-next-rsc');
-const getSymlinkAbsolutePath = (symlink) => join(dirname(getPackagePath()), symlink);
-const getConfigPath = (type) => {
-    const configFilePath = join(process.cwd(), `uniform.${type}.config.js`);
+const { existsSync } = require('fs');
+const { join } = require('path');
+const getConfigPath = () => {
+    const configFilePath = join(process.cwd(), `uniform.server.config.js`);
     if (!existsSync(configFilePath)) {
         return undefined;
     }
-    const content = readFileSync(configFilePath, 'utf8');
-    return content;
+    return configFilePath;
 };
 module.exports.withUniformConfig = (nextConfig) => ({
     ...nextConfig,
@@ -17,23 +14,15 @@ module.exports.withUniformConfig = (nextConfig) => ({
             nextConfig.webpack(config, context);
         }
         if (context.isServer) {
-            const uniformConfig = getConfigPath('server');
-            if (uniformConfig) {
-                const packagePath = getPackagePath();
-                const stat = lstatSync(packagePath);
-                const jsFilePath = 'dist/config/uniform.server.config.js';
-                if (stat === null || stat === void 0 ? void 0 : stat.isSymbolicLink()) {
-                    const symlink = readlinkSync(packagePath);
-                    if (symlink) {
-                        const absolute = join(!isAbsolute(symlink) ? getSymlinkAbsolutePath(symlink) : symlink, jsFilePath);
-                        // eslint-disable-next-line no-console
-                        console.log(`Writing Uniform config to ${absolute}`);
-                        writeFileSync(absolute, uniformConfig, 'utf8');
-                    }
-                }
-                else {
-                    writeFileSync(join(packagePath, jsFilePath), uniformConfig, 'utf8');
-                }
+            const uniformConfigPath = getConfigPath();
+            if (uniformConfigPath) {
+                /* eslint-disable-next-line no-console */
+                console.log('Using Uniform config from', uniformConfigPath);
+                config.module.rules.push({
+                    test: /uniform\.server\.config\.js$/,
+                    include: uniformConfigPath,
+                    use: context.defaultLoaders.babel,
+                });
             }
         }
         return config;

package/dist/handler/helpers.js

@@ -2,7 +2,7 @@ import { parseConnectionString } from '@vercel/edge-config';
 import { Webhook } from 'svix';
 import { getProjectMapClient } from '../client/projectMapClient';
 import { getRouteClient } from '../client/routeClient';
-import config from '../config/uniform.server.config';
+import { getServerConfig } from '../config/helpers';
 import { buildCompositionTag, buildPathTag } from '../utils/tag';
 export const isSvixMessage = async (request) => {
     const requiredHeaders = ['svix-id', 'svix-timestamp', 'svix-signature'];
@@ -100,6 +100,7 @@ export const processEdgeConfigChange = async ({ source_url }) => {
         console.warn('UNIFORM_VERCEL_EDGE_CONFIG_TOKEN is not set, skipping edge redirect upsert');
         return;
     }
+    const config = getServerConfig();
     const routeClient = getRouteClient({
         revalidate: -1,
     });

package/dist/handler/messages/handleProjectMapNodeDelete.js

@@ -1,5 +1,5 @@
 import { ProjectMapNodeDeleteDefinition } from '@uniformdev/webhooks';
-import config from '../../config/uniform.server.config';
+import { getServerConfig } from '../../config/helpers';
 import { buildProjectMapNodePaths, processEdgeConfigChange } from '../helpers';
 export const handleProjectMapNodeDelete = async (body) => {
     var _a;
@@ -9,6 +9,7 @@ export const handleProjectMapNodeDelete = async (body) => {
     }
     const tags = [];
     tags.push(...buildProjectMapNodePaths(parsed.data.path));
+    const config = getServerConfig();
     if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeCompositions) {
         await processEdgeConfigChange({
             source_url: parsed.data.path,

package/dist/handler/messages/handleProjectMapNodeInsert.js

@@ -1,5 +1,5 @@
 import { ProjectMapNodeInsertDefinition } from '@uniformdev/webhooks';
-import config from '../../config/uniform.server.config';
+import { getServerConfig } from '../../config/helpers';
 import { buildProjectMapNodePaths, processEdgeConfigChange } from '../helpers';
 export const handleProjectMapNodeInsert = async (body) => {
     var _a;
@@ -9,6 +9,7 @@ export const handleProjectMapNodeInsert = async (body) => {
     }
     const tags = [];
     tags.push(...buildProjectMapNodePaths(parsed.data.path));
+    const config = getServerConfig();
     if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeCompositions) {
         await processEdgeConfigChange({
             source_url: parsed.data.path,

package/dist/handler/messages/handleProjectMapNodeUpdate.js

@@ -1,5 +1,5 @@
 import { ProjectMapNodeUpdateDefinition } from '@uniformdev/webhooks';
-import config from '../../config/uniform.server.config';
+import { getServerConfig } from '../../config/helpers';
 import { buildProjectMapNodePaths, processEdgeConfigChange } from '../helpers';
 export const handleProjectMapNodeUpdate = async (body) => {
     var _a;
@@ -10,6 +10,7 @@ export const handleProjectMapNodeUpdate = async (body) => {
     const tags = [];
     tags.push(...buildProjectMapNodePaths(parsed.data.path));
     tags.push(...buildProjectMapNodePaths(parsed.data.previous_path));
+    const config = getServerConfig();
     if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeCompositions) {
         await processEdgeConfigChange({
             source_url: parsed.data.path,

package/dist/handler/messages/handleRedirectDelete.js

@@ -1,5 +1,5 @@
 import { RedirectDeleteDefinition } from '@uniformdev/webhooks';
-import config from '../../config/uniform.server.config';
+import { getServerConfig } from '../../config/helpers';
 import { processEdgeConfigChange, processRedirectChange } from '../helpers';
 export const handleRedirectDelete = async (body) => {
     var _a;
@@ -7,6 +7,7 @@ export const handleRedirectDelete = async (body) => {
     if (!parsed.success) {
         return undefined;
     }
+    const config = getServerConfig();
     if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeRedirects) {
         await processEdgeConfigChange(parsed.data);
     }

package/dist/handler/messages/handleRedirectInsert.js

@@ -1,5 +1,5 @@
 import { RedirectInsertDefinition } from '@uniformdev/webhooks';
-import config from '../../config/uniform.server.config';
+import { getServerConfig } from '../../config/helpers';
 import { processEdgeConfigChange, processRedirectChange } from '../helpers';
 export const handleRedirectInsert = async (body) => {
     var _a;
@@ -7,6 +7,7 @@ export const handleRedirectInsert = async (body) => {
     if (!parsed.success) {
         return undefined;
     }
+    const config = getServerConfig();
     if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeRedirects) {
         await processEdgeConfigChange(parsed.data);
     }

package/dist/handler/messages/handleRedirectUpdate.js

@@ -1,5 +1,5 @@
 import { RedirectUpdateDefinition } from '@uniformdev/webhooks';
-import config from '../../config/uniform.server.config';
+import { getServerConfig } from '../../config/helpers';
 import { processEdgeConfigChange, processRedirectChange } from '../helpers';
 export const handleRedirectUpdate = async (body) => {
     var _a;
@@ -7,6 +7,7 @@ export const handleRedirectUpdate = async (body) => {
     if (!parsed.success) {
         return undefined;
     }
+    const config = getServerConfig();
     if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeRedirects) {
         await processEdgeConfigChange(parsed.data);
     }

package/dist/index.d.ts

@@ -9,12 +9,15 @@ export { useToggleConsent } from './hooks/useToggleConsent';
 export { useUniformContext } from './hooks/useUniformContext';
 export { componentStore } from './register/componentStore';
 export { registerUniformComponent } from './register/registerUniformComponent';
+export { getUniformContext } from './components/getUniformContext';
 export { getCanvasClient } from './client/canvasClient';
 export { getManifestClient } from './client/manifestClient';
 export { getProjectMapClient } from './client/projectMapClient';
 export { getRouteClient } from './client/routeClient';
-export declare const UniformComposition: (props: Omit<BaseUniformCompositionProps, 'suspense' | 'children'>) => JSX.Element;
-export declare const UniformCompositionCustom: (props: BaseUniformCompositionProps) => JSX.Element;
+export { resolveComposition } from './components/retrieveRoute';
+export { updateContextAction } from './actions/updateContext';
+export declare const UniformComposition: (props: Omit<BaseUniformCompositionProps, 'suspense' | 'children' | 'update'>) => import("react/jsx-runtime").JSX.Element;
+export declare const UniformCompositionCustom: (props: BaseUniformCompositionProps) => import("react/jsx-runtime").JSX.Element;
 export { UniformRichText } from './components/UniformRichText';
 export { isDraftModeEnabled, isIncontextEditingEnabled, isOnVercelPreviewEnvironment } from './utils/draft';
 export { CANVAS_DRAFT_STATE, CANVAS_PUBLISHED_STATE, IN_CONTEXT_EDITOR_QUERY_STRING_PARAM, } from '@uniformdev/canvas';

package/dist/index.js

@@ -12,12 +12,17 @@ export { useUniformContext } from './hooks/useUniformContext';
 // Component Registry
 export { componentStore } from './register/componentStore';
 export { registerUniformComponent } from './register/registerUniformComponent';
+// Context
+export { getUniformContext } from './components/getUniformContext';
 // Clients
 export { getCanvasClient } from './client/canvasClient';
 export { getManifestClient } from './client/manifestClient';
 export { getProjectMapClient } from './client/projectMapClient';
 export { getRouteClient } from './client/routeClient';
-export const UniformComposition = (props) => (_jsx(BaseUniformComposition, { ...props }));
+export { resolveComposition } from './components/retrieveRoute';
+// actions
+export { updateContextAction } from './actions/updateContext';
+export const UniformComposition = (props) => _jsx(BaseUniformComposition, { ...props });
 export const UniformCompositionCustom = (props) => (_jsx(BaseUniformComposition, { ...props }));
 export { UniformRichText } from './components/UniformRichText';
 export { isDraftModeEnabled, isIncontextEditingEnabled, isOnVercelPreviewEnvironment } from './utils/draft';

package/dist/utils/comp.js

@@ -1,14 +1,25 @@
-import { walkComponentTree } from '@uniformdev/canvas';
+import { walkNodeTree } from '@uniformdev/canvas';
 export const getAllComponents = (composition) => {
     const ids = {};
-    walkComponentTree(composition, (component, ancestors) => {
-        if (component._id) {
-            const [self, parent] = ancestors;
-            ids[component._id] = {
-                parentId: parent === null || parent === void 0 ? void 0 : parent.component._id,
-                slot: self === null || self === void 0 ? void 0 : self.parentSlot,
-                slotIndex: self === null || self === void 0 ? void 0 : self.parentSlotIndex,
-                component,
+    walkNodeTree(composition, ({ type, actions, node, ancestorsAndSelf }) => {
+        if (type !== 'component') {
+            // don't want blocks here
+            actions.stopProcessingDescendants();
+            return;
+        }
+        if (node._id) {
+            const [self, parent] = ancestorsAndSelf;
+            if (self.type === 'block') {
+                // just to make TS happy, we already know this is true due to the preceding type-prop check
+                return;
+            }
+            const slotIndex = self.type === 'root' ? undefined : self.parentSlotIndex;
+            const slot = self.type === 'root' ? undefined : self.parentSlot;
+            ids[node._id] = {
+                parentId: parent === null || parent === void 0 ? void 0 : parent.node._id,
+                slot,
+                slotIndex,
+                component: node,
             };
         }
     });
@@ -16,9 +27,16 @@ export const getAllComponents = (composition) => {
 };
 export const getComponent = (composition, id) => {
     let result;
-    walkComponentTree(composition, (component) => {
-        if (component._id === id) {
-            result = component;
+    walkNodeTree(composition, ({ type, node, actions }) => {
+        // note: does not work on blocks because it didn't before - so leaving that for back compat
+        // no technical reason I know of why we can't let it find blocks by ID
+        if (type !== 'component') {
+            actions.stopProcessingDescendants();
+            return;
+        }
+        if (node._id === id) {
+            result = node;
+            actions.stopProcessingDescendants();
         }
     });
     return result;

package/dist/utils/draft.js

@@ -6,16 +6,13 @@ export const isDraftModeEnabled = ({ searchParams, }) => {
     if (isDevelopmentEnvironment()) {
         return isIncontextEditingEnabled({ searchParams });
     }
-    return draftMode().isEnabled;
+    return draftMode().isEnabled || isIncontextEditingEnabled({ searchParams });
 };
 export const isIncontextEditingEnabled = ({ searchParams, }) => {
-    // workaround for this https://github.com/vercel/next.js/issues/49927, as draftMode() is not working in dev mode
-    // so we just need to check if the query string contains the IN_CONTEXT_EDITOR_QUERY_STRING_PARAM blindly
-    if (isDevelopmentEnvironment() || draftMode().isEnabled) {
-        const containsKey = typeof (searchParams === null || searchParams === void 0 ? void 0 : searchParams[IN_CONTEXT_EDITOR_QUERY_STRING_PARAM]) !== 'undefined';
-        return containsKey;
-    }
-    return false;
+    // todo (adaml): draft mode can't be trusted in edge mode, consider in context editing if query string
+    // is present: https://github.com/vercel/next.js/issues/52080
+    const containsKey = typeof (searchParams === null || searchParams === void 0 ? void 0 : searchParams[IN_CONTEXT_EDITOR_QUERY_STRING_PARAM]) !== 'undefined';
+    return containsKey;
 };
 export const isOnVercelPreviewEnvironment = () => {
     return process.env.VERCEL_ENV === 'preview';

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@uniformdev/canvas-next-rsc",
-  "version": "19.49.0",
+  "version": "19.49.4-alpha.67+9773e3b65",
   "license": "SEE LICENSE IN LICENSE.txt",
   "scripts": {
-    "dev": "pnpm build --watch",
+    "dev": "tsc --watch",
     "build": "tsc && node scripts/remove-export.js",
     "lint": "eslint \"**/*.{ts,tsx}\" --fix",
     "test": "jest --maxWorkers=1 --passWithNoTests"
@@ -48,33 +48,35 @@
     "@types/gtag.js": "^0.0.13",
     "@types/js-cookie": "^3.0.3",
     "@types/node": "^18.0.0",
-    "@types/react": "^18.2.3",
+    "@types/react": "^18.2.20",
     "eslint": "^8.11.0",
-    "next": "13.4.12",
+    "next": "^13.4.12",
     "react": "18.2.0",
-    "react-dom": "18.2.0",
-    "typescript": "^5.0.4"
+    "react-dom": "18.2.0"
   },
   "dependencies": {
-    "@uniformdev/canvas": "19.49.0",
-    "@uniformdev/canvas-react": "19.49.0",
-    "@uniformdev/context": "19.49.0",
-    "@uniformdev/project-map": "19.49.0",
-    "@uniformdev/redirect": "19.49.0",
-    "@uniformdev/richtext": "19.49.0",
-    "@uniformdev/webhooks": "19.49.0",
+    "@uniformdev/canvas": "19.49.4-alpha.67+9773e3b65",
+    "@uniformdev/canvas-react": "19.49.4-alpha.67+9773e3b65",
+    "@uniformdev/context": "19.49.4-alpha.67+9773e3b65",
+    "@uniformdev/project-map": "19.49.4-alpha.67+9773e3b65",
+    "@uniformdev/redirect": "19.49.4-alpha.67+9773e3b65",
+    "@uniformdev/richtext": "19.49.4-alpha.67+9773e3b65",
+    "@uniformdev/webhooks": "19.49.4-alpha.67+9773e3b65",
     "@vercel/edge-config": "^0.2.0",
     "dequal": "^2.0.3",
     "js-cookie": "^3.0.5",
     "svix": "^1.5.0"
   },
+  "engines": {
+    "node": ">=16.14.0"
+  },
   "peerDependencies": {
     "next": ">=13.4.7",
-    "react": ">=16.13.1 || 17 || 18",
-    "react-dom": ">=16.13.1"
+    "react": ">=18.2",
+    "react-dom": ">=18.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7aaac583f8003f3e510e6a68a76828a32cbf451d"
+  "gitHead": "9773e3b65168255768f5cbecf2536988fa0e03af"
 }

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

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

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

@@ -1,3 +0,0 @@
-// NOTE: this file will be replaced at build time with (project root)/uniform.client.config.js (if it exists)
-const config = {};
-export default config;