@uniformdev/canvas-next-rsc 19.46.0 → 19.47.0

package/dist/components/UniformComponent.d.ts

@@ -1,6 +1,6 @@
-import { type ComponentInstance, type RootComponentInstance } from '@uniformdev/canvas';
+import { type ComponentInstance, type RootComponentInstance, RouteGetResponseComposition } from '@uniformdev/canvas';
 import { ReactNode } from 'react';
-export type CompositionContext = {
+export type CompositionContext = Omit<RouteGetResponseComposition, 'compositionApiResponse'> & {
     composition: RootComponentInstance;
     path: string;
     state?: number;

package/dist/components/UniformComposition.js

@@ -1,5 +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';
@@ -56,16 +57,31 @@ const UniformCompositionInner = async ({ params, searchParams, children }) => {
     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: resolveResult.compositionApiResponse.composition,
+        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;
+        }, {}),
     });
     const context = {
         composition: evaluatedComposition,
         path,
         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/UniformSlot.js

@@ -28,7 +28,7 @@ export function UniformSlot({ name, children, emptyPlaceholder, data: parentData
             emptyPlaceholder,
         });
         const elements = children ? children({ child, component, key: `wrapped-inner-${index}` }) : child;
-        return createElement(Fragment, { key: index }, elements);
+        return createElement(Fragment, { key: `wrapped-${index}` }, elements);
     });
     if (!wrapperComponent) {
         return React.createElement(React.Fragment, undefined, finalChildren);

package/dist/components/__tests__/evaluateComposition.spec.d.ts

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

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

@@ -0,0 +1,72 @@
+import { CANVAS_LOCALE_TAG_PARAM, CANVAS_LOCALIZATION_SLOT, CANVAS_LOCALIZATION_TYPE, } from '@uniformdev/canvas';
+import { evaluateComposition } from '../evaluateComposition';
+describe('evaluateComposition', () => {
+    it('should localize a compoisition when dynmaic inputs include locale token', async () => {
+        var _a, _b;
+        const root = {
+            _id: 'root',
+            _name: 'root',
+            type: 'root',
+            slots: {
+                content: [
+                    {
+                        type: CANVAS_LOCALIZATION_TYPE,
+                        slots: {
+                            [CANVAS_LOCALIZATION_SLOT]: [
+                                {
+                                    type: 'hero',
+                                    parameters: {
+                                        [CANVAS_LOCALE_TAG_PARAM]: {
+                                            type: CANVAS_LOCALE_TAG_PARAM,
+                                            value: 'fr',
+                                        },
+                                        title: {
+                                            type: 'text',
+                                            value: 'This is the french title!',
+                                        },
+                                    },
+                                },
+                                {
+                                    type: 'hero',
+                                    parameters: {
+                                        [CANVAS_LOCALE_TAG_PARAM]: {
+                                            type: CANVAS_LOCALE_TAG_PARAM,
+                                            value: 'en',
+                                        },
+                                        title: {
+                                            type: 'text',
+                                            value: 'This is the english title!',
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        };
+        await evaluateComposition({
+            root,
+            dynamicInputs: {
+                lang: 'en',
+            },
+            cookies: {},
+            headers: new Headers(),
+            params: {
+                slug: 'whatever',
+            },
+            searchParams: {},
+            config: {
+                experimental: {
+                    localeDynamicInputs: ['lang'],
+                },
+            },
+            manifest: {
+                project: {},
+            },
+        });
+        const localizedHero = (_a = root.slots) === null || _a === void 0 ? void 0 : _a['content'][0];
+        expect(localizedHero).toBeDefined();
+        expect((_b = localizedHero === null || localizedHero === void 0 ? void 0 : localizedHero.parameters) === null || _b === void 0 ? void 0 : _b[CANVAS_LOCALE_TAG_PARAM].value).toBe('en');
+    });
+});

package/dist/components/evaluateComposition.d.ts

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

package/dist/components/evaluateComposition.js

@@ -1,21 +1,13 @@
-import { CANVAS_PERSONALIZATION_PARAM, CANVAS_PERSONALIZE_TYPE, CANVAS_TEST_TYPE, mapSlotToPersonalizedVariations, mapSlotToTestVariations, walkComponentTree, } from '@uniformdev/canvas';
+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 { cookies, headers } from 'next/headers';
-import { getManifestFromApi } from '../client/manifestClient';
+import serverConfig from '../config/uniform.server.config';
 import { serializeCookie } from '../score';
-import { applyDiff } from '../utils/apply';
-import { isDraftModeEnabled } from '../utils/draft';
 import { getBaseUrl } from '../utils/url';
 import { getEnrichmentTags } from './getEnrichmentTags';
 import { resolvePath } from './resolvePath';
-export const evaluateComposition = async ({ root, params, searchParams, }) => {
-    var _a;
-    // retrieve the manifest
-    const manifest = await getManifestFromApi({
-        searchParams,
-    });
+export const evaluateComposition = async ({ root, params, searchParams, dynamicInputs, manifest, headers, cookies, config = serverConfig, }) => {
     // retrieve the score from the cookie, if any
-    const score = (_a = cookies().get(UNIFORM_DEFAULT_COOKIE_NAME)) === null || _a === void 0 ? void 0 : _a.value;
+    const score = cookies[UNIFORM_DEFAULT_COOKIE_NAME];
     // resolve the path from route params
     const path = resolvePath({
         params,
@@ -34,37 +26,30 @@ export const evaluateComposition = async ({ root, params, searchParams, }) => {
             url.searchParams.set(key, value);
         }
     }
-    const headersInstance = headers();
     const missingQuirkValue = 'unknown';
     // update context to update scores
     await context.update({
-        cookies: cookies()
-            .getAll()
-            .reduce((acc, cookie) => {
-            acc[cookie.name] = cookie.value;
-            return acc;
-        }, {}),
+        cookies,
         url,
         quirks: {
-            'vc-country': headersInstance.get('x-vercel-ip-country') || missingQuirkValue,
-            'vc-region': headersInstance.get('x-vercel-ip-country-region') || missingQuirkValue,
-            'vc-city': headersInstance.get('x-vercel-ip-city') || missingQuirkValue,
+            '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,
         },
     });
-    let composition = root;
-    if (isDraftModeEnabled({ searchParams })) {
-        const { vcdiff } = searchParams || {};
-        if (vcdiff) {
-            // remove bas64 encoding
-            const diff = Buffer.from(vcdiff, 'base64').toString('utf-8');
-            // parse the diff
-            const parsedDiff = JSON.parse(diff);
-            // apply the diff
-            composition = applyDiff({
-                composition,
-                diff: parsedDiff,
-            });
-        }
+    const composition = root;
+    const resolvedLocaleKey = Object.keys(dynamicInputs || {}).find((key) => {
+        var _a, _b;
+        return (_b = (_a = config.experimental) === null || _a === void 0 ? void 0 : _a.localeDynamicInputs) === null || _b === void 0 ? void 0 : _b.includes(key);
+    });
+    const resolvedLocale = resolvedLocaleKey
+        ? dynamicInputs[resolvedLocaleKey]
+        : undefined;
+    if (typeof resolvedLocale !== 'undefined') {
+        localize({
+            composition,
+            locale: resolvedLocale,
+        });
     }
     const enrichmentTags = [];
     const seenComponents = [];

package/dist/config/models.d.ts

@@ -39,5 +39,9 @@ export type UniformServerConfig = {
          * @default false
          */
         edgeCompositions?: boolean;
+        /**
+         * Dynamic tokens names that should be used for localization.
+         */
+        localeDynamicInputs?: string[];
     };
 };

package/dist/utils/draft.js

@@ -21,5 +21,5 @@ export const isOnVercelPreviewEnvironment = () => {
     return process.env.VERCEL_ENV === 'preview';
 };
 export const isDevelopmentEnvironment = () => {
-    return process.env.NODE_ENV === 'development';
+    return process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test';
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/canvas-next-rsc",
-  "version": "19.46.0",
+  "version": "19.47.0",
   "license": "SEE LICENSE IN LICENSE.txt",
   "scripts": {
     "dev": "pnpm build --watch",
@@ -56,13 +56,13 @@
     "typescript": "^5.0.4"
   },
   "dependencies": {
-    "@uniformdev/canvas": "19.46.0",
-    "@uniformdev/canvas-react": "19.46.0",
-    "@uniformdev/context": "19.46.0",
-    "@uniformdev/project-map": "19.46.0",
-    "@uniformdev/redirect": "19.46.0",
-    "@uniformdev/richtext": "19.46.0",
-    "@uniformdev/webhooks": "19.46.0",
+    "@uniformdev/canvas": "19.47.0",
+    "@uniformdev/canvas-react": "19.47.0",
+    "@uniformdev/context": "19.47.0",
+    "@uniformdev/project-map": "19.47.0",
+    "@uniformdev/redirect": "19.47.0",
+    "@uniformdev/richtext": "19.47.0",
+    "@uniformdev/webhooks": "19.47.0",
     "@vercel/edge-config": "^0.2.0",
     "dequal": "^2.0.3",
     "js-cookie": "^3.0.5",
@@ -76,5 +76,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "6adedbd963772fdfe3c43584a89704d58527719d"
+  "gitHead": "66bb196919cc178fc94f4d0490d0ac517193304a"
 }