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

package/dist/components/UniformRichTextNode.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { createElement as _createElement } from "react";
+import { isRichTextNode } from '@uniformdev/richtext';
+import { HeadingRichTextNode } from './nodes/HeadingRichTextNode';
+import { LinebreakRichTextNode } from './nodes/LinebreakRichTextNode';
+import { LinkRichTextNode } from './nodes/LinkRichTextNode';
+import { ListItemRichTextNode } from './nodes/ListItemRichTextNode';
+import { ListRichTextNode } from './nodes/ListRichTextNode';
+import { ParagraphRichTextNode } from './nodes/ParagraphRichTextNode';
+import { TabRichTextNode } from './nodes/TabRichTextNode';
+import { TextRichTextNode } from './nodes/TextRichTextNode';
+/**
+ * Render a single RichText node
+ */
+export function UniformRichTextNode({ node, ...props }) {
+    var _a;
+    if (!isRichTextNode(node))
+        return null;
+    let NodeRenderer = (_a = props.resolveRichTextRenderer) === null || _a === void 0 ? void 0 : _a.call(props, node);
+    if (typeof NodeRenderer === 'undefined') {
+        NodeRenderer = resolveRichTextDefaultRenderer(node);
+    }
+    if (!NodeRenderer) {
+        return null;
+    }
+    const children = node.children
+        ? node.children.map((childNode, i) => _createElement(UniformRichTextNode, { ...props, key: i, node: childNode }))
+        : null;
+    return _jsx(NodeRenderer, { node: node, children: children });
+}
+const rendererMap = new Map([
+    ['heading', HeadingRichTextNode],
+    ['linebreak', LinebreakRichTextNode],
+    ['link', LinkRichTextNode],
+    ['list', ListRichTextNode],
+    ['listitem', ListItemRichTextNode],
+    ['paragraph', ParagraphRichTextNode],
+    ['quote', ({ children }) => _jsx("blockquote", { children: children })],
+    [
+        'code',
+        ({ children }) => (_jsx("pre", { children: _jsx("code", { children: children }) })),
+    ],
+    ['root', ({ children }) => _jsx(_Fragment, { children: children })],
+    ['text', TextRichTextNode],
+    ['tab', TabRichTextNode],
+]);
+const resolveRichTextDefaultRenderer = (node) => {
+    return rendererMap.get(node.type);
+};

package/dist/components/UniformScript.d.ts

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

package/dist/components/UniformScript.js

@@ -0,0 +1,49 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { createCanvasChannel } from '@uniformdev/canvas';
+import { useRouter } from 'next/navigation';
+import { useEffect, useMemo } from 'react';
+export const UniformScript = ({ enabled }) => {
+    const router = useRouter();
+    const channel = useMemo(() => {
+        var _a;
+        if (typeof window === 'undefined') {
+            return;
+        }
+        const instance = createCanvasChannel({
+            broadcastTo: [(_a = window.opener) !== null && _a !== void 0 ? _a : window.top],
+            listenTo: [window],
+        });
+        return instance;
+    }, []);
+    useEffect(() => {
+        if (!channel) {
+            return;
+        }
+        const unsubscribeFromEditorUpdates = channel.on('editor-state-updated', () => {
+            router.refresh();
+        });
+        return () => {
+            unsubscribeFromEditorUpdates();
+        };
+    }, [channel, router]);
+    useEffect(() => {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        const existing = document.getElementById('uniform-script');
+        if (enabled) {
+            if (!existing) {
+                const script = document.createElement('script');
+                script.id = 'uniform-script';
+                script.src = `https://uniform.app/files/canvas-in-context-embed/index.js`;
+                script.async = true;
+                document.head.appendChild(script);
+            }
+        }
+        else if (existing) {
+            existing.remove();
+        }
+    }, [enabled]);
+    return _jsx(_Fragment, {});
+};

package/dist/components/UniformSlot.d.ts

@@ -0,0 +1,48 @@
+import { ComponentInstance } from '@uniformdev/canvas';
+import React, { Key, ReactNode } from 'react';
+
+import { CompositionContext } from './UniformComponent';
+export type CustomSlotChildRenderFunc = (options: {
+  child: ReactNode;
+  component: ComponentInstance;
+  key: Key;
+}) => JSX.Element;
+export type UniformSlotWrapperComponentProps = {
+  items: ReactNode[];
+  slotName: string;
+};
+export type UniformSlotProps<TSlotNames extends string> = {
+  /** Name of the slot to render */
+  name: TSlotNames;
+  /** The composition that is being rendered */
+  data: ComponentInstance;
+  /** The context of the composition that is being rendered */
+  context: CompositionContext;
+  /**
+   *  Optional render props enables wrapping all child components in the slot with some markup
+   *
+   *  @deprecated Use `wrapperComponent` instead and define wrapping component for slot children inside.
+   */
+  children?: CustomSlotChildRenderFunc;
+  /**
+   * Optional wrapper component around list of slot items that allows to control
+   * exactly how to render slot items, otherwise React.Fragment is being used
+   */
+  wrapperComponent?: React.ComponentType<UniformSlotWrapperComponentProps>;
+  /**
+   * Optional ReactNode to use as a placeholder in Canvas editor when the slot is empty.
+   * The node is used to render a placeholder with realistic dimensions and it's never shown to users.
+   * Pass `null` to disable the placeholder.
+   */
+  emptyPlaceholder?: ReactNode;
+};
+export declare function UniformSlot<TSlotNames extends string = string>({
+  name,
+  children,
+  emptyPlaceholder,
+  data: parentData,
+  wrapperComponent,
+  context,
+}: UniformSlotProps<TSlotNames> & {
+  data: ComponentInstance;
+}): JSX.Element | null;

package/dist/components/UniformSlot.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createElement, Fragment } from 'react';
+import { renderComponent } from './renderComponent';
+export function UniformSlot({ name, children, emptyPlaceholder, data: parentData, wrapperComponent, context, }) {
+    var _a;
+    const slot = (_a = parentData.slots) === null || _a === void 0 ? void 0 : _a[name];
+    if (!slot || !Array.isArray(slot)) {
+        return null;
+    }
+    const finalChildren = slot.map((component, index) => {
+        const child = renderComponent({
+            component,
+            context,
+            resolveSystem: {
+                test: () => {
+                    // https://www.youtube.com/watch?v=G3AfIvJBcGo
+                    return null;
+                },
+                personalization: () => {
+                    return null;
+                },
+            },
+            key: `inner-${index}`,
+            indexInSlot: index,
+            slotName: name,
+            parentComponent: parentData,
+            slotChildrenCount: slot.length,
+            emptyPlaceholder,
+        });
+        const elements = children ? children({ child, component, key: `wrapped-inner-${index}` }) : child;
+        return createElement(Fragment, { key: `wrapped-${index}` }, elements);
+    });
+    if (!wrapperComponent) {
+        return React.createElement(React.Fragment, undefined, finalChildren);
+    }
+    const Wrapper = wrapperComponent;
+    return _jsx(Wrapper, { items: finalChildren, slotName: name });
+}

package/dist/components/UniformText.d.ts

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

package/dist/components/UniformText.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+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.d.ts

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

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

@@ -0,0 +1,80 @@
+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 composition 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'],
+                },
+            },
+            update: undefined,
+        });
+        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/convertComponentToProps.d.ts

@@ -0,0 +1,18 @@
+import { ComponentInstance } from '@uniformdev/canvas';
+
+import { ComponentProps, CompositionContext } from './UniformComponent';
+/**
+ * Extracts parameters from a component instance and returns them as a props object.
+ *
+ * @param component The component instance to extract parameters from.
+ *
+ * @returns The parameters as a props object.
+ *
+ */
+export declare function convertComponentToProps<T = unknown>({
+  component,
+  context,
+}: {
+  component: ComponentInstance;
+  context: CompositionContext;
+}): ComponentProps<T>;

package/dist/components/convertComponentToProps.js

@@ -0,0 +1,22 @@
+/**
+ * Extracts parameters from a component instance and returns them as a props object.
+ *
+ * @param component The component instance to extract parameters from.
+ *
+ * @returns The parameters as a props object.
+ *
+ */
+export function convertComponentToProps({ component, context, }) {
+    var _a;
+    const parameters = (_a = component.parameters) !== null && _a !== void 0 ? _a : {};
+    const renderComponentProps = {
+        ...Object.keys(parameters).reduce((acc, cur) => {
+            acc[cur] = parameters[cur].value;
+            return acc;
+        }, {}),
+        ...component.data,
+        component,
+        context,
+    };
+    return renderComponentProps;
+}

package/dist/components/evaluateComposition.d.ts

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

package/dist/components/evaluateComposition.js

@@ -0,0 +1,183 @@
+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, headers, cookies, update, config = getServerConfig(), }) => {
+    // resolve the path from route params
+    const path = resolvePath({
+        params,
+    });
+    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}`);
+    for (const [key, value] of Object.entries(searchParams)) {
+        if (value) {
+            url.searchParams.set(key, value);
+        }
+    }
+    const missingQuirkValue = 'unknown';
+    const { cookies: updateCookies, quirks: updateQuirks, ...restOfUpdate } = update || {};
+    // update context to update scores
+    await context.update({
+        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) => {
+        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 = [];
+    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) {
+            const pzComponent = component;
+            // extract the personalized variations from the pz component slot
+            const processedVariants = mapSlotToPersonalizedVariations((_a = pzComponent === null || pzComponent === void 0 ? void 0 : pzComponent.slots) === null || _a === void 0 ? void 0 : _a.pz);
+            // extract the number of variations to take from the pz component, defaulting to 1
+            const take = Number((_b = pzComponent.parameters.count) === null || _b === void 0 ? void 0 : _b.value) || 1;
+            // determine the personalization name
+            const personalizationName = ((_c = pzComponent.parameters.trackingEventName) === null || _c === void 0 ? void 0 : _c.value) || 'Unknown';
+            // personalize the component
+            const { variations: personalized } = context.personalize({
+                name: personalizationName,
+                variations: processedVariants,
+                take,
+            });
+            // if personalized variations were returned, remove the the criteria parameter
+            if (personalized) {
+                for (let i = 0; i < personalized.length; i++) {
+                    (_d = personalized[i].parameters) === null || _d === void 0 ? true : delete _d[CANVAS_PERSONALIZATION_PARAM];
+                }
+            }
+            // record that we have selected these variations for this personalization
+            seenComponents.push({
+                id: personalizationName,
+                type: 'personalization',
+                variants: personalized.map((p) => p.id),
+                control: context.storage.data.controlGroup || false,
+            });
+            // set the replacement components to the personalized variations
+            replacementComponents = personalized;
+        }
+        // evaluate test component
+        if (component.type === CANVAS_TEST_TYPE) {
+            const testComponent = component;
+            // extract the test variations from the test component slot
+            const processedVariants = mapSlotToTestVariations((_e = testComponent === null || testComponent === void 0 ? void 0 : testComponent.slots) === null || _e === void 0 ? void 0 : _e.test);
+            const testName = ((_f = testComponent.parameters.test) === null || _f === void 0 ? void 0 : _f.value) || 'Unknown';
+            // evaluate the test
+            const testResult = context.test({
+                name: testName,
+                variations: processedVariants,
+            });
+            // record that we have selected this variation for this test
+            seenComponents.push({
+                id: testName,
+                type: 'test',
+                variant: testResult.result ? testResult.result.id : undefined,
+            });
+            // set the replacement components to the test variation
+            if (testResult.result) {
+                replacementComponents = [testResult.result];
+            }
+            else {
+                replacementComponents = [];
+            }
+        }
+        // if we replacement components is defined, process replacements
+        if (typeof replacementComponents !== 'undefined') {
+            // if no variants were selected, just remove the current component. no matches.
+            if (replacementComponents.length === 0) {
+                actions.remove();
+            }
+            else {
+                const [first, ...rest] = replacementComponents;
+                // replace the first component
+                actions.replace(first);
+                // if there are other components, insert them after the first
+                if (rest.length) {
+                    actions.insertAfter(rest);
+                }
+            }
+        }
+        else {
+            // check to see if this component has any enrichment tags assigned
+            const tags = getEnrichmentTags(component);
+            // if so, add them to the enrichment tags
+            if (tags === null || tags === void 0 ? void 0 : tags.length) {
+                enrichmentTags.push(...tags);
+            }
+        }
+    });
+    // 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({
+            enrichments: enrichmentTags,
+        });
+    }
+    // return the updated cookie value and any seen components
+    return {
+        cookieValue: context.storage.data.consent ? serializeCookie(context.storage.data) : undefined,
+        composition,
+        seenComponents,
+    };
+};

package/dist/components/getEnrichmentTags.d.ts

@@ -0,0 +1,5 @@
+import { ComponentInstance } from '@uniformdev/canvas';
+import { EnrichmentData } from '@uniformdev/context';
+export declare const getEnrichmentTags: (
+  targets: ComponentInstance | ComponentInstance[]
+) => EnrichmentData[];

package/dist/components/getEnrichmentTags.js

@@ -0,0 +1,13 @@
+import { CANVAS_ENRICHMENT_TAG_PARAM } from '@uniformdev/canvas';
+export const getEnrichmentTags = (targets) => {
+    const targetsArray = Array.isArray(targets) ? targets : [targets];
+    const tags = [];
+    targetsArray.forEach((target) => {
+        var _a, _b;
+        const enrichmentTags = (_b = (_a = target.parameters) === null || _a === void 0 ? void 0 : _a[CANVAS_ENRICHMENT_TAG_PARAM]) === null || _b === void 0 ? void 0 : _b.value;
+        if (enrichmentTags) {
+            tags.push(...enrichmentTags);
+        }
+    });
+    return tags;
+};

package/dist/components/getUniformContext.d.ts

@@ -0,0 +1,10 @@
+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/nodes/HeadingRichTextNode.d.ts

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

package/dist/components/nodes/HeadingRichTextNode.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const HeadingRichTextNode = ({ children, node }) => {
+    const { tag } = node;
+    const HTag = (tag !== null && tag !== void 0 ? tag : 'h1');
+    return _jsx(HTag, { children: children });
+};

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

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

package/dist/components/nodes/LinebreakRichTextNode.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const LinebreakRichTextNode = () => {
+    return _jsx("br", {});
+};

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

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

package/dist/components/nodes/LinkRichTextNode.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { linkParamValueToHref } from '@uniformdev/richtext';
+export const LinkRichTextNode = ({ children, node }) => {
+    const { link } = node;
+    return _jsx("a", { href: linkParamValueToHref(link), children: children });
+};

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

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

package/dist/components/nodes/ListItemRichTextNode.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const ListItemRichTextNode = ({ children, node }) => {
+    const { value } = node;
+    return _jsx("li", { value: Number.isFinite(value) && value > 0 ? value : undefined, children: children });
+};

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

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

package/dist/components/nodes/ListRichTextNode.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const ListRichTextNode = ({ children, node }) => {
+    const { tag, start } = node;
+    const ListTag = (tag !== null && tag !== void 0 ? tag : 'ul');
+    return _jsx(ListTag, { start: Number.isFinite(start) && start > 0 ? start : undefined, children: children });
+};