@uniformdev/canvas-next-rsc 19.69.0 → 19.73.0

package/dist/register/registerUniformComponent.d.ts

@@ -1,6 +0,0 @@
-import { ComponentProps } from '../components/UniformComponent';
-export declare const registerUniformComponent: ({ type, variantId, component, }: {
-    type: string;
-    variantId?: string | undefined;
-    component: React.ComponentType<ComponentProps<any>>;
-}) => void;

package/dist/register/registerUniformComponent.js

@@ -1,8 +0,0 @@
-import { componentStore } from './componentStore';
-export const registerUniformComponent = ({ type, variantId, component, }) => {
-    componentStore.register({
-        type,
-        variantId,
-        component,
-    });
-};

package/dist/resolve/resolveChildren.d.ts

@@ -1,10 +0,0 @@
-import { RenderComponentResolver } from '@uniformdev/canvas-react';
-import { ReactNode } from 'react';
-import { CompositionContext, UniformComponentProps } from '../components/UniformComponent';
-export declare function resolveChildren<TRenderProps = unknown>({ children, data, context, hasParentLayout, resolveRenderer, }: {
-    children: UniformComponentProps<TRenderProps>['children'];
-    data: Required<UniformComponentProps<TRenderProps>>['data'];
-    context: CompositionContext;
-    hasParentLayout: boolean;
-    resolveRenderer: RenderComponentResolver;
-}): ReactNode;

package/dist/resolve/resolveChildren.js

@@ -1,20 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createElement } from 'react';
-import { convertComponentToProps } from '../components/convertComponentToProps';
-import { UniformSlot } from '../components/UniformSlot';
-export function resolveChildren({ children, data, context, hasParentLayout, resolveRenderer, }) {
-    // attempt to resolve the top level component if we're at the root and children were not provided
-    if (!children && !hasParentLayout) {
-        const topLevelComponent = resolveRenderer({ type: data.type });
-        if (topLevelComponent) {
-            children = createElement(topLevelComponent, convertComponentToProps({ component: data, context }));
-        }
-        else {
-            children = Object.keys(data.slots || {}).map((slotName) => (_jsx(UniformSlot, { name: slotName, data: data, context: context }, slotName)));
-        }
-    }
-    const renderChildren = typeof children === 'function'
-        ? children(convertComponentToProps({ component: data, context }))
-        : children;
-    return renderChildren;
-}

package/dist/score/index.d.ts

@@ -1,3 +0,0 @@
-import { VisitorData } from '@uniformdev/context';
-export declare function parseScoreCookie(cookieValue: string | undefined): Partial<VisitorData> | undefined;
-export declare function serializeCookie(data: VisitorData): string;

package/dist/score/index.js

@@ -1,114 +0,0 @@
-const TYPE_SEP = '~';
-const PAIR_SEP = '!';
-const KV_SEP = '-';
-// the cookie format is thus:
-// <ab-test-data>~<session-scores>~<visitor-scores>
-// where each type is subdivided into key-value pairs:
-// <k>-<v>!<k>-<v>!...
-// score data is further encoded into base64, so the scores themselves are compressed
-// example:
-// mytest-var1!mytest2-var2~ses1-x!ses2-1~vis1-fa~vis2-10
-// means:
-// mytest test: var1 variant
-// mytest2 test: var2 variant
-// ses1 session signal: bton(x) score
-// ses2 session signal: bton(1) score
-// vis1 visitor signal: bton(fa) score
-// vis2 visitor signal: bton(10) score;
-export function parseScoreCookie(cookieValue) {
-    if (!cookieValue)
-        return;
-    const types = cookieValue.split(TYPE_SEP);
-    if (types.length > 3)
-        return;
-    const [abTestData, sessionScores, visitorScores] = types;
-    return {
-        // this is true since we're reading a cookie, which wouldn't exist if consent wasn't given
-        consent: true,
-        sessionScores: decodeCookieType(parseCookieType(sessionScores)),
-        scores: decodeCookieType(parseCookieType(visitorScores)),
-        tests: parseCookieType(abTestData),
-    };
-}
-function parseCookieType(type) {
-    if (!type) {
-        return {};
-    }
-    const pairs = type.split(PAIR_SEP).map((pair) => pair.split(KV_SEP));
-    return pairs.reduce((acc, cur) => {
-        if (cur.length < 2)
-            return acc;
-        // join handles the case when there is a pair separator in the value,
-        // i.e. testname-testid-with-hyphens
-        acc[cur[0]] = cur.slice(1).join('-');
-        return acc;
-    }, {});
-}
-function decodeCookieType(type) {
-    return Object.entries(type).reduce((acc, [key, value]) => {
-        acc[key] = bton(value);
-        return acc;
-    }, {});
-}
-export function serializeCookie(data) {
-    return [
-        serializeCookieType(data.tests),
-        serializeCookieType(encodeCookieType(data.sessionScores)),
-        serializeCookieType(encodeCookieType(data.scores)),
-    ].join(TYPE_SEP);
-}
-function encodeCookieType(type) {
-    return Object.entries(type).reduce((acc, [key, value]) => {
-        acc[key] = ntob(value);
-        return acc;
-    }, {});
-}
-function serializeCookieType(type) {
-    return Object.entries(type)
-        .map((kv) => kv.join(KV_SEP))
-        .join(PAIR_SEP);
-}
-const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-// binary to string lookup table
-const b2s = alphabet.split('');
-// string to binary lookup table
-// 123 == 'z'.charCodeAt(0) + 1
-const s2b = new Array(123);
-for (let i = 0; i < alphabet.length; i++) {
-    s2b[alphabet.charCodeAt(i)] = i;
-}
-/**
- * Converts a number to a base64 string of its representation.
- * Compresses the number if it is to be transferred in a string representation.
- */
-const ntob = (number) => {
-    if (number < 0)
-        return `-${ntob(-number)}`;
-    let lo = number >>> 0;
-    let hi = (number / 4294967296) >>> 0;
-    let right = '';
-    while (hi > 0) {
-        right = b2s[0x3f & lo] + right;
-        lo >>>= 6;
-        lo |= (0x3f & hi) << 26;
-        hi >>>= 6;
-    }
-    let left = '';
-    do {
-        left = b2s[0x3f & lo] + left;
-        lo >>>= 6;
-    } while (lo > 0);
-    return left + right;
-};
-/**
- * Converts a base64 string to an equivalent number _represented as a string in base64_.
- * Decompresses a number from the compressed base64 string.
- */
-const bton = (base64) => {
-    let number = 0;
-    const sign = base64.charAt(0) === '-' ? 1 : 0;
-    for (let i = sign; i < base64.length; i++) {
-        number = number * 64 + s2b[base64.charCodeAt(i)];
-    }
-    return sign ? -number : number;
-};

package/dist/utils/__tests__/apply.spec.d.ts

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

package/dist/utils/__tests__/apply.spec.js

@@ -1,358 +0,0 @@
-import { applyDiff } from '../apply';
-import { ComponentDiffType } from '../diff';
-describe('apply', () => {
-    it('should leave a composition alone if the diff is blank', () => {
-        const result = applyDiff({
-            composition: {
-                _id: 'root',
-                _name: 'root',
-                type: 'root',
-            },
-            diff: [],
-        });
-        expect(result).toEqual({
-            _id: 'root',
-            _name: 'root',
-            type: 'root',
-        });
-    });
-    it('should add a slot component if diff specifies one', () => {
-        const result = applyDiff({
-            composition: {
-                _id: 'root',
-                _name: 'root',
-                type: 'root',
-                slots: {
-                    content: [],
-                },
-            },
-            diff: [
-                {
-                    type: ComponentDiffType.ComponentAdded,
-                    id: 'child',
-                    parentId: 'root',
-                    slot: 'content',
-                    slotIndex: 0,
-                    component: {
-                        type: 'child',
-                        _id: 'child',
-                    },
-                },
-            ],
-        });
-        expect(result).toEqual({
-            _id: 'root',
-            _name: 'root',
-            type: 'root',
-            slots: {
-                content: [
-                    {
-                        _id: 'child',
-                        type: 'child',
-                    },
-                ],
-            },
-        });
-    });
-    it('should remove a slot component if diff specifies one', () => {
-        const result = applyDiff({
-            composition: {
-                _id: 'root',
-                _name: 'root',
-                type: 'root',
-                slots: {
-                    content: [
-                        {
-                            type: 'child1',
-                            _id: 'child',
-                        },
-                        {
-                            type: 'child',
-                            _id: 'child2',
-                        },
-                    ],
-                },
-            },
-            diff: [
-                {
-                    type: ComponentDiffType.ComponentRemoved,
-                    id: 'child',
-                },
-            ],
-        });
-        expect(result).toEqual({
-            _id: 'root',
-            _name: 'root',
-            type: 'root',
-            slots: {
-                content: [
-                    {
-                        type: 'child',
-                        _id: 'child2',
-                    },
-                ],
-            },
-        });
-    });
-    it('should move a slot component if diff specifies one', () => {
-        const result = applyDiff({
-            composition: {
-                _id: 'root',
-                _name: 'root',
-                type: 'root',
-                slots: {
-                    content: [
-                        {
-                            type: 'child',
-                            _id: 'child1',
-                            slots: {
-                                content: [],
-                            },
-                        },
-                        {
-                            type: 'child',
-                            _id: 'child2',
-                        },
-                    ],
-                },
-            },
-            diff: [
-                {
-                    type: ComponentDiffType.ComponentMoved,
-                    id: 'child2',
-                    parentId: 'child1',
-                    slot: 'content',
-                    slotIndex: 0,
-                },
-            ],
-        });
-        expect(result).toEqual({
-            _id: 'root',
-            _name: 'root',
-            type: 'root',
-            slots: {
-                content: [
-                    {
-                        type: 'child',
-                        _id: 'child1',
-                        slots: {
-                            content: [
-                                {
-                                    type: 'child',
-                                    _id: 'child2',
-                                },
-                            ],
-                        },
-                    },
-                ],
-            },
-        });
-    });
-    it('should move a slot component if diff specifies one, even if target does not define slot', () => {
-        const result = applyDiff({
-            composition: {
-                _id: 'root',
-                _name: 'root',
-                type: 'root',
-                slots: {
-                    content: [
-                        {
-                            type: 'child',
-                            _id: 'child1',
-                        },
-                        {
-                            type: 'child',
-                            _id: 'child2',
-                        },
-                    ],
-                },
-            },
-            diff: [
-                {
-                    type: ComponentDiffType.ComponentMoved,
-                    id: 'child2',
-                    parentId: 'child1',
-                    slot: 'content',
-                    slotIndex: 0,
-                },
-            ],
-        });
-        expect(result).toEqual({
-            _id: 'root',
-            _name: 'root',
-            type: 'root',
-            slots: {
-                content: [
-                    {
-                        type: 'child',
-                        _id: 'child1',
-                        slots: {
-                            content: [
-                                {
-                                    type: 'child',
-                                    _id: 'child2',
-                                },
-                            ],
-                        },
-                    },
-                ],
-            },
-        });
-    });
-    it('should change a parameter if diff specifies one', () => {
-        const result = applyDiff({
-            composition: {
-                _id: 'root',
-                _name: 'root',
-                type: 'root',
-                parameters: {
-                    title: {
-                        type: 'text',
-                        value: 'Hello',
-                    },
-                },
-            },
-            diff: [
-                {
-                    type: ComponentDiffType.ParameterChanged,
-                    componentId: 'root',
-                    parameterName: 'title',
-                    value: 'Goodbye',
-                },
-            ],
-        });
-        expect(result).toEqual({
-            _id: 'root',
-            _name: 'root',
-            type: 'root',
-            parameters: {
-                title: {
-                    type: 'text',
-                    value: 'Goodbye',
-                },
-            },
-        });
-    });
-    it('should delete a parameter if diff specifies one', () => {
-        const result = applyDiff({
-            composition: {
-                _id: 'root',
-                _name: 'root',
-                type: 'root',
-                parameters: {
-                    title: {
-                        type: 'text',
-                        value: 'Hello',
-                    },
-                },
-            },
-            diff: [
-                {
-                    type: ComponentDiffType.ParameterRemoved,
-                    componentId: 'root',
-                    parameterName: 'title',
-                },
-            ],
-        });
-        expect(result).toEqual({
-            _id: 'root',
-            _name: 'root',
-            type: 'root',
-            parameters: {},
-        });
-    });
-    it('should handle a component and move in a slot', () => {
-        const result = applyDiff({
-            composition: {
-                _id: 'root',
-                _name: 'root',
-                type: 'root',
-                slots: {
-                    pageContent: [
-                        {
-                            type: 'hero',
-                            _id: '1f352a25-7acb-4893-a11c-f06bd45f27ab',
-                        },
-                        {
-                            type: 'hero',
-                            _id: '93e9fa20-d86e-4543-9ca7-927ffeab6d54',
-                        },
-                    ],
-                },
-            },
-            diff: [
-                {
-                    type: ComponentDiffType.ComponentRemoved,
-                    id: '1f352a25-7acb-4893-a11c-f06bd45f27ab',
-                },
-                {
-                    type: ComponentDiffType.ComponentMoved,
-                    id: '93e9fa20-d86e-4543-9ca7-927ffeab6d54',
-                    slotIndex: 0,
-                    parentId: undefined,
-                    slot: undefined,
-                },
-            ],
-        });
-        expect(result).toEqual({
-            _id: 'root',
-            _name: 'root',
-            type: 'root',
-            slots: {
-                pageContent: [
-                    {
-                        type: 'hero',
-                        _id: '93e9fa20-d86e-4543-9ca7-927ffeab6d54',
-                    },
-                ],
-            },
-        });
-    });
-    it('should put components back into the correct position', () => {
-        const result = applyDiff({
-            composition: {
-                _id: 'root',
-                _name: 'root',
-                type: 'root',
-                slots: {
-                    content: [
-                        {
-                            type: 'child',
-                            _id: 'existing',
-                        },
-                    ],
-                },
-            },
-            diff: [
-                {
-                    type: ComponentDiffType.ComponentAdded,
-                    id: 'child',
-                    parentId: 'root',
-                    slot: 'content',
-                    slotIndex: 0,
-                    component: {
-                        type: 'child',
-                        _id: 'child',
-                    },
-                },
-            ],
-        });
-        expect(result).toEqual({
-            _id: 'root',
-            _name: 'root',
-            type: 'root',
-            slots: {
-                content: [
-                    {
-                        _id: 'child',
-                        type: 'child',
-                    },
-                    {
-                        type: 'child',
-                        _id: 'existing',
-                    },
-                ],
-            },
-        });
-    });
-});

package/dist/utils/__tests__/diff.spec.d.ts

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