@delmaredigital/payload-experiments 0.3.0-rc.4 → 0.4.0-rc.2

package/dist/admin/views/ExperimentsRootView.js

@@ -1,14 +1,9 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { accentStyles } from '../../ui/accent.js';
 import { formatAdminURL } from 'payload/shared';
 import { notFound, redirect } from 'next/navigation.js';
-import { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent';
-import { serializeAttributeKeys, serializeFlagPoints, serializeMetricSources } from '../../collections/serialize.js';
-import { puckCollections } from '../../options.js';
 import { xpOptionsFromReq } from '../../options/fromReq.js';
-import { XP_TESTS_SURFACE } from '../paths.js';
-import { SURFACE_COPY } from '../copy/surface.js';
-import { routeAccess } from './access.model.js';
+import { surfaceUrls } from '../surfaceUrls.js';
+import { buildSurfaceProps } from './buildSurfaceProps.js';
+import { renderTestsSurface } from './renderTestsSurface.js';
 export async function ExperimentsRootView({ initPageResult, params, searchParams }) {
     const { req } = initPageResult;
     const adminRoute = req.payload.config.routes.admin;
@@ -26,6 +21,9 @@ export async function ExperimentsRootView({ initPageResult, params, searchParams
     } else if (tail.length === 1) {
         route = 'test';
         id = tail[0];
+    } else if (tail.length === 2 && tail[0] === 'by-slug') {
+        route = 'test';
+        id = tail[1];
     } else if (tail.length === 2 && tail[1] === 'results') {
         route = 'results';
         id = tail[0];
@@ -46,140 +44,37 @@ export async function ExperimentsRootView({ initPageResult, params, searchParams
             path: `${login}?redirect=${encodeURIComponent(currentPath)}`
         }));
     }
-    // Keep the server export importable in plain Node; Next loads the CSS-bearing client boundary when this view renders.
-    const { RootViewMessage } = await import('../components/RootViewMessage.js');
-    const options = xpOptionsFromReq(req);
-    async function permits(access) {
+    if (route === 'home' || route === 'goals') {
+        let canManage = false;
         try {
-            return await access({
+            canManage = await xpOptionsFromReq(req).access.manage({
                 req
             }) === true;
-        } catch  {
-            return false;
-        }
+        } catch  {}
+        if (!canManage) return renderTestsSurface(req, null);
+        return redirect(route === 'home' ? surfaceUrls.home(adminRoute, await searchParams) : surfaceUrls.goals(adminRoute, await searchParams));
     }
-    const canManage = await permits(options.access.manage);
-    const isAdmin = options.access.admin ? await permits(options.access.admin) : false;
-    const canReadResults = options.access.readResults ? await permits(options.access.readResults) : canManage;
-    if (routeAccess({
+    const clientProps = await buildSurfaceProps({
+        req,
         route,
-        hasUser: true,
-        canManage,
-        canReadResults
-    }) !== 'ok') {
-        return /*#__PURE__*/ _jsx(RootViewMessage, {
-            children: SURFACE_COPY.noAccess
-        });
-    }
-    const flagPoints = serializeFlagPoints(options);
-    // xp-state is manager-readable only. Results-only readers do not edit settings.
-    if (canManage && flagPoints.length) {
-        const state = await req.payload.findGlobal({
-            slug: 'xp-state',
+        id,
+        searchParams
+    });
+    if (clientProps?.canManage && id && tail[0] === 'by-slug') {
+        const result = await req.payload.find({
+            collection: 'xp-experiments',
             req,
             overrideAccess: false,
-            depth: 0
-        });
-        const defaults = state.flagDefaults;
-        for (const point of flagPoints)point.effectiveDefaults = defaults?.[point.id]?.params ?? point.defaultParams;
-    }
-    const registrations = puckCollections(options);
-    const pages = route === 'new' && canManage && options.puck?.enabled && registrations.length ? (await Promise.all(registrations.map(async ({ slug: collection })=>{
-        try {
-            const config = req.payload.config.collections.find((item)=>item.slug === collection);
-            const useAsTitle = config?.admin.useAsTitle ?? 'id';
-            const label = config?.labels.plural;
-            // Keep /rsc dependency-safe: translations is not a declared runtime dependency,
-            // so a per-language label picks the request language, then English, then any string.
-            const byLanguage = label && typeof label === 'object' ? label : {};
-            const collectionLabel = typeof label === 'string' ? label : [
-                byLanguage[req.i18n?.language ?? 'en'],
-                byLanguage.en,
-                ...Object.values(byLanguage)
-            ].find((value)=>typeof value === 'string') ?? collection;
-            const result = await req.payload.find({
-                collection,
-                req,
-                overrideAccess: false,
-                depth: 0,
-                limit: 50,
-                sort: '-updatedAt',
-                draft: true,
-                select: {
-                    [useAsTitle]: true
-                }
-            });
-            return result.docs.map((doc)=>{
-                const id = doc.id;
-                const customUrl = options.admin?.editorUrl?.({
-                    collection,
-                    id,
-                    draft: true
-                });
-                const title = doc[useAsTitle];
-                return {
-                    collection,
-                    collectionLabel,
-                    id,
-                    title: typeof title === 'string' || typeof title === 'number' ? String(title) : String(id),
-                    editorUrl: typeof customUrl === 'string' ? customUrl : formatAdminURL({
-                        adminRoute,
-                        path: `/collections/${collection}/${encodeURIComponent(String(id))}`
-                    })
-                };
-            });
-        } catch  {
-            return [];
-        }
-    }))).flat() : undefined;
-    const descriptions = options.admin?.descriptions;
-    const returnToTest = (await searchParams)?.return;
-    const clientProps = {
-        ...typeof returnToTest === 'string' && /^[\w-]+$/.test(returnToTest) ? {
-            returnToTest
-        } : {},
-        route,
-        ...id === undefined ? {} : {
-            id
-        },
-        adminRoute,
-        apiRoute: req.payload.config.routes.api,
-        canManage,
-        canReadResults,
-        isAdmin,
-        flagPoints,
-        ...pages === undefined ? {} : {
-            pages
-        },
-        attributeKeys: serializeAttributeKeys(options),
-        metricSources: serializeMetricSources(options),
-        ...descriptions ? {
-            admin: {
-                descriptions: {
-                    ...descriptions
+            depth: 0,
+            limit: 1,
+            where: {
+                slug: {
+                    equals: id
                 }
             }
-        } : {}
-    };
-    function TestsSurfaceFallback() {
-        return /*#__PURE__*/ _jsx(RootViewMessage, {
-            alert: true,
-            children: SURFACE_COPY.notInstalled
         });
+        if (!result.docs[0]) return notFound();
+        clientProps.id = String(result.docs[0].id);
     }
-    const css = accentStyles(options.theme?.accent);
-    const surface = RenderServerComponent({
-        Component: XP_TESTS_SURFACE,
-        Fallback: TestsSurfaceFallback,
-        importMap: req.payload.importMap,
-        clientProps
-    });
-    return css ? /*#__PURE__*/ _jsxs(_Fragment, {
-        children: [
-            /*#__PURE__*/ _jsx("style", {
-                children: css
-            }),
-            surface
-        ]
-    }) : surface;
+    return renderTestsSurface(req, clientProps);
 }

package/dist/admin/views/GoalEditRedirect.d.ts

@@ -0,0 +1,4 @@
+import type { DocumentViewServerProps } from 'payload';
+type Props = Pick<DocumentViewServerProps, 'initPageResult' | 'params' | 'routeSegments'>;
+export declare function GoalEditRedirect({ initPageResult, params, routeSegments }: Props): Promise<never>;
+export {};

package/dist/admin/views/GoalEditRedirect.js

@@ -0,0 +1,14 @@
+import { formatAdminURL } from 'payload/shared';
+import { redirect } from 'next/navigation.js';
+export async function GoalEditRedirect({ initPageResult, params, routeSegments }) {
+    const resolved = await params;
+    const segments = routeSegments ?? (Array.isArray(resolved?.segments) ? resolved.segments : []);
+    const collectionIndex = segments.indexOf('xp-metrics');
+    const tail = collectionIndex >= 0 ? segments.slice(collectionIndex + 1) : segments;
+    const id = tail[0] ?? resolved?.id ?? initPageResult.docID;
+    const path = id === undefined || id === 'create' ? '/experiments/goals/new' : `/experiments/goals/${encodeURIComponent(String(id))}`;
+    return redirect(formatAdminURL({
+        adminRoute: initPageResult.req.payload.config.routes.admin,
+        path
+    }));
+}

package/dist/admin/views/GoalsCollectionListView.d.ts

@@ -0,0 +1,2 @@
+import type { ListViewServerProps } from 'payload';
+export declare function GoalsCollectionListView(props: ListViewServerProps): Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react").JSX.Element | null | undefined>;

package/dist/admin/views/GoalsCollectionListView.js

@@ -0,0 +1,4 @@
+import { renderCollectionList } from './renderCollectionList.js';
+export async function GoalsCollectionListView(props) {
+    return renderCollectionList(props, 'goals');
+}

package/dist/admin/views/TestsCollectionListView.d.ts

@@ -0,0 +1,2 @@
+import type { ListViewServerProps } from 'payload';
+export declare function TestsCollectionListView(props: ListViewServerProps): Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react").JSX.Element | null | undefined>;

package/dist/admin/views/TestsCollectionListView.js

@@ -0,0 +1,4 @@
+import { renderCollectionList } from './renderCollectionList.js';
+export async function TestsCollectionListView(props) {
+    return renderCollectionList(props, 'home');
+}

package/dist/admin/views/TestsNavLinkServer.d.ts

@@ -1,2 +1,3 @@
 import type { ServerProps } from 'payload';
+/** @deprecated Retained for existing import maps until 0.5.0. */
 export declare function TestsNavLinkServer({ payload, user, permissions }: Pick<ServerProps, 'payload' | 'user' | 'permissions'>): Promise<string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined>;

package/dist/admin/views/TestsNavLinkServer.js

@@ -1,7 +1,7 @@
 import { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent';
 import { SURFACE_COPY } from '../copy/surface.js';
 import { XP_TESTS_NAV_CLIENT } from '../paths.js';
-export async function TestsNavLinkServer({ payload, user, permissions }) {
+/** @deprecated Retained for existing import maps until 0.5.0. */ export async function TestsNavLinkServer({ payload, user, permissions }) {
     const testPermissions = permissions?.collections?.['xp-experiments'];
     if (!user?.collection || testPermissions?.update !== true) return null;
     const result = await payload.find({

package/dist/admin/views/buildSurfaceProps.d.ts

@@ -0,0 +1,8 @@
+import type { AdminViewServerProps, PayloadRequest } from 'payload';
+import type { TestsRoute, TestsSurfaceProps } from '../../types/surface.js';
+export declare function buildSurfaceProps({ req, route, id, searchParams }: {
+    req: PayloadRequest;
+    route: TestsRoute;
+    id?: string;
+    searchParams: AdminViewServerProps['searchParams'];
+}): Promise<TestsSurfaceProps | null>;

package/dist/admin/views/buildSurfaceProps.js

@@ -0,0 +1,143 @@
+import { flattenTopLevelFields, formatAdminURL } from 'payload/shared';
+import { serializeAttributeKeys, serializeFlagPoints, serializeMetricSources } from '../../collections/serialize.js';
+import { serializePageCollections } from '../pageCollections.js';
+import { collectionLabel as resolveLabel } from '../../collections/labels.js';
+import { documentEditor, puckCollections } from '../../options.js';
+import { xpOptionsFromReq } from '../../options/fromReq.js';
+import { routeAccess } from './access.model.js';
+export async function buildSurfaceProps({ req, route, id, searchParams }) {
+    if (!req.user) return null;
+    const adminRoute = req.payload.config.routes.admin;
+    const options = xpOptionsFromReq(req);
+    async function permits(access) {
+        try {
+            return await access({
+                req
+            }) === true;
+        } catch  {
+            return false;
+        }
+    }
+    const canManage = await permits(options.access.manage);
+    const isAdmin = options.access.admin ? await permits(options.access.admin) : false;
+    const canReadResults = options.access.readResults ? await permits(options.access.readResults) : canManage;
+    if (routeAccess({
+        route,
+        hasUser: true,
+        canManage,
+        canReadResults
+    }) !== 'ok') {
+        return null;
+    }
+    const flagPoints = serializeFlagPoints(options);
+    // xp-state is manager-readable only. Results-only readers do not edit settings.
+    if (canManage && flagPoints.length) {
+        const state = await req.payload.findGlobal({
+            slug: 'xp-state',
+            req,
+            overrideAccess: false,
+            depth: 0
+        });
+        const defaults = state.flagDefaults;
+        for (const point of flagPoints)point.effectiveDefaults = defaults?.[point.id]?.params ?? point.defaultParams;
+    }
+    const registrations = [
+        ...new Set([
+            ...options.puck?.enabled ? puckCollections(options) : [],
+            ...options.blocks?.collections ?? []
+        ].map((entry)=>entry.slug))
+    ];
+    const pages = route === 'new' && canManage && registrations.length ? (await Promise.all(registrations.map(async (collection)=>{
+        try {
+            const config = req.payload.config.collections.find((item)=>item.slug === collection);
+            const useAsTitle = config?.admin.useAsTitle ?? 'id';
+            const collectionLabel = resolveLabel(config?.labels.plural, collection, req);
+            // appliesTo may inspect any stored field; ordinary Puck lists keep their title-only projection.
+            const predicateFields = options.blocks?.collections.some((entry)=>entry.slug === collection) ? Object.fromEntries(flattenTopLevelFields(config?.fields ?? []).map((field)=>[
+                    field.name,
+                    true
+                ])) : {};
+            const result = await req.payload.find({
+                collection,
+                req,
+                overrideAccess: false,
+                depth: 0,
+                limit: 50,
+                sort: '-updatedAt',
+                draft: true,
+                select: {
+                    [useAsTitle]: true,
+                    ...predicateFields
+                }
+            });
+            // The new-test list uses the latest draft's editing intent, as the "Test a block" field condition does (§4.1).
+            return result.docs.map((doc)=>{
+                const editor = documentEditor(options, collection, doc);
+                if (editor !== 'puck' && editor !== 'blocks') return null;
+                const id = doc.id;
+                const customUrl = options.admin?.editorUrl?.({
+                    collection,
+                    id,
+                    draft: true,
+                    editor,
+                    doc
+                });
+                const title = doc[useAsTitle];
+                return {
+                    collection,
+                    collectionLabel,
+                    id,
+                    editor,
+                    title: typeof title === 'string' || typeof title === 'number' ? String(title) : String(id),
+                    editorUrl: typeof customUrl === 'string' ? customUrl : formatAdminURL({
+                        adminRoute,
+                        path: `/collections/${collection}/${encodeURIComponent(String(id))}`
+                    })
+                };
+            }).filter((page)=>page !== null);
+        } catch  {
+            return [];
+        }
+    }))).flat() : undefined;
+    const descriptions = options.admin?.descriptions;
+    const returnToTest = (await searchParams)?.return;
+    return {
+        ...typeof returnToTest === 'string' && /^[\w-]+$/.test(returnToTest) ? {
+            returnToTest
+        } : {},
+        route,
+        ...id === undefined ? {} : {
+            id
+        },
+        adminRoute,
+        apiRoute: req.payload.config.routes.api,
+        canManage,
+        canReadResults,
+        isAdmin,
+        flagPoints,
+        ...pages === undefined ? {} : {
+            pages
+        },
+        pageCollections: serializePageCollections(options.pages?.collections ?? [], req),
+        collectionTitles: Object.fromEntries(req.payload.config.collections.flatMap((collection)=>{
+            const title = collection.admin.useAsTitle;
+            return title && title !== 'id' ? [
+                [
+                    collection.slug,
+                    title
+                ]
+            ] : [];
+        })),
+        userId: req.user.id,
+        userCollection: req.payload.config.admin.user,
+        attributeKeys: serializeAttributeKeys(options),
+        metricSources: serializeMetricSources(options),
+        ...descriptions ? {
+            admin: {
+                descriptions: {
+                    ...descriptions
+                }
+            }
+        } : {}
+    };
+}

package/dist/admin/views/renderCollectionList.d.ts

@@ -0,0 +1,2 @@
+import type { ListViewServerProps } from 'payload';
+export declare function renderCollectionList({ payload, searchParams }: ListViewServerProps, route: 'home' | 'goals'): Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react").JSX.Element | null | undefined>;

package/dist/admin/views/renderCollectionList.js

@@ -0,0 +1,34 @@
+import { createLocalReq } from 'payload';
+import { formatAdminURL } from 'payload/shared';
+import { headers } from 'next/headers.js';
+import { redirect } from 'next/navigation.js';
+import { surfaceUrls } from '../surfaceUrls.js';
+import { buildSurfaceProps } from './buildSurfaceProps.js';
+import { renderTestsSurface } from './renderTestsSurface.js';
+export async function renderCollectionList({ payload, searchParams }, route) {
+    const requestHeaders = await headers();
+    // Authentication, not an access-checked operation; host access callbacks need the full session user.
+    const { user } = await payload.auth({
+        headers: requestHeaders
+    });
+    const adminRoute = payload.config.routes.admin;
+    if (!user) {
+        const { login } = payload.config.admin.routes;
+        const currentPath = route === 'home' ? surfaceUrls.home(adminRoute, await searchParams) : surfaceUrls.goals(adminRoute, await searchParams);
+        return redirect(formatAdminURL({
+            adminRoute,
+            path: `${login}?redirect=${encodeURIComponent(currentPath)}`
+        }));
+    }
+    const req = await createLocalReq({
+        user,
+        req: {
+            headers: requestHeaders
+        }
+    }, payload);
+    return renderTestsSurface(req, await buildSurfaceProps({
+        req,
+        route,
+        searchParams
+    }));
+}

package/dist/admin/views/renderTestsSurface.d.ts

@@ -0,0 +1,3 @@
+import type { PayloadRequest } from 'payload';
+import type { TestsSurfaceProps } from '../../types/surface.js';
+export declare function renderTestsSurface(req: PayloadRequest, clientProps: TestsSurfaceProps | null): Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react").JSX.Element | null | undefined>;

package/dist/admin/views/renderTestsSurface.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent';
+import { accentStyles } from '../../ui/accent.js';
+import { xpOptionsFromReq } from '../../options/fromReq.js';
+import { XP_TESTS_SURFACE } from '../paths.js';
+import { SURFACE_COPY } from '../copy/surface.js';
+export async function renderTestsSurface(req, clientProps) {
+    // Keep the server export importable in plain Node; Next loads the CSS-bearing client boundary on render.
+    const { RootViewMessage } = await import('../components/RootViewMessage.js');
+    if (!clientProps) return /*#__PURE__*/ _jsx(RootViewMessage, {
+        children: SURFACE_COPY.noAccess
+    });
+    function TestsSurfaceFallback() {
+        return /*#__PURE__*/ _jsx(RootViewMessage, {
+            alert: true,
+            children: SURFACE_COPY.notInstalled
+        });
+    }
+    const css = accentStyles(xpOptionsFromReq(req).theme?.accent);
+    const surface = RenderServerComponent({
+        Component: XP_TESTS_SURFACE,
+        Fallback: TestsSurfaceFallback,
+        importMap: req.payload.importMap,
+        clientProps
+    });
+    return css ? /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx("style", {
+                children: css
+            }),
+            surface
+        ]
+    }) : surface;
+}

package/dist/blocks/bindings.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedOptions } from '../types/contracts.js';
+/** Same document-kind rule as the scan; Payload blocks are top level, Puck is recursive. */
+export declare function placementSlugs(options: Pick<ResolvedOptions, 'blocks' | 'puck'>, collection: string, doc: Record<string, unknown> | undefined): string[];

package/dist/blocks/bindings.js

@@ -0,0 +1,34 @@
+import { documentEditor, puckCollections } from '../options.js';
+import { EXPERIMENT_BLOCK_SLUG, hostBlocks, isObject } from './model.js';
+/** Same document-kind rule as the scan; Payload blocks are top level, Puck is recursive. */ export function placementSlugs(options, collection, doc) {
+    if (!doc) return [];
+    const editor = documentEditor(options, collection, doc);
+    if (editor === 'blocks') {
+        const registration = options.blocks?.collections.find((r)=>r.slug === collection);
+        if (!registration) return [];
+        return [
+            ...new Set(hostBlocks(doc[registration.field]).flatMap((block)=>block.blockType === (registration.blockSlug ?? EXPERIMENT_BLOCK_SLUG) && typeof block.experiment === 'string' ? [
+                    block.experiment
+                ] : []))
+        ];
+    }
+    if (editor !== 'puck') return [];
+    const registration = puckCollections(options).find((r)=>r.slug === collection);
+    const found = new Set();
+    function walk(v) {
+        if (Array.isArray(v)) {
+            v.forEach(walk);
+            return;
+        }
+        if (!isObject(v)) return;
+        if (v.type === 'ExperimentSlot' && isObject(v.props)) {
+            const ref = v.props.experiment, slug = typeof ref === 'string' ? ref : isObject(ref) ? ref.slug : undefined;
+            if (typeof slug === 'string') found.add(slug);
+        }
+        Object.values(v).forEach(walk);
+    }
+    if (registration) walk(doc[registration.field]);
+    return [
+        ...found
+    ];
+}

package/dist/blocks/createExperimentBlock.d.ts

@@ -0,0 +1,6 @@
+import type { Block } from 'payload';
+export declare function validateExperimentSlots(value: unknown): true | string;
+export declare function createExperimentBlock({ blocks, slug }: {
+    blocks: Block[];
+    slug?: string;
+}): Block;

package/dist/blocks/createExperimentBlock.js

@@ -0,0 +1,77 @@
+import { XP_BLOCK_STATUS, XP_BLOCK_ROW_LABEL, XP_COPY_ORIGINAL } from '../admin/paths.js';
+import { BLOCK_SLOTS, EXPERIMENT_BLOCK_SLUG } from './model.js';
+export function validateExperimentSlots(value) {
+    if (!Array.isArray(value)) return true;
+    const slots = value.map((row)=>row?.slot);
+    return new Set(slots).size === slots.length ? true : 'Each version appears once';
+}
+export function createExperimentBlock({ blocks, slug = EXPERIMENT_BLOCK_SLUG }) {
+    if (blocks.some((block)=>block.slug === slug)) throw new Error('Experiment blocks cannot be nested.');
+    return {
+        slug,
+        labels: {
+            singular: 'Experiment',
+            plural: 'Experiments'
+        },
+        fields: [
+            {
+                name: 'xpBlockStatus',
+                type: 'ui',
+                admin: {
+                    components: {
+                        Field: XP_BLOCK_STATUS
+                    }
+                }
+            },
+            {
+                name: 'experiment',
+                label: 'Test',
+                type: 'text',
+                required: true
+            },
+            {
+                name: 'slots',
+                label: 'Versions',
+                type: 'array',
+                validate: validateExperimentSlots,
+                admin: {
+                    components: {
+                        RowLabel: XP_BLOCK_ROW_LABEL
+                    }
+                },
+                fields: [
+                    {
+                        name: 'xpCopyOriginal',
+                        type: 'ui',
+                        admin: {
+                            components: {
+                                Field: XP_COPY_ORIGINAL
+                            }
+                        }
+                    },
+                    {
+                        name: 'slot',
+                        label: 'Version',
+                        type: 'select',
+                        required: true,
+                        options: BLOCK_SLOTS.map((value, index)=>({
+                                value,
+                                label: [
+                                    'Original',
+                                    'Variant A',
+                                    'Variant B',
+                                    'Variant C'
+                                ][index]
+                            }))
+                    },
+                    {
+                        name: 'blocks',
+                        label: 'Content',
+                        type: 'blocks',
+                        blocks
+                    }
+                ]
+            }
+        ]
+    };
+}

package/dist/blocks/formState.d.ts

@@ -0,0 +1,31 @@
+import type { Block, Field, SanitizedConfig } from 'payload';
+import { type ExperimentBlock, type HostBlock } from './model.js';
+type RowConfig = {
+    blocks?: Block[];
+    localization?: SanitizedConfig['localization'];
+};
+type RowsField = Extract<Field, {
+    type: 'array' | 'blocks';
+}>;
+/** Mirror Payload 3.90.2's collections/operations/utilities/copyDataWithFreshRowIDs.js:
+ * walk configured row/subfield containers only. Mint ids for array/blocks rows, leaving
+ * opaque values (including json, richText, relationships and uploads) unchanged.
+ * Global block definitions resolve blockReferences; inline slot blocks retain host configs.
+ */
+export declare function freshBlockIds<T>(value: T, field: RowsField, config?: RowConfig, mint?: () => string): T;
+export declare function wrapExperimentBlock(block: HostBlock, experiment: string, field: RowsField, config?: RowConfig, blockSlug?: string): ExperimentBlock;
+export declare function syncExperimentSlots(block: ExperimentBlock, arms: readonly {
+    key: string;
+    kind?: string;
+    slot?: string | null;
+}[], field: RowsField, config?: RowConfig): ExperimentBlock;
+export declare function copyOriginalIntoVersion(block: ExperimentBlock, slot: string, field: RowsField, config?: RowConfig): ExperimentBlock;
+export declare function unwrapExperimentBlock(block: HostBlock, field: RowsField, slot?: string, config?: RowConfig): HostBlock[];
+/** Config coordinates include unnamed layout containers. No field component is injected here. */
+export declare function findRegisteredBlocksField(fields: readonly Field[], name: string): {
+    field: Extract<Field, {
+        type: 'blocks';
+    }>;
+    path: Array<string | number>;
+} | undefined;
+export {};