@uniformdev/canvas-next-rsc 19.51.0 → 19.53.0

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/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,7 @@ export type CompositionContext = Omit<RouteGetResponseComposition, 'compositionA
     searchParams: {
         [key: string]: string | undefined;
     } | undefined;
+    cookieValue: string | undefined;
 };
 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,6 @@
 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 { resolveComposition } from './retrieveRoute';
 import { UniformComponent } from './UniformComponent';
 import { UniformProvider } from './UniformContext';
 import { UniformScript } from './UniformScript';
@@ -20,67 +13,17 @@ 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,
         ...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

@@ -3,4 +3,4 @@ import { CompositionContext } from './UniformComponent';
 export type UniformTextProps = {
     context: CompositionContext;
 } & Omit<PureUniformTextProps, 'skipCustomRendering' | 'isContextualEditing'>;
-export declare const UniformText: ({ context, ...rest }: UniformTextProps) => JSX.Element;
+export declare const UniformText: ({ context, ...rest }: UniformTextProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,5 +1,15 @@
 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 () => {
         var _a, _b;
@@ -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,24 +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 { UNIFORM_DEFAULT_COOKIE_NAME } from '@uniformdev/context';
 import serverConfig from '../config/uniform.server.config';
 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 = serverConfig, }) => {
     // 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}`);
@@ -28,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) => {

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,16 @@
+import { Context, CookieTransitionDataStore } from '@uniformdev/context';
+import { getManifestFromApi } from '../client/manifestClient';
+import serverConfig from '../config/uniform.server.config';
+export const getUniformContext = async ({ searchParams, cookieValue, }) => {
+    const manifest = await getManifestFromApi({
+        searchParams,
+    });
+    const context = new Context({
+        manifest,
+        defaultConsent: serverConfig.defaultConsent,
+        transitionStore: new CookieTransitionDataStore({
+            serverCookieValue: cookieValue,
+        }),
+    });
+    return context;
+};

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,80 @@
-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 { 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);

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/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@uniformdev/canvas-next-rsc",
-  "version": "19.51.0",
+  "version": "19.53.0",
   "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.51.0",
-    "@uniformdev/canvas-react": "19.51.0",
-    "@uniformdev/context": "19.51.0",
-    "@uniformdev/project-map": "19.51.0",
-    "@uniformdev/redirect": "19.51.0",
-    "@uniformdev/richtext": "19.51.0",
-    "@uniformdev/webhooks": "19.51.0",
+    "@uniformdev/canvas": "19.53.0",
+    "@uniformdev/canvas-react": "19.53.0",
+    "@uniformdev/context": "19.53.0",
+    "@uniformdev/project-map": "19.53.0",
+    "@uniformdev/redirect": "19.53.0",
+    "@uniformdev/richtext": "19.53.0",
+    "@uniformdev/webhooks": "19.53.0",
     "@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": "6169b3df00a64ebb66e4c4434cbf171e5cfbe6e4"
+  "gitHead": "2f5a368ac31888a37da39c0e449b29b94c35c591"
 }