@delmaredigital/payload-experiments 0.0.0-stage → 0.1.0-rc.6

package/dist/admin/arms/ArmsField.js

@@ -0,0 +1,310 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { Button, TextInput, useField, useForm, useFormFields } from '@payloadcms/ui';
+import { EDITABLE_BY_STATUS, isEditable } from '../../collections/experiments/editability.js';
+import { lockedReason } from '../lockedNotice.model.js';
+import { ARMS_COPY, GROUP_LABELS, ISSUE_COPY, issueMessage } from '../copy/arms.js';
+import { addHoldoutArm, addVariant, ARM_FIELDS, defaultArms, issuesByRow, readArms, removeArm, setWeight, splitEvenly, totalWeight, withSlotsFor } from './arms.model.js';
+import { pageTargetIssue, setPageTarget, showsPageTarget } from './pageTarget.model.js';
+import { paramsForArm, paramsReadOnly } from './params.model.js';
+import { numberInputStyle, ParamsEditor } from './ParamsEditor.js';
+function newRowId() {
+    if (globalThis.crypto?.getRandomValues) {
+        return Array.from(globalThis.crypto.getRandomValues(new Uint8Array(12)), (byte)=>byte.toString(16).padStart(2, '0')).join('');
+    }
+    return (Date.now().toString(16).padStart(12, '0') + Math.floor(Math.random() * 2 ** 48).toString(16).padStart(12, '0')).slice(-24);
+}
+export function ArmsField({ field, path = 'arms', readOnly }) {
+    const form = useForm();
+    const { showError, errorMessage } = useField({
+        path,
+        hasRows: true
+    });
+    const kind = useFormFields(([fields])=>fields.kind?.value);
+    const status = useFormFields(([fields])=>fields.status?.value ?? 'draft');
+    const flagPoint = useFormFields(([fields])=>fields.flagPoint?.value);
+    const rowMetadata = useFormFields(([fields])=>fields[path]?.rows);
+    // Payload compares selector results by identity. Retain the arm slice when
+    // another field changes, including while a cleared weight contains NaN.
+    const selectRows = useMemo(()=>{
+        let previous = {
+            arms: [],
+            rowIds: []
+        };
+        return ([fields])=>{
+            const arms = readArms(fields, path);
+            const rowIds = arms.map((_, index)=>fields[`${path}.${index}.id`]?.value);
+            if (arms.length !== previous.arms.length || arms.some((arm, index)=>rowIds[index] !== previous.rowIds[index] || ARM_FIELDS.some((key)=>!Object.is(arm[key], previous.arms[index]?.[key])))) previous = {
+                arms,
+                rowIds
+            };
+            return previous;
+        };
+    }, [
+        path
+    ]);
+    const { arms, rowIds } = useFormFields(selectRows);
+    const seeded = useRef(false);
+    const editable = isEditable(status, 'arms') && !readOnly && !form.disabled;
+    const reason = lockedReason(status, 'arms', EDITABLE_BY_STATUS);
+    const points = field.admin?.custom?.flagPoints ?? [];
+    const point = points.find((candidate)=>candidate.id === flagPoint);
+    const issues = issuesByRow(arms, kind);
+    const total = totalWeight(arms);
+    const hasControl = arms.some((arm)=>arm.kind === 'control');
+    const serverCode = [
+        ...issues.form,
+        ...issues.rows.flat()
+    ].find((issue)=>issue.message === errorMessage)?.code ?? (typeof errorMessage === 'string' ? Object.keys(ISSUE_COPY).find((code)=>errorMessage.split(/[^a-z-]+/).includes(code)) : undefined);
+    function apply(next) {
+        if (!editable) return;
+        // null (from Postgres) and undefined both mean "unset"; only real differences are written.
+        const same = (a, b)=>Object.is(a, b) || a == null && b == null;
+        let changed = false;
+        next = withSlotsFor(next, kind);
+        if (next === arms) return;
+        const structureChanged = next.length !== arms.length || next.some((row, index)=>row.key !== arms[index]?.key);
+        // Array row IDs identify existing groups in the server's immutable-key check.
+        // Move both the hidden ID field and public row metadata with the logical key.
+        const idsByKey = new Map(arms.map((row, index)=>[
+                row.key,
+                rowIds[index]
+            ]));
+        const nextIds = structureChanged ? next.map((row)=>idsByKey.get(row.key) ?? newRowId()) : rowIds;
+        if (structureChanged) changed = true;
+        for(let rowIndex = arms.length - 1; rowIndex >= next.length; rowIndex--)form.removeFieldRow({
+            path,
+            rowIndex
+        });
+        for(let rowIndex = arms.length; rowIndex < next.length; rowIndex++){
+            const row = next[rowIndex];
+            const subFieldState = {
+                ...Object.fromEntries(ARM_FIELDS.filter((key)=>key !== 'params' || row.kind !== 'holdout').map((key)=>[
+                        key,
+                        {
+                            value: row[key],
+                            initialValue: undefined,
+                            valid: true
+                        }
+                    ])),
+                id: {
+                    value: nextIds[rowIndex],
+                    initialValue: undefined,
+                    valid: true
+                }
+            };
+            form.addFieldRow({
+                path,
+                rowIndex,
+                schemaPath: 'arms',
+                subFieldState
+            });
+        }
+        next.forEach((row, index)=>{
+            if (structureChanged && rowIds[index] !== nextIds[index]) form.dispatchFields({
+                type: 'UPDATE',
+                path: `${path}.${index}.id`,
+                value: nextIds[index]
+            });
+            for (const key of ARM_FIELDS){
+                if (key === 'params' && row.kind === 'holdout') {
+                    // Reusing a physical row for the holdout must drop the former
+                    // variant's params without assigning params to the holdout.
+                    if (arms[index]?.params != null) {
+                        changed = true;
+                        form.dispatchFields({
+                            type: 'UPDATE',
+                            path: `${path}.${index}.params`,
+                            value: undefined
+                        });
+                    }
+                    continue;
+                }
+                if (!same(arms[index]?.[key], row[key])) {
+                    changed = true;
+                    form.dispatchFields({
+                        type: 'UPDATE',
+                        path: `${path}.${index}.${key}`,
+                        value: row[key]
+                    });
+                }
+            }
+        });
+        if (structureChanged) form.dispatchFields({
+            type: 'UPDATE',
+            path,
+            rows: nextIds.map((id)=>rowMetadata?.find((row)=>row.id === id) ?? {
+                    id: id,
+                    isLoading: true
+                })
+        });
+        if (changed) form.setModified(true);
+    }
+    useEffect(()=>{
+        if (!editable) return;
+        if (!arms.length && !seeded.current) {
+            seeded.current = true;
+            apply(defaultArms(kind));
+        } else if (arms.length) apply(arms);
+    });
+    function update(index, patch) {
+        apply(arms.map((arm, i)=>i === index ? {
+                ...arm,
+                ...patch
+            } : arm));
+    }
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "xp-groups",
+        children: [
+            reason ? /*#__PURE__*/ _jsx("p", {
+                className: "xp-locked-notice",
+                children: reason
+            }) : null,
+            arms.length ? issues.form.map((issue, i)=>/*#__PURE__*/ _jsx("p", {
+                    role: "alert",
+                    children: issueMessage(issue, total)
+                }, i)) : null,
+            showError && errorMessage ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: issueMessage({
+                    code: serverCode ?? '',
+                    message: errorMessage
+                }, total)
+            }) : null,
+            /*#__PURE__*/ _jsxs("fieldset", {
+                disabled: !editable,
+                "aria-label": ARMS_COPY.groups,
+                style: {
+                    border: 0,
+                    padding: 0,
+                    margin: 0
+                },
+                children: [
+                    arms.map((arm, index)=>{
+                        const rowPath = `${path}.${index}`;
+                        const pageIssue = kind && showsPageTarget(kind, arm.kind) ? pageTargetIssue(arm.pageTarget, arm.kind) : null;
+                        return /*#__PURE__*/ _jsxs("section", {
+                            className: "xp-group",
+                            style: {
+                                marginBottom: '1.5rem'
+                            },
+                            children: [
+                                /*#__PURE__*/ _jsx("h3", {
+                                    children: GROUP_LABELS[arm.key] ?? arm.label
+                                }),
+                                /*#__PURE__*/ _jsx(TextInput, {
+                                    hasMany: false,
+                                    path: `${rowPath}.label`,
+                                    label: ARMS_COPY.label,
+                                    value: arm.label ?? '',
+                                    readOnly: !editable,
+                                    onChange: (event)=>update(index, {
+                                            label: event.target.value
+                                        })
+                                }),
+                                /*#__PURE__*/ _jsxs("label", {
+                                    htmlFor: `${rowPath}.weight`,
+                                    children: [
+                                        ARMS_COPY.weight,
+                                        /*#__PURE__*/ _jsx("input", {
+                                            id: `${rowPath}.weight`,
+                                            name: `${rowPath}.weight`,
+                                            type: "number",
+                                            min: 0,
+                                            max: 100,
+                                            step: 1,
+                                            style: numberInputStyle,
+                                            disabled: !editable,
+                                            value: Number.isFinite(arm.weight) ? arm.weight : '',
+                                            onChange: (event)=>apply(setWeight(arms, arm.key, event.target.value === '' ? NaN : Number(event.target.value)))
+                                        })
+                                    ]
+                                }),
+                                kind === 'block' && arm.kind !== 'holdout' ? /*#__PURE__*/ _jsxs("p", {
+                                    children: [
+                                        ARMS_COPY.slot,
+                                        ": ",
+                                        GROUP_LABELS[arm.key] ?? arm.label
+                                    ]
+                                }) : null,
+                                kind === 'page' && arm.kind === 'holdout' ? /*#__PURE__*/ _jsx("p", {
+                                    children: ARMS_COPY.holdoutPage
+                                }) : null,
+                                kind && showsPageTarget(kind, arm.kind) ? /*#__PURE__*/ _jsx(TextInput, {
+                                    hasMany: false,
+                                    path: `${rowPath}.pageTarget`,
+                                    label: ARMS_COPY.pagePath,
+                                    value: arm.pageTarget ?? '',
+                                    required: true,
+                                    readOnly: !editable,
+                                    onChange: (event)=>{
+                                        const next = setPageTarget(arm, event.target.value);
+                                        update(index, {
+                                            pageTarget: next.pageTarget
+                                        });
+                                    }
+                                }) : null,
+                                pageIssue ? /*#__PURE__*/ _jsx("p", {
+                                    role: "alert",
+                                    children: pageIssue
+                                }) : null,
+                                kind === 'flag' && point && arm.kind !== 'holdout' ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                    children: [
+                                        arm.kind === 'control' ? /*#__PURE__*/ _jsx("p", {
+                                            children: ARMS_COPY.controlParams
+                                        }) : null,
+                                        /*#__PURE__*/ _jsx(ParamsEditor, {
+                                            fields: point.params,
+                                            path: `${rowPath}.params`,
+                                            value: paramsForArm(arm, point),
+                                            readOnly: paramsReadOnly(arm, editable),
+                                            onChange: (params)=>update(index, {
+                                                    params
+                                                })
+                                        })
+                                    ]
+                                }) : null,
+                                issues.rows[index].map((issue, i)=>/*#__PURE__*/ _jsx("p", {
+                                        role: "alert",
+                                        children: issueMessage(issue, total)
+                                    }, i)),
+                                arm.kind === 'holdout' ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                    children: [
+                                        /*#__PURE__*/ _jsx("p", {
+                                            children: ARMS_COPY.holdout
+                                        }),
+                                        /*#__PURE__*/ _jsx(Button, {
+                                            onClick: ()=>apply(removeArm(arms, arm.key)),
+                                            disabled: !editable,
+                                            children: ARMS_COPY.removeHoldout
+                                        })
+                                    ]
+                                }) : arm.kind === 'variant' ? /*#__PURE__*/ _jsx(Button, {
+                                    onClick: ()=>apply(removeArm(arms, arm.key)),
+                                    disabled: !editable,
+                                    children: ARMS_COPY.removeVariant
+                                }) : null
+                            ]
+                        }, index);
+                    }),
+                    /*#__PURE__*/ _jsx(Button, {
+                        disabled: !editable || !hasControl || arms.filter((arm)=>arm.kind === 'variant').length >= 3,
+                        onClick: ()=>apply(addVariant(arms, kind)),
+                        children: ARMS_COPY.addVariant
+                    }),
+                    !arms.some((arm)=>arm.kind === 'holdout') ? /*#__PURE__*/ _jsx(Button, {
+                        disabled: !editable || !hasControl,
+                        onClick: ()=>apply(addHoldoutArm(arms)),
+                        children: ARMS_COPY.addHoldout
+                    }) : null,
+                    /*#__PURE__*/ _jsx(Button, {
+                        disabled: !editable,
+                        onClick: ()=>apply(splitEvenly(arms)),
+                        children: ARMS_COPY.splitEvenly
+                    })
+                ]
+            })
+        ]
+    });
+}

package/dist/admin/arms/ParamsEditor.d.ts

@@ -0,0 +1,16 @@
+import type { ParamField } from '../../types/contracts.js';
+export declare const numberInputStyle: {
+    readonly background: "var(--theme-input-bg)";
+    readonly color: "var(--theme-text)";
+    readonly border: "1px solid var(--theme-elevation-150)";
+    readonly borderRadius: "var(--style-radius-s)";
+    readonly padding: "0.65rem";
+    readonly width: "100%";
+};
+export declare function ParamsEditor({ fields, value, path, readOnly, onChange }: {
+    fields: Record<string, ParamField>;
+    value: Record<string, unknown>;
+    path: string;
+    readOnly: boolean;
+    onChange: (value: Record<string, unknown>) => void;
+}): import("react").JSX.Element;

package/dist/admin/arms/ParamsEditor.js

@@ -0,0 +1,79 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CheckboxInput, SelectInput, TextareaInput, TextInput } from '@payloadcms/ui';
+import { paramIssue, setParam } from './params.model.js';
+export const numberInputStyle = {
+    background: 'var(--theme-input-bg)',
+    color: 'var(--theme-text)',
+    border: '1px solid var(--theme-elevation-150)',
+    borderRadius: 'var(--style-radius-s)',
+    padding: '0.65rem',
+    width: '100%'
+};
+export function ParamsEditor({ fields, value, path, readOnly, onChange }) {
+    return /*#__PURE__*/ _jsx("div", {
+        className: "xp-params-editor",
+        children: Object.entries(fields).map(([key, field])=>{
+            const fieldPath = `${path}.${key}`;
+            const change = (next)=>{
+                if (!readOnly) onChange(setParam(value, key, field, next));
+            };
+            const issue = paramIssue(field, value[key]);
+            const shared = {
+                path: fieldPath,
+                label: field.label,
+                required: field.required,
+                readOnly
+            };
+            const text = typeof value[key] === 'string' ? value[key] : '';
+            return /*#__PURE__*/ _jsxs("div", {
+                children: [
+                    field.type === 'number' ? /*#__PURE__*/ _jsxs("label", {
+                        htmlFor: fieldPath,
+                        children: [
+                            field.label,
+                            /*#__PURE__*/ _jsx("input", {
+                                id: fieldPath,
+                                name: fieldPath,
+                                type: "number",
+                                style: numberInputStyle,
+                                required: field.required,
+                                disabled: readOnly,
+                                min: field.min,
+                                max: field.max,
+                                step: "any",
+                                value: typeof value[key] === 'number' && Number.isFinite(value[key]) ? value[key] : '',
+                                "aria-invalid": !!issue,
+                                onChange: (event)=>change(event.target.value)
+                            })
+                        ]
+                    }) : field.type === 'checkbox' ? /*#__PURE__*/ _jsx(CheckboxInput, {
+                        ...shared,
+                        name: fieldPath,
+                        checked: value[key] === true,
+                        onToggle: (event)=>change(event.target.checked)
+                    }) : field.type === 'select' ? /*#__PURE__*/ _jsx(SelectInput, {
+                        ...shared,
+                        name: fieldPath,
+                        options: field.options ?? [],
+                        value: text,
+                        onChange: (option)=>change(!Array.isArray(option) ? option?.value ?? '' : '')
+                    }) : field.type === 'textarea' ? /*#__PURE__*/ _jsx(TextareaInput, {
+                        ...shared,
+                        value: text,
+                        onChange: (event)=>change(event.target.value)
+                    }) : /*#__PURE__*/ _jsx(TextInput, {
+                        hasMany: false,
+                        ...shared,
+                        value: text,
+                        onChange: (event)=>change(event.target.value)
+                    }),
+                    issue ? /*#__PURE__*/ _jsx("p", {
+                        role: "alert",
+                        children: issue
+                    }) : null
+                ]
+            }, key);
+        })
+    });
+}

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

@@ -0,0 +1,21 @@
+import type { ArmIssue } from '../../collections/experiments/armInvariants.js';
+import type { Arm, ArmKey, ExperimentKind } from '../../types/contracts.js';
+export declare function defaultArms(kind?: ExperimentKind): Arm[];
+/** Keep content slots in step with the experiment kind, including an unset kind. */
+export declare function withSlotsFor(arms: Arm[], kind?: ExperimentKind): Arm[];
+export declare function totalWeight(arms: Arm[]): number;
+export declare function addVariant(arms: Arm[], kind?: ExperimentKind): Arm[];
+export declare function removeArm(arms: Arm[], key: ArmKey): Arm[];
+export declare function addHoldoutArm(arms: Arm[]): Arm[];
+export declare function removeHoldout(arms: Arm[]): Arm[];
+export declare function splitEvenly(arms: Arm[]): Arm[];
+export declare function setWeight(arms: Arm[], key: ArmKey, weight: number): Arm[];
+export declare function issuesByRow(arms: Arm[], kind?: ExperimentKind): {
+    rows: ArmIssue[][];
+    form: ArmIssue[];
+};
+export declare const ARM_FIELDS: readonly ["key", "label", "weight", "kind", "slot", "params", "pageTarget"];
+/** Payload arrays store each row's values at separate field paths. */
+export declare function readArms(fields: Record<string, {
+    value?: unknown;
+}>, path?: string): Arm[];

package/dist/admin/arms/arms.model.js

@@ -0,0 +1,153 @@
+import { addHoldout, checkArms } from '../../collections/experiments/armInvariants.js';
+import { GROUP_LABELS } from '../copy/arms.js';
+const VARIANTS = [
+    'variantA',
+    'variantB',
+    'variantC'
+];
+export function defaultArms(kind) {
+    return withSlotsFor([
+        {
+            key: 'control',
+            kind: 'control',
+            label: GROUP_LABELS.control,
+            weight: 50
+        },
+        {
+            key: 'variantA',
+            kind: 'variant',
+            label: GROUP_LABELS.variantA,
+            weight: 50
+        }
+    ], kind);
+}
+/** Keep content slots in step with the experiment kind, including an unset kind. */ export function withSlotsFor(arms, kind) {
+    const next = arms.map((arm)=>{
+        if (kind === 'block' && arm.kind !== 'holdout') return arm.slot === arm.key ? arm : {
+            ...arm,
+            slot: arm.key
+        };
+        // Postgres returns null for unset columns; null counts as "no slot" so a loaded doc is not rewritten.
+        if (arm.slot == null) return arm;
+        const { slot: _slot, ...rest } = arm;
+        return rest;
+    });
+    return next.every((arm, index)=>arm === arms[index]) ? arms : next;
+}
+const finiteWeight = (weight)=>Number.isFinite(weight) ? weight : 0;
+export function totalWeight(arms) {
+    return arms.reduce((sum, arm)=>sum + finiteWeight(arm.weight), 0);
+}
+export function addVariant(arms, kind) {
+    if (!arms.some((arm)=>arm.kind === 'control')) return arms;
+    const key = VARIANTS.find((candidate)=>!arms.some((arm)=>arm.key === candidate));
+    if (!key || arms.filter((arm)=>arm.kind === 'variant').length >= 3) return arms;
+    const block = kind === 'block' || kind === undefined && arms.some((arm)=>arm.slot !== undefined);
+    const variant = {
+        key,
+        kind: 'variant',
+        label: GROUP_LABELS[key],
+        weight: 0,
+        ...block ? {
+            slot: key
+        } : {}
+    };
+    const index = arms.findIndex((arm)=>arm.kind === 'holdout');
+    const result = [
+        ...arms
+    ];
+    result.splice(index < 0 ? arms.length : index, 0, variant);
+    return result;
+}
+export function removeArm(arms, key) {
+    if (arms.some((arm)=>arm.key === key && arm.kind === 'control')) return arms;
+    if (key === 'holdout') return removeHoldout(arms);
+    return arms.filter((arm)=>arm.key !== key);
+}
+export function addHoldoutArm(arms) {
+    if (!arms.some((arm)=>arm.kind === 'control') || arms.some((arm)=>arm.kind === 'holdout' || arm.key === 'holdout')) return arms;
+    return addHoldout(arms.map((arm)=>Number.isFinite(arm.weight) ? arm : {
+            ...arm,
+            weight: 0
+        }));
+}
+// Largest remainder, with equal fractional remainders awarded to Original first.
+function distribute(arms, total, proportional) {
+    if (!arms.length) return arms;
+    const weightTotal = totalWeight(arms);
+    const useWeights = proportional && weightTotal > 0;
+    const denominator = useWeights ? weightTotal : arms.length;
+    const numerators = arms.map((arm)=>(useWeights ? finiteWeight(arm.weight) : 1) * total);
+    const weights = numerators.map((numerator)=>Math.floor(numerator / denominator));
+    const order = arms.map((_, i)=>i).sort((a, b)=>numerators[b] % denominator - numerators[a] % denominator || Number(arms[b].kind === 'control') - Number(arms[a].kind === 'control') || a - b);
+    const remainder = total - weights.reduce((sum, weight)=>sum + weight, 0);
+    for(let i = 0; i < remainder; i++)weights[order[i % order.length]]++;
+    return arms.map((arm, i)=>({
+            ...arm,
+            weight: weights[i]
+        }));
+}
+export function removeHoldout(arms) {
+    if (!arms.some((arm)=>arm.kind === 'holdout')) return arms;
+    return distribute(arms.filter((arm)=>arm.kind !== 'holdout'), totalWeight(arms), true);
+}
+export function splitEvenly(arms) {
+    const holdout = arms.find((arm)=>arm.kind === 'holdout');
+    const weight = finiteWeight(holdout?.weight ?? 0);
+    return [
+        ...distribute(arms.filter((arm)=>arm.kind !== 'holdout'), 100 - weight, false),
+        ...holdout ? [
+            {
+                ...holdout,
+                weight
+            }
+        ] : []
+    ];
+}
+export function setWeight(arms, key, weight) {
+    return arms.map((arm)=>arm.key === key ? {
+            ...arm,
+            weight
+        } : arm);
+}
+export function issuesByRow(arms, kind) {
+    const rows = arms.map(()=>[]);
+    const form = [];
+    for (const issue of checkArms(arms, kind)){
+        const index = issue.armIndex ?? arms.findIndex((arm)=>arm.key === issue.armKey);
+        if (index >= 0 && index < arms.length) rows[index].push(issue);
+        else form.push(issue);
+    }
+    return {
+        rows,
+        form
+    };
+}
+export const ARM_FIELDS = [
+    'key',
+    'label',
+    'weight',
+    'kind',
+    'slot',
+    'params',
+    'pageTarget'
+];
+/** Payload arrays store each row's values at separate field paths. */ export function readArms(fields, path = 'arms') {
+    const indices = new Set();
+    for (const name of Object.keys(fields)){
+        if (!name.startsWith(`${path}.`)) continue;
+        const [index, field] = name.slice(path.length + 1).split('.');
+        if (/^\d+$/.test(index) && field === 'key') indices.add(Number(index));
+    }
+    return [
+        ...indices
+    ].sort((a, b)=>a - b).map((index)=>Object.fromEntries(ARM_FIELDS.flatMap((field)=>{
+            const value = fields[`${path}.${index}.${field}`]?.value;
+            return value === undefined ? [] : [
+                [
+                    field,
+                    value
+                ]
+            ];
+        })));
+}

package/dist/admin/arms/pageTarget.model.d.ts

@@ -0,0 +1,4 @@
+import type { Arm, ArmKind, ExperimentKind } from '../../types/contracts.js';
+export declare function showsPageTarget(kind: ExperimentKind, group: ArmKind): boolean;
+export declare function pageTargetIssue(value: unknown, group: ArmKind): string | null;
+export declare function setPageTarget(arm: Arm, value: string): Arm;

package/dist/admin/arms/pageTarget.model.js

@@ -0,0 +1,19 @@
+import { ARMS_COPY } from '../copy/arms.js';
+export function showsPageTarget(kind, group) {
+    return kind === 'page' && group !== 'holdout';
+}
+export function pageTargetIssue(value, group) {
+    if (group === 'holdout') return null;
+    if (typeof value !== 'string' || !value.trim()) return ARMS_COPY.pageRequired;
+    // Backslashes and whitespace can be normalised into a different URL by the browser.
+    if (!value.startsWith('/') || value.startsWith('//') || /[?#\\\s]/.test(value)) return ARMS_COPY.pageInvalid;
+    return null;
+}
+export function setPageTarget(arm, value) {
+    if (arm.kind !== 'holdout') return {
+        ...arm,
+        pageTarget: value
+    };
+    const { pageTarget: _ignored, ...rest } = arm;
+    return rest;
+}

package/dist/admin/arms/params.model.d.ts

@@ -0,0 +1,7 @@
+import type { Arm, ParamField } from '../../types/contracts.js';
+import type { SerializedFlagPoint } from '../../types/admin.js';
+export declare function coerceParam(field: ParamField, value: unknown): unknown;
+export declare function paramIssue(field: ParamField, value: unknown): string | null;
+export declare function paramsReadOnly(arm: Arm, editable: boolean): boolean;
+export declare function paramsForArm(arm: Arm, point?: SerializedFlagPoint): Record<string, unknown>;
+export declare function setParam(params: Record<string, unknown>, key: string, field: ParamField, value: unknown): Record<string, unknown>;

package/dist/admin/arms/params.model.js

@@ -0,0 +1,35 @@
+import { ARMS_COPY } from '../copy/arms.js';
+export function coerceParam(field, value) {
+    if (field.type === 'number') {
+        if (value === '' || value == null) return undefined;
+        return typeof value === 'number' ? value : typeof value === 'string' ? Number(value) : NaN;
+    }
+    if (field.type === 'checkbox') return value === true || value === 'true';
+    return typeof value === 'string' ? value : '';
+}
+export function paramIssue(field, value) {
+    const message = (copy)=>copy.replace('{label}', field.label).replace('{min}', String(field.min)).replace('{max}', String(field.max));
+    if (value == null || value === '') return field.required ? message(ARMS_COPY.paramRequired) : null;
+    if (field.type === 'number') {
+        if (typeof value !== 'number' || !Number.isFinite(value)) return message(ARMS_COPY.paramNumber);
+        if (field.min !== undefined && value < field.min) return message(ARMS_COPY.paramMin);
+        if (field.max !== undefined && value > field.max) return message(ARMS_COPY.paramMax);
+    } else if (field.type === 'checkbox') {
+        if (typeof value !== 'boolean') return message(ARMS_COPY.paramCheckbox);
+    } else if (field.type === 'select') {
+        if (!field.options?.some((option)=>option.value === value)) return message(ARMS_COPY.paramOption);
+    } else if (typeof value !== 'string' || field.required && !value.trim()) return message(ARMS_COPY.paramRequired);
+    return null;
+}
+export function paramsReadOnly(arm, editable) {
+    return !editable || arm.kind !== 'variant';
+}
+export function paramsForArm(arm, point) {
+    return arm.kind !== 'variant' && point ? point.effectiveDefaults : arm.params ?? {};
+}
+export function setParam(params, key, field, value) {
+    return {
+        ...params,
+        [key]: coerceParam(field, value)
+    };
+}