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

package/dist/admin/blocks/BlockPanel.js

@@ -0,0 +1,199 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Banner, Button, ConfirmationModal, toast, useModal, useFormInitializing, useRowLabel } from '@payloadcms/ui';
+import { formatAdminURL } from 'payload/shared';
+import { useEffect, useId, useRef, useState } from 'react';
+import { copyOriginalIntoVersion, syncExperimentSlots, unwrapExperimentBlock } from '../../blocks/formState.js';
+import { BLOCK_COPY, blockSyncNotice, blockUnwrapNotice, blockDeleteConfirmation, blockUnwrapConfirmation, blockRunningUnwrap, blockDecidedUnwrap, blockFinishedCopy } from '../copy/blocks.js';
+import { API_MESSAGES } from '../copy/common.js';
+import { isOrphan, liveStatus, slotLabel, statusSentence } from './model.js';
+import { createApi } from '../api.js';
+import { useBlockStatus, setBlockStatus } from './statusCache.js';
+import { useBlockForm } from './useBlockForm.js';
+import { BlockChangedError, RefusalError } from './formApi.js';
+function errorMessage(error) {
+    return error instanceof BlockChangedError || error instanceof RefusalError ? error.message : API_MESSAGES.failed;
+}
+export function BlockStatusField({ path }) {
+    const context = useBlockForm(path), { block, field, manager, config, collection, replace } = context;
+    const initializing = useFormInitializing();
+    const status = useBlockStatus(config.routes.api, block?.experiment, true);
+    const synced = useRef(false), syncing = useRef(false);
+    const [notice, setNotice] = useState(false), [error, setError] = useState(), [busy, setBusy] = useState(false);
+    const [syncError, setSyncError] = useState();
+    const { openModal } = useModal();
+    const modalSlug = `xp-unwrap-${useId()}`;
+    const canSync = !initializing && manager && block && field && liveStatus(status) && [
+        'draft',
+        'stopped'
+    ].includes(status.status);
+    async function sync() {
+        if (!canSync || syncing.current) return;
+        syncing.current = true;
+        setBusy(true);
+        setSyncError(undefined);
+        try {
+            const next = syncExperimentSlots(block, status.arms, field);
+            if (JSON.stringify(next.slots) !== JSON.stringify(block.slots)) {
+                await replace([
+                    next
+                ]);
+                setNotice(true);
+            }
+        } catch (error) {
+            setSyncError(errorMessage(error));
+        } finally{
+            syncing.current = false;
+            setBusy(false);
+        }
+    }
+    useEffect(()=>{
+        if (synced.current || !canSync) return;
+        synced.current = true;
+        void sync();
+    });
+    if (!status || !manager) return null;
+    const draft = liveStatus(status) && status.status === 'draft';
+    const stopped = liveStatus(status) && status.status === 'stopped';
+    async function unwrap() {
+        if (!block || !field || busy) return;
+        setBusy(true);
+        setError(undefined);
+        let deleted = false;
+        try {
+            if (draft) {
+                const api = createApi(config.routes.api);
+                const found = await api.findTestIdBySlug(block.experiment);
+                if (!found.ok) throw new RefusalError(found.message);
+                const removed = await api.deleteTest(found.data);
+                if (!removed.ok) throw new RefusalError(removed.message);
+                deleted = true;
+                setBlockStatus(config.routes.api, block.experiment, {
+                    deleted: true
+                });
+            }
+            await replace(unwrapExperimentBlock(block, field));
+            toast.success(blockUnwrapNotice(Boolean(collection?.versions?.drafts), deleted));
+        } catch (error) {
+            setError(deleted ? BLOCK_COPY.finishUnwrap : errorMessage(error));
+        } finally{
+            setBusy(false);
+        }
+    }
+    const sentence = statusSentence(status);
+    const linkedCopy = liveStatus(status) ? status.status === 'running' ? blockRunningUnwrap : status.status === 'decided' ? blockDecidedUnwrap : status.status === 'archived' && status.winnerArm ? blockFinishedCopy(slotLabel(status.winnerArm, status)) : undefined : undefined;
+    const href = formatAdminURL({
+        adminRoute: config.routes.admin,
+        path: `/experiments/by-slug/${encodeURIComponent(block?.experiment ?? '')}`
+    });
+    return /*#__PURE__*/ _jsxs("div", {
+        children: [
+            liveStatus(status) && status.status === 'running' ? /*#__PURE__*/ _jsx(Banner, {
+                children: sentence
+            }) : linkedCopy && liveStatus(status) && status.status === 'archived' ? null : /*#__PURE__*/ _jsx("p", {
+                children: sentence
+            }),
+            linkedCopy ? /*#__PURE__*/ _jsxs("p", {
+                children: [
+                    linkedCopy.before,
+                    /*#__PURE__*/ _jsx("a", {
+                        href: href,
+                        children: linkedCopy.link
+                    }),
+                    linkedCopy.after
+                ]
+            }) : null,
+            notice ? /*#__PURE__*/ _jsx("p", {
+                role: "status",
+                children: blockSyncNotice(Boolean(collection?.versions?.drafts))
+            }) : null,
+            isOrphan(status) || draft || stopped ? /*#__PURE__*/ _jsx(Button, {
+                disabled: busy,
+                onClick: ()=>draft || stopped ? openModal(modalSlug) : void unwrap(),
+                children: draft ? BLOCK_COPY.removeAndUnwrap : BLOCK_COPY.unwrap
+            }) : null,
+            draft || stopped ? /*#__PURE__*/ _jsx(ConfirmationModal, {
+                modalSlug: modalSlug,
+                heading: draft ? BLOCK_COPY.removeAndUnwrap : BLOCK_COPY.unwrap,
+                body: draft ? blockDeleteConfirmation(status.name) : blockUnwrapConfirmation(status.name),
+                confirmLabel: draft ? BLOCK_COPY.deleteAndUnwrap : BLOCK_COPY.unwrap,
+                cancelLabel: BLOCK_COPY.cancel,
+                onConfirm: unwrap
+            }) : null,
+            error ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: error
+            }) : null,
+            syncError ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: syncError
+            }) : null,
+            syncError && canSync ? /*#__PURE__*/ _jsx(Button, {
+                disabled: busy,
+                onClick: ()=>void sync(),
+                children: BLOCK_COPY.retry
+            }) : null
+        ]
+    });
+}
+export function BlockSlotRowLabel() {
+    const { data, path } = useRowLabel();
+    const { config, block } = useBlockForm(path);
+    const status = useBlockStatus(config.routes.api, block?.experiment);
+    return /*#__PURE__*/ _jsx("span", {
+        children: slotLabel(data?.slot ?? '', status)
+    });
+}
+export function CopyOriginalField({ path }) {
+    const { block, field, form, manager, config, replace } = useBlockForm(path);
+    const status = useBlockStatus(config.routes.api, block?.experiment);
+    const rowPath = path.slice(0, path.lastIndexOf('.'));
+    const slot = form.getDataByPath(`${rowPath}.slot`);
+    const [busy, setBusy] = useState(false), [error, setError] = useState();
+    const { openModal } = useModal();
+    const modalSlug = `xp-copy-original-${useId()}`;
+    if (!manager || !field || !block || !slot || slot === 'control' || !liveStatus(status) || ![
+        'draft',
+        'stopped',
+        'running'
+    ].includes(status.status)) return null;
+    async function copy() {
+        if (!block || !field || busy || !slot) return;
+        setBusy(true);
+        setError(undefined);
+        try {
+            await replace([
+                copyOriginalIntoVersion(block, slot, field)
+            ]);
+        } catch (error) {
+            setError(errorMessage(error));
+        } finally{
+            setBusy(false);
+        }
+    }
+    function requestCopy() {
+        if (block?.slots.find((row)=>row.slot === slot)?.blocks?.length) openModal(modalSlug);
+        else void copy();
+    }
+    return /*#__PURE__*/ _jsxs("div", {
+        children: [
+            /*#__PURE__*/ _jsx(Button, {
+                disabled: busy,
+                onClick: requestCopy,
+                children: BLOCK_COPY.copy
+            }),
+            /*#__PURE__*/ _jsx(ConfirmationModal, {
+                modalSlug: modalSlug,
+                heading: BLOCK_COPY.copy,
+                body: BLOCK_COPY.confirmCopy,
+                confirmLabel: BLOCK_COPY.replace,
+                cancelLabel: BLOCK_COPY.cancel,
+                onConfirm: copy
+            }),
+            error ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: error
+            }) : null
+        ]
+    });
+}

package/dist/admin/blocks/TestBlockField.d.ts

@@ -0,0 +1,5 @@
+import type { UIFieldClientProps } from 'payload';
+export declare function TestBlockField(props: UIFieldClientProps & {
+    blocksField: string;
+    blockSlug?: string;
+}): import("react").JSX.Element | null;

package/dist/admin/blocks/TestBlockField.js

@@ -0,0 +1,163 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Button, SelectInput, useAuth, useConfig, useDocumentInfo, useForm, useFormFields, useFormModified, useServerFunctions } from '@payloadcms/ui';
+import { formatAdminURL } from 'payload/shared';
+import { useMemo, useRef, useState } from 'react';
+import { hostBlocks } from '../../blocks/model.js';
+import { wrapExperimentBlock } from '../../blocks/formState.js';
+import { CreateRefused, createTest } from '../../puck/editor/createTest.js';
+import { createApi } from '../api.js';
+import { BLOCK_COPY, blockSaveNotice, blockTestName } from '../copy/blocks.js';
+import { API_MESSAGES } from '../copy/common.js';
+import { adaptClientBlocksField, BlockChangedError, dataAt, experimentBlockSlug, findClientBlocksField, replaceBlockRow, wrapMode } from './formApi.js';
+import { blockChoices, labelText } from './model.js';
+export function TestBlockField(props) {
+    const { permissions } = useAuth();
+    const testPermissions = permissions?.collections?.['xp-experiments'];
+    return testPermissions?.update === true ? /*#__PURE__*/ _jsx(ManagedTestBlockField, {
+        ...props
+    }) : null;
+}
+function ManagedTestBlockField({ blocksField, blockSlug: suppliedSlug }) {
+    const form = useForm(), modified = useFormModified(), document = useDocumentInfo();
+    const { config, getEntityConfig } = useConfig(), { getFormState } = useServerFunctions();
+    useFormFields(([fields])=>fields);
+    const collection = document.collectionSlug ? getEntityConfig({
+        collectionSlug: document.collectionSlug
+    }) : undefined;
+    const clientField = collection ? findClientBlocksField(collection.fields, blocksField) : undefined;
+    const field = useMemo(()=>clientField ? adaptClientBlocksField(clientField, config) : undefined, [
+        clientField,
+        config
+    ]);
+    const [choice, setChoice] = useState(), [busy, setBusy] = useState(false), [error, setError] = useState();
+    const wrapping = useRef(false);
+    if (!field || !collection || !document.collectionSlug) return null;
+    const blockSlug = suppliedSlug ?? experimentBlockSlug(field);
+    const rows = hostBlocks(form.getDataByPath(blocksField)), choices = blockChoices(rows, field, blockSlug);
+    const wrappers = rows.filter((block)=>block.blockType === blockSlug && typeof block.experiment === 'string');
+    async function wrap() {
+        if (!field || wrapping.current || !document.collectionSlug || !collection) return;
+        setError(undefined);
+        if (wrapMode === 'fallback' && modified) {
+            setError(BLOCK_COPY.saveFirst);
+            return;
+        }
+        const selected = blockChoices(form.getDataByPath(blocksField), field, blockSlug).find((item)=>String(item.index) === choice);
+        if (!selected) return;
+        const title = collection.admin?.useAsTitle ? form.getDataByPath(collection.admin.useAsTitle) : undefined;
+        const name = blockTestName(typeof title === 'string' && title.trim() ? title : labelText(collection.labels.singular) ?? collection.slug, selected.label);
+        const beforeCreate = JSON.stringify(form.getData());
+        wrapping.current = true;
+        setBusy(true);
+        try {
+            const test = await createTest(config.routes.api, {
+                kind: 'block',
+                name,
+                unitType: 'visitor'
+            });
+            if (wrapMode === 'fallback') {
+                if (JSON.stringify(form.getData()) !== beforeCreate) {
+                    setError(BLOCK_COPY.saveFirst);
+                    return;
+                }
+                if (document.id == null || !selected.block.id) {
+                    setError(BLOCK_COPY.wrapRefusals['wrap-target-missing']);
+                    return;
+                }
+                const result = await createApi(config.routes.api).wrapBlock({
+                    collection: document.collectionSlug,
+                    id: document.id,
+                    field: blocksField,
+                    blockId: selected.block.id,
+                    experiment: test.slug
+                });
+                if (!result.ok) {
+                    setError(result.code && Object.hasOwn(BLOCK_COPY.wrapRefusals, result.code) ? BLOCK_COPY.wrapRefusals[result.code] : API_MESSAGES.failed);
+                    return;
+                }
+                window.location.reload();
+            } else {
+                await replaceBlockRow({
+                    form,
+                    getFormState,
+                    collectionSlug: document.collectionSlug,
+                    id: document.id,
+                    field: blocksField,
+                    index: selected.index,
+                    expectedBlock: selected.block,
+                    rows: [
+                        wrapExperimentBlock(selected.block, test.slug, field, {}, blockSlug)
+                    ],
+                    docPermissions: document.docPermissions,
+                    docPreferences: await document.getDocPreferences?.()
+                });
+            }
+            setChoice(undefined);
+        } catch (cause) {
+            setError(cause instanceof CreateRefused || cause instanceof BlockChangedError ? cause.message : API_MESSAGES.failed);
+        } finally{
+            wrapping.current = false;
+            setBusy(false);
+        }
+    }
+    return /*#__PURE__*/ _jsxs("div", {
+        children: [
+            /*#__PURE__*/ _jsx("h3", {
+                children: BLOCK_COPY.testBlock
+            }),
+            choices.length ? /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    /*#__PURE__*/ _jsx(SelectInput, {
+                        name: "xpBlockChoice",
+                        path: "xpBlockChoice",
+                        label: BLOCK_COPY.pick,
+                        options: choices.map((item)=>({
+                                label: item.option,
+                                value: String(item.index)
+                            })),
+                        value: choice,
+                        readOnly: busy,
+                        onChange: (option)=>{
+                            if (!Array.isArray(option)) setChoice(option?.value);
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(Button, {
+                        disabled: busy || choice === undefined,
+                        onClick: ()=>void wrap(),
+                        children: BLOCK_COPY.testBlock
+                    })
+                ]
+            }) : /*#__PURE__*/ _jsx("p", {
+                children: BLOCK_COPY.empty
+            }),
+            error ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: error
+            }) : null,
+            wrappers.map((block)=>{
+                const slug = block.experiment;
+                const inSavedDocument = hostBlocks(dataAt(document.data, blocksField)).some((row)=>row.blockType === blockSlug && row.experiment === slug);
+                const saved = !modified && inSavedDocument;
+                return /*#__PURE__*/ _jsxs("p", {
+                    children: [
+                        !inSavedDocument ? /*#__PURE__*/ _jsxs(_Fragment, {
+                            children: [
+                                blockSaveNotice(Boolean(collection.versions?.drafts)),
+                                ' '
+                            ]
+                        }) : null,
+                        /*#__PURE__*/ _jsx("a", {
+                            "aria-disabled": !saved,
+                            href: saved ? formatAdminURL({
+                                adminRoute: config.routes.admin,
+                                path: `/experiments/by-slug/${encodeURIComponent(slug)}`
+                            }) : undefined,
+                            children: BLOCK_COPY.setup
+                        })
+                    ]
+                }, block.id ?? slug);
+            })
+        ]
+    });
+}

package/dist/admin/blocks/formApi.d.ts

@@ -0,0 +1,46 @@
+import type { ClientConfig, ClientField, Field } from 'payload';
+import type { useForm, useServerFunctions } from '@payloadcms/ui';
+import { type HostBlock } from '../../blocks/model.js';
+/** The only form-state failure with block-specific editor copy. */
+export declare class BlockChangedError extends Error {
+    constructor();
+}
+/** An API refusal already translated into editor-facing copy. */
+export declare class RefusalError extends Error {
+}
+export type RowsField = Extract<Field, {
+    type: 'blocks';
+}>;
+export declare const wrapMode: 'form-api' | 'fallback';
+/** Client twin: unnamed layout containers do not contribute to a data path. */
+export declare function findClientBlocksField(fields: readonly ClientField[], name: string): Extract<ClientField, {
+    type: 'blocks';
+}> | undefined;
+/** Only schema structure is needed by the pure helpers, never server validators.
+ * Resolve references at every depth, including inside the Experiment slots field.
+ */
+export declare function adaptClientBlocksField(field: Extract<ClientField, {
+    type: 'blocks';
+}>, config: Pick<ClientConfig, 'blocks'>): RowsField;
+export declare function experimentBlockSlug(field: RowsField): string;
+export declare function rowLocation(path: string): {
+    field: string;
+    index: number;
+} | undefined;
+export declare function dataAt(data: unknown, path: string): unknown;
+/** Payload 3.90.2 and 4 beta.6 use the same row APIs. Sync replaces the whole
+ * wrapper so add/drop/reorder and the server-rendered component slots stay together.
+ * N=0 needs UPDATE: removeFieldRow alone serializes the empty field as number 0.
+ */
+export declare function replaceBlockRow(args: {
+    form: ReturnType<typeof useForm>;
+    getFormState: ReturnType<typeof useServerFunctions>['getFormState'];
+    collectionSlug: string;
+    id?: string | number;
+    field: string;
+    index: number;
+    rows: HostBlock[];
+    expectedBlock?: HostBlock;
+    docPermissions?: Parameters<ReturnType<typeof useServerFunctions>['getFormState']>[0]['docPermissions'];
+    docPreferences?: Parameters<ReturnType<typeof useServerFunctions>['getFormState']>[0]['docPreferences'];
+}): Promise<void>;

package/dist/admin/blocks/formApi.js

@@ -0,0 +1,159 @@
+import { EXPERIMENT_BLOCK_SLUG, hostBlocks } from '../../blocks/model.js';
+import { BLOCK_COPY } from '../copy/blocks.js';
+/** The only form-state failure with block-specific editor copy. */ export class BlockChangedError extends Error {
+    constructor(){
+        super(BLOCK_COPY.blockChanged);
+    }
+}
+/** An API refusal already translated into editor-facing copy. */ export class RefusalError extends Error {
+}
+export const wrapMode = 'form-api';
+/** Client twin: unnamed layout containers do not contribute to a data path. */ export function findClientBlocksField(fields, name) {
+    for (const field of fields){
+        if (field.type === 'blocks' && field.name === name) return field;
+        if (field.type === 'row' || field.type === 'collapsible') {
+            const found = findClientBlocksField(field.fields, name);
+            if (found) return found;
+        }
+        if (field.type === 'tabs') for (const tab of field.tabs){
+            if ('name' in tab && tab.name) continue;
+            const found = findClientBlocksField(tab.fields, name);
+            if (found) return found;
+        }
+    }
+}
+/** Only schema structure is needed by the pure helpers, never server validators.
+ * Resolve references at every depth, including inside the Experiment slots field.
+ */ export function adaptClientBlocksField(field, config) {
+    function block(block) {
+        return {
+            ...block,
+            fields: block.fields.map(adapt)
+        };
+    }
+    function adapt(field) {
+        if (field.type === 'blocks') return {
+            ...field,
+            blocks: [
+                ...field.blocks.map(block),
+                ...(field.blockReferences ?? []).flatMap((reference)=>{
+                    const resolved = typeof reference === 'string' ? config.blocks?.find((item)=>item.slug === reference) : reference;
+                    return resolved ? [
+                        block(resolved)
+                    ] : [];
+                })
+            ],
+            blockReferences: []
+        };
+        if ('fields' in field) return {
+            ...field,
+            fields: field.fields.map(adapt)
+        };
+        if (field.type === 'tabs') return {
+            ...field,
+            tabs: field.tabs.map((tab)=>({
+                    ...tab,
+                    fields: tab.fields.map(adapt)
+                }))
+        };
+        return field;
+    }
+    return adapt(field);
+}
+export function experimentBlockSlug(field) {
+    return field.blocks.find((block)=>block.fields.some((field)=>'name' in field && field.name === 'xpBlockStatus'))?.slug ?? EXPERIMENT_BLOCK_SLUG;
+}
+export function rowLocation(path) {
+    const match = /^([^.]+)\.(\d+)(?:\.|$)/.exec(path);
+    return match ? {
+        field: match[1],
+        index: Number(match[2])
+    } : undefined;
+}
+export function dataAt(data, path) {
+    return path.split('.').reduce((value, key)=>value && typeof value === 'object' ? value[key] : undefined, data);
+}
+/** Stable object keys; array order and scalar values remain significant. */ function stringify(value) {
+    return JSON.stringify(value, (_, item)=>item && typeof item === 'object' && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b])=>a < b ? -1 : a > b ? 1 : 0)) : item);
+}
+/** Payload 3.90.2 and 4 beta.6 use the same row APIs. Sync replaces the whole
+ * wrapper so add/drop/reorder and the server-rendered component slots stay together.
+ * N=0 needs UPDATE: removeFieldRow alone serializes the empty field as number 0.
+ */ export async function replaceBlockRow(args) {
+    const { form, getFormState, collectionSlug, id, field, index, rows } = args;
+    const data = form.getData(), before = hostBlocks(data[field]);
+    if (args.expectedBlock && stringify(form.getDataByPath(`${field}.${index}`)) !== stringify(args.expectedBlock)) throw new BlockChangedError();
+    // Compare the same reader on both sides: getData() keeps empty row counts as 0.
+    const original = stringify(form.getDataByPath(field));
+    const next = [
+        ...before.slice(0, index),
+        ...rows,
+        ...before.slice(index + 1)
+    ];
+    const result = await getFormState({
+        collectionSlug,
+        id,
+        schemaPath: collectionSlug,
+        data: {
+            ...data,
+            [field]: next
+        },
+        docPermissions: args.docPermissions,
+        docPreferences: args.docPreferences ?? {
+            fields: {}
+        },
+        operation: id == null ? 'create' : 'update',
+        renderAllFields: true,
+        skipValidation: true
+    });
+    if (stringify(form.getDataByPath(field)) !== original) throw new BlockChangedError();
+    if (!result.state) throw new Error('Missing server form state');
+    const state = result.state;
+    function subFieldState(rowIndex) {
+        const prefix = `${field}.${rowIndex}.`;
+        return Object.fromEntries(Object.entries(state).filter(([path])=>path.startsWith(prefix)).map(([path, value])=>[
+                path.slice(prefix.length),
+                value
+            ]));
+    }
+    if (!rows.length) {
+        form.removeFieldRow({
+            path: field,
+            rowIndex: index
+        });
+        if (next.length === 0) form.dispatchFields({
+            type: 'UPDATE',
+            path: field,
+            value: [],
+            disableFormData: false
+        });
+        return;
+    }
+    form.replaceFieldRow({
+        path: field,
+        rowIndex: index,
+        schemaPath: `${collectionSlug}.${field}`,
+        blockType: rows[0].blockType,
+        subFieldState: subFieldState(index)
+    });
+    for(let offset = 1; offset < rows.length; offset++)form.addFieldRow({
+        path: field,
+        rowIndex: index + offset,
+        schemaPath: `${collectionSlug}.${field}`,
+        blockType: rows[offset].blockType,
+        subFieldState: subFieldState(index + offset)
+    });
+    // REPLACE_ROW invents a metadata id even when the data id is unchanged.
+    // Keep server row metadata (including custom labels) and the wrapper React key:
+    // otherwise a sync remounts the status field and loses its save notice.
+    const oldRows = form.getFields()[field]?.rows ?? [];
+    const serverRows = state[field]?.rows;
+    if (serverRows) form.dispatchFields({
+        type: 'UPDATE',
+        path: field,
+        rows: serverRows.map((row)=>({
+                ...oldRows.find((old)=>old.id === row.id),
+                ...row
+            }))
+    });
+}

package/dist/admin/blocks/inject.d.ts

@@ -0,0 +1,7 @@
+import type { Field } from 'payload';
+/** Copy the coordinates supplied by CORE-L2, including every containing array. */
+export declare function injectTestBlock(fields: Field[], registration: {
+    field: string;
+    blockSlug?: string;
+    appliesTo?: (doc: Record<string, unknown>) => boolean;
+}): Field[];

package/dist/admin/blocks/inject.js

@@ -0,0 +1,41 @@
+import { findRegisteredBlocksField } from '../../blocks/formState.js';
+import { XP_TEST_BLOCK } from '../paths.js';
+/** Copy the coordinates supplied by CORE-L2, including every containing array. */ export function injectTestBlock(fields, registration) {
+    const found = findRegisteredBlocksField(fields, registration.field);
+    if (!found) return fields;
+    const ui = {
+        name: 'xpTestBlock',
+        type: 'ui',
+        admin: {
+            condition: (data)=>{
+                try {
+                    return registration.appliesTo ? registration.appliesTo(data) === true : true;
+                } catch  {
+                    return false;
+                }
+            },
+            components: {
+                Field: {
+                    path: XP_TEST_BLOCK,
+                    clientProps: {
+                        blocksField: registration.field,
+                        blockSlug: registration.blockSlug
+                    }
+                }
+            }
+        }
+    };
+    function insert(value, path) {
+        const [key, ...rest] = path;
+        if (key === undefined) return value;
+        const copy = Array.isArray(value) ? [
+            ...value
+        ] : {
+            ...value
+        };
+        if (!rest.length) copy.splice(Number(key) + 1, 0, ui);
+        else copy[key] = insert(value[key], rest);
+        return copy;
+    }
+    return insert(fields, found.path);
+}

package/dist/admin/blocks/model.d.ts

@@ -0,0 +1,17 @@
+import type { PlacementStatusResult } from '../../types/endpoints.js';
+import type { RowsField } from './formApi.js';
+export type BlockStatus = PlacementStatusResult['slugs'][string];
+export type LiveBlockStatus = Extract<BlockStatus, {
+    status: string;
+}>;
+export declare function liveStatus(status: BlockStatus | null): status is LiveBlockStatus;
+export declare function slotLabel(slot: string, status: BlockStatus | null): string;
+export declare function statusSentence(status: BlockStatus): string;
+export declare function isOrphan(status: BlockStatus): boolean;
+export declare function labelText(value: unknown): string | undefined;
+export declare function blockChoices(value: unknown, field: RowsField, blockSlug: string): {
+    block: import("../../blocks/model.js").HostBlock;
+    index: number;
+    label: string;
+    option: string;
+}[];