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

package/dist/admin/copy/tabs.js

@@ -0,0 +1,7 @@
+export const TAB_DESCRIPTIONS = {
+    What: "What you're testing and why.",
+    Who: 'Who takes part and how traffic is split.',
+    Groups: 'The Original, the variants, and an optional holdout.',
+    Metrics: 'What decides the winner and what must not get worse.',
+    Review: 'Check everything, see how long it will take, and start.'
+};

package/dist/admin/copy/who.d.ts

@@ -0,0 +1,36 @@
+export declare const WHO_COPY: {
+    readonly allocation: "Who takes part (%)";
+    readonly attribute: "Attribute";
+    readonly operator: "Comparison";
+    readonly value: "Value";
+    readonly true: "Yes";
+    readonly false: "No";
+    readonly caseNote: "Letter case doesn't matter.";
+    readonly listNote: "Separate values with commas.";
+    readonly emptyListNote: "Add at least one value — an empty list can't be saved.";
+};
+export declare const STRING_OP_LABELS: {
+    readonly eq: "is";
+    readonly neq: "is not";
+    readonly in: "is one of";
+    readonly nin: "is not one of";
+    readonly contains: "contains";
+};
+export declare const NUMBER_OP_LABELS: {
+    readonly eq: "=";
+    readonly neq: "≠";
+    readonly gt: ">";
+    readonly gte: "≥";
+    readonly lt: "<";
+    readonly lte: "≤";
+};
+export declare const participation: (allocation: string, people: string, groups: string) => string;
+export declare const eachVersion: (share: string) => string;
+export declare const groupShare: (share: string, label: string) => string;
+export declare const uncounted = "; the rest see the Original and are not counted";
+export declare const holdoutClause: (weight: string) => string;
+export declare const layerSentence: (name: string, used: number, free: number) => string;
+export declare const peopleLabel: {
+    readonly visitor: "visitors";
+    readonly user: "signed-in users";
+};

package/dist/admin/copy/who.js

@@ -0,0 +1,36 @@
+export const WHO_COPY = {
+    allocation: 'Who takes part (%)',
+    attribute: 'Attribute',
+    operator: 'Comparison',
+    value: 'Value',
+    true: 'Yes',
+    false: 'No',
+    caseNote: "Letter case doesn't matter.",
+    listNote: 'Separate values with commas.',
+    emptyListNote: "Add at least one value — an empty list can't be saved."
+};
+export const STRING_OP_LABELS = {
+    eq: 'is',
+    neq: 'is not',
+    in: 'is one of',
+    nin: 'is not one of',
+    contains: 'contains'
+};
+export const NUMBER_OP_LABELS = {
+    eq: '=',
+    neq: '≠',
+    gt: '>',
+    gte: '≥',
+    lt: '<',
+    lte: '≤'
+};
+export const participation = (allocation, people, groups)=>`${allocation}% of ${people} take part: about ${groups}`;
+export const eachVersion = (share)=>`${share}% see each version`;
+export const groupShare = (share, label)=>`${share}% see ${label === 'Original' ? 'the Original' : label}`;
+export const uncounted = '; the rest see the Original and are not counted';
+export const holdoutClause = (weight)=>`; the holdout (${weight}% of them) sees the Original and is measured; everyone else sees the Original and is not counted.`;
+export const layerSentence = (name, used, free)=>` Uses ${used} of the 100 slices in layer ${name}; ${free} are free.`;
+export const peopleLabel = {
+    visitor: 'visitors',
+    user: 'signed-in users'
+};

package/dist/admin/labels.d.ts

@@ -0,0 +1,45 @@
+import type { ExperimentKind, Status } from '../types/contracts.js';
+import type { VerdictCode } from '../types/snapshot.js';
+export declare const ARM_LABELS: {
+    control: string;
+    variantA: string;
+    variantB: string;
+    variantC: string;
+    holdout: string;
+};
+export declare const STATUS_LABELS: {
+    draft: string;
+    running: string;
+    stopped: string;
+    decided: string;
+    archived: string;
+};
+export declare const PHASE_KIND_LABELS: {
+    readonly test: "during the test";
+    readonly rollout: "after shipping";
+};
+export declare const KIND_LABELS: {
+    block: string;
+    page: string;
+    flag: string;
+    code: string;
+};
+export declare const VERDICT_LABELS: {
+    unavailable: string;
+    'data-problem': string;
+    'guardrail-failing': string;
+    collecting: string;
+    'original-better': string;
+    'worse-none-better': string;
+    winner: string;
+    mixed: string;
+    'keep-running': string;
+    'no-difference': string;
+    'rollout-collecting': string;
+    'rollout-readout': string;
+};
+export declare function armLabel(key: string, storedLabel?: string): string;
+export declare function statusLabel(status: Status): string;
+export declare function phaseKindLabel(kind: 'test' | 'rollout'): string;
+export declare function verdictCodeLabel(code: VerdictCode): string;
+export declare function kindLabel(kind: ExperimentKind): string;

package/dist/admin/labels.js

@@ -0,0 +1,53 @@
+export const ARM_LABELS = {
+    control: 'Original',
+    variantA: 'Variant A',
+    variantB: 'Variant B',
+    variantC: 'Variant C',
+    holdout: 'Holdout'
+};
+export const STATUS_LABELS = {
+    draft: 'Draft',
+    running: 'Running',
+    stopped: 'Stopped',
+    decided: 'Decided',
+    archived: 'Archived'
+};
+export const PHASE_KIND_LABELS = {
+    test: 'during the test',
+    rollout: 'after shipping'
+};
+export const KIND_LABELS = {
+    block: 'Block on a page',
+    page: 'Whole page',
+    flag: 'Setting in code',
+    code: 'Developer code'
+};
+export const VERDICT_LABELS = {
+    unavailable: 'Results unavailable',
+    'data-problem': 'Check the data',
+    'guardrail-failing': 'An important outcome got worse',
+    collecting: 'Collecting results',
+    'original-better': 'The Original is better',
+    'worse-none-better': 'No better option',
+    winner: 'A winner',
+    mixed: 'Mixed results',
+    'keep-running': 'Keep running',
+    'no-difference': 'No clear difference',
+    'rollout-collecting': 'Collecting results after shipping',
+    'rollout-readout': 'Results after shipping'
+};
+export function armLabel(key, storedLabel) {
+    return Object.hasOwn(ARM_LABELS, key) ? ARM_LABELS[key] : storedLabel ?? key;
+}
+export function statusLabel(status) {
+    return STATUS_LABELS[status];
+}
+export function phaseKindLabel(kind) {
+    return PHASE_KIND_LABELS[kind];
+}
+export function verdictCodeLabel(code) {
+    return VERDICT_LABELS[code];
+}
+export function kindLabel(kind) {
+    return KIND_LABELS[kind];
+}

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

@@ -0,0 +1,15 @@
+import type { Status } from '../types/contracts.js';
+export type LayerExperiment = {
+    name: string;
+    status: Status;
+    layerSlices?: readonly number[] | null;
+};
+export declare function layerUsage(experiments: readonly LayerExperiment[]): {
+    used: number;
+    free: number;
+    rows: {
+        name: string;
+        status: Status;
+        slices: number;
+    }[];
+};

package/dist/admin/layerUsage.model.js

@@ -0,0 +1,18 @@
+export function layerUsage(experiments) {
+    const slices = new Set();
+    // ADM-08 coordinator ruling (spec §5.3): exp-core clears layerSlices to [] when freeing slices.
+    const rows = experiments.filter((doc)=>doc.status === 'running' || doc.status === 'decided').map((doc)=>{
+        const unique = new Set(doc.layerSlices ?? []);
+        unique.forEach((slice)=>slices.add(slice));
+        return {
+            name: doc.name,
+            status: doc.status,
+            slices: unique.size
+        };
+    });
+    return {
+        used: slices.size,
+        free: 100 - slices.size,
+        rows
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { Status } from '../types/contracts.js';
+import type { EditableField } from '../types/admin.js';
+export declare function lockedReason(status: Status, field: string, table: Record<Status, readonly EditableField[]>): string | null;

package/dist/admin/lockedNotice.model.js

@@ -0,0 +1,18 @@
+import { LOCKED_MESSAGES } from './copy/common.js';
+export function lockedReason(status, field, table) {
+    if ([
+        'slug',
+        'kind',
+        'unitType',
+        'layer'
+    ].includes(field)) return LOCKED_MESSAGES.creation;
+    if (table[status].some((editable)=>editable === field)) return null;
+    if (status === 'running') {
+        if (field === 'allocation') return LOCKED_MESSAGES.runningAllocation;
+        if (field === 'metrics') return LOCKED_MESSAGES.runningMetrics;
+        return LOCKED_MESSAGES.running;
+    }
+    if (status === 'decided') return LOCKED_MESSAGES.decided;
+    if (status === 'archived') return LOCKED_MESSAGES.archived;
+    return LOCKED_MESSAGES.other;
+}

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

@@ -0,0 +1,7 @@
+import type { SerializedMetricSource } from '../types/admin.js';
+export declare function metricSourceOptions(sources: readonly SerializedMetricSource[]): {
+    value: string;
+    label: string;
+    badge: "count" | "yes/no" | "amount";
+}[];
+export declare function metricSourceHint(source?: SerializedMetricSource): string | null;

package/dist/admin/metricSource.model.js

@@ -0,0 +1,11 @@
+import { METRICS_COPY, METRIC_KIND_LABELS } from './copy/metrics.js';
+export function metricSourceOptions(sources) {
+    return sources.map((source)=>({
+            value: source.id,
+            label: `${source.label} · ${METRIC_KIND_LABELS[source.kind]}`,
+            badge: METRIC_KIND_LABELS[source.kind]
+        }));
+}
+export function metricSourceHint(source) {
+    return source?.kind === 'revenue' ? METRICS_COPY.revenueHint : null;
+}

package/dist/admin/paths.d.ts

@@ -0,0 +1,16 @@
+export declare const XP_STATUS_CELL = "@delmaredigital/payload-experiments/admin/client#StatusCell";
+export declare const XP_SUMMARY_CELL = "@delmaredigital/payload-experiments/admin/client#SummaryCell";
+export declare const XP_ACTIONS = "@delmaredigital/payload-experiments/admin/client#ExperimentActions";
+export declare const XP_LOCKED_NOTICE = "@delmaredigital/payload-experiments/admin/client#LockedFieldNotice";
+export declare const XP_FLAG_POINT_SELECT = "@delmaredigital/payload-experiments/admin/client#FlagPointSelect";
+export declare const XP_ARMS_FIELD = "@delmaredigital/payload-experiments/admin/client#ArmsField";
+export declare const XP_ALLOCATION_FIELD = "@delmaredigital/payload-experiments/admin/client#AllocationField";
+export declare const XP_TARGETING_ATTRIBUTE = "@delmaredigital/payload-experiments/admin/client#TargetingAttributeField";
+export declare const XP_TARGETING_OP = "@delmaredigital/payload-experiments/admin/client#TargetingOpField";
+export declare const XP_TARGETING_VALUE = "@delmaredigital/payload-experiments/admin/client#TargetingValueField";
+export declare const XP_METRIC_SOURCE_SELECT = "@delmaredigital/payload-experiments/admin/client#MetricSourceSelect";
+export declare const XP_REVIEW_PANEL = "@delmaredigital/payload-experiments/admin/client#ReviewPanel";
+export declare const XP_PHASE_HISTORY = "@delmaredigital/payload-experiments/admin/client#PhaseHistory";
+export declare const XP_LAYER_USAGE = "@delmaredigital/payload-experiments/admin/client#LayerUsage";
+export declare const XP_RESULTS_VIEW = "@delmaredigital/payload-experiments/admin/client#ResultsView";
+export declare const XP_ARM_SELECT = "@delmaredigital/payload-experiments/admin/client#ArmSelectField";

package/dist/admin/paths.js

@@ -0,0 +1,16 @@
+export const XP_STATUS_CELL = '@delmaredigital/payload-experiments/admin/client#StatusCell';
+export const XP_SUMMARY_CELL = '@delmaredigital/payload-experiments/admin/client#SummaryCell';
+export const XP_ACTIONS = '@delmaredigital/payload-experiments/admin/client#ExperimentActions';
+export const XP_LOCKED_NOTICE = '@delmaredigital/payload-experiments/admin/client#LockedFieldNotice';
+export const XP_FLAG_POINT_SELECT = '@delmaredigital/payload-experiments/admin/client#FlagPointSelect';
+export const XP_ARMS_FIELD = '@delmaredigital/payload-experiments/admin/client#ArmsField';
+export const XP_ALLOCATION_FIELD = '@delmaredigital/payload-experiments/admin/client#AllocationField';
+export const XP_TARGETING_ATTRIBUTE = '@delmaredigital/payload-experiments/admin/client#TargetingAttributeField';
+export const XP_TARGETING_OP = '@delmaredigital/payload-experiments/admin/client#TargetingOpField';
+export const XP_TARGETING_VALUE = '@delmaredigital/payload-experiments/admin/client#TargetingValueField';
+export const XP_METRIC_SOURCE_SELECT = '@delmaredigital/payload-experiments/admin/client#MetricSourceSelect';
+export const XP_REVIEW_PANEL = '@delmaredigital/payload-experiments/admin/client#ReviewPanel';
+export const XP_PHASE_HISTORY = '@delmaredigital/payload-experiments/admin/client#PhaseHistory';
+export const XP_LAYER_USAGE = '@delmaredigital/payload-experiments/admin/client#LayerUsage';
+export const XP_RESULTS_VIEW = '@delmaredigital/payload-experiments/admin/client#ResultsView';
+export const XP_ARM_SELECT = '@delmaredigital/payload-experiments/admin/client#ArmSelectField';

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

@@ -0,0 +1,10 @@
+export type ManagePermissions = {
+    collections?: {
+        'xp-experiments'?: {
+            update?: boolean | {
+                permission?: boolean;
+            };
+        };
+    };
+};
+export declare function canManage(permissions: ManagePermissions | null | undefined): boolean;

package/dist/admin/permissions.model.js

@@ -0,0 +1,4 @@
+export function canManage(permissions) {
+    const update = permissions?.collections?.['xp-experiments']?.update;
+    return update === true || typeof update === 'object' && update !== null && update.permission === true;
+}

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

@@ -0,0 +1,19 @@
+export type HistoryPhase = {
+    phase: number;
+    phaseKind: 'test' | 'rollout';
+    startedAt: string;
+    endedAt?: string | null;
+    arms: readonly {
+        weight: number;
+    }[];
+};
+export declare function phaseHistory(phases: readonly HistoryPhase[], decision?: {
+    decidedBy?: unknown;
+} | null): {
+    rows: {
+        phase: number;
+        phaseKind: "test" | "rollout";
+        text: string;
+    }[];
+    decision: string | null;
+};

package/dist/admin/phaseHistory.model.js

@@ -0,0 +1,19 @@
+import { phaseKindLabel } from './labels.js';
+import { HISTORY_COPY, roundRow } from './copy/history.js';
+const dateFormat = new Intl.DateTimeFormat('en-US', {
+    month: 'short',
+    day: 'numeric',
+    timeZone: 'UTC'
+});
+export function phaseHistory(phases, decision) {
+    return {
+        rows: [
+            ...phases
+        ].sort((a, b)=>a.phase - b.phase || new Date(a.startedAt).getTime() - new Date(b.startedAt).getTime()).map((phase)=>({
+                phase: phase.phase,
+                phaseKind: phase.phaseKind,
+                text: roundRow(phase.phase, phaseKindLabel(phase.phaseKind), dateFormat.format(new Date(phase.startedAt)), phase.endedAt ? dateFormat.format(new Date(phase.endedAt)) : HISTORY_COPY.now, phase.arms.map((arm)=>arm.weight).join('/'))
+            })),
+        decision: decision?.decidedBy != null ? HISTORY_COPY.decided : null
+    };
+}

package/dist/admin/reload.d.ts

@@ -0,0 +1 @@
+export declare const reloadPage: () => void;

package/dist/admin/reload.js

@@ -0,0 +1 @@
+export const reloadPage = ()=>window.location.reload();

package/dist/admin/results/ArmTable.d.ts

@@ -0,0 +1,8 @@
+import type { ArmRow } from './results.model.js';
+export interface ArmTableProps {
+    rows: ArmRow[];
+    caption: string;
+    method: 'sequential' | 'bayesian';
+    metricKind: 'binomial' | 'count' | 'revenue';
+}
+export declare function ArmTable({ rows, caption, method, metricKind }: ArmTableProps): import("react").JSX.Element;

package/dist/admin/results/ArmTable.js

@@ -0,0 +1,112 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { RESULTS_COPY } from '../copy/results.js';
+import { CappedCell } from './CappedCell.js';
+export function ArmTable({ rows, caption, method, metricKind }) {
+    const sequential = method === 'sequential';
+    const showAdjustedCI = sequential && rows.some((row)=>row.comparison?.method === 'sequential' && row.comparison.adjustedCI !== undefined);
+    const showAdjustedPValue = sequential && rows.some((row)=>row.comparison?.method === 'sequential' && row.comparison.pValueAdjusted !== undefined);
+    const columns = 4 + Number(showAdjustedCI) + Number(showAdjustedPValue);
+    return /*#__PURE__*/ _jsx("div", {
+        className: "xp-arm-table",
+        style: {
+            color: 'var(--theme-text)',
+            overflowX: 'auto'
+        },
+        children: /*#__PURE__*/ _jsxs("table", {
+            children: [
+                /*#__PURE__*/ _jsx("caption", {
+                    children: caption
+                }),
+                /*#__PURE__*/ _jsx("thead", {
+                    children: /*#__PURE__*/ _jsxs("tr", {
+                        children: [
+                            /*#__PURE__*/ _jsx("th", {
+                                scope: "col",
+                                children: RESULTS_COPY.group
+                            }),
+                            /*#__PURE__*/ _jsx("th", {
+                                scope: "col",
+                                children: RESULTS_COPY.people
+                            }),
+                            /*#__PURE__*/ _jsx("th", {
+                                scope: "col",
+                                children: metricKind === 'binomial' ? RESULTS_COPY.conversions : RESULTS_COPY.mean
+                            }),
+                            /*#__PURE__*/ _jsx("th", {
+                                scope: "col",
+                                children: sequential ? RESULTS_COPY.lift : RESULTS_COPY.chanceToWin
+                            }),
+                            /*#__PURE__*/ _jsx("th", {
+                                scope: "col",
+                                children: RESULTS_COPY.ci
+                            }),
+                            showAdjustedCI ? /*#__PURE__*/ _jsx("th", {
+                                scope: "col",
+                                children: RESULTS_COPY.adjustedCI
+                            }) : null,
+                            /*#__PURE__*/ _jsx("th", {
+                                scope: "col",
+                                children: sequential ? RESULTS_COPY.pValue : RESULTS_COPY.risk
+                            }),
+                            showAdjustedPValue ? /*#__PURE__*/ _jsx("th", {
+                                scope: "col",
+                                children: RESULTS_COPY.adjustedPValue
+                            }) : null,
+                            /*#__PURE__*/ _jsx("th", {
+                                scope: "col",
+                                children: RESULTS_COPY.comparison
+                            })
+                        ]
+                    })
+                }),
+                /*#__PURE__*/ _jsx("tbody", {
+                    children: rows.map((row)=>/*#__PURE__*/ _jsxs("tr", {
+                            children: [
+                                /*#__PURE__*/ _jsx("th", {
+                                    scope: "row",
+                                    children: row.label
+                                }),
+                                /*#__PURE__*/ _jsx("td", {
+                                    children: row.n
+                                }),
+                                /*#__PURE__*/ _jsx("td", {
+                                    children: metricKind === 'revenue' ? /*#__PURE__*/ _jsx(CappedCell, {
+                                        model: row.capped
+                                    }) : row.value
+                                }),
+                                row.baseline ? /*#__PURE__*/ _jsx("td", {
+                                    colSpan: columns,
+                                    children: row.baseline
+                                }) : /*#__PURE__*/ _jsxs(_Fragment, {
+                                    children: [
+                                        /*#__PURE__*/ _jsx("td", {
+                                            children: row.comparison?.method === 'sequential' ? row.comparison.lift : row.comparison?.chanceToWin ?? '—'
+                                        }),
+                                        /*#__PURE__*/ _jsx("td", {
+                                            children: row.comparison?.ci ?? '—'
+                                        }),
+                                        showAdjustedCI ? /*#__PURE__*/ _jsx("td", {
+                                            children: row.comparison?.method === 'sequential' ? row.comparison.adjustedCI ?? '—' : '—'
+                                        }) : null,
+                                        /*#__PURE__*/ _jsx("td", {
+                                            children: row.comparison?.method === 'sequential' ? row.comparison.pValue : row.comparison?.risk ?? '—'
+                                        }),
+                                        showAdjustedPValue ? /*#__PURE__*/ _jsx("td", {
+                                            children: row.comparison?.method === 'sequential' ? row.comparison.pValueAdjusted ?? '—' : '—'
+                                        }) : null,
+                                        /*#__PURE__*/ _jsx("td", {
+                                            children: row.comparison ? /*#__PURE__*/ _jsx("span", {
+                                                className: "xp-chip",
+                                                children: row.comparison.significance
+                                            }) : '—'
+                                        })
+                                    ]
+                                })
+                            ]
+                        }, row.key))
+                })
+            ]
+        })
+    });
+}

package/dist/admin/results/CappedCell.d.ts

@@ -0,0 +1,4 @@
+import type { CappedCellModel } from './results.model.js';
+export declare function CappedCell({ model }: {
+    model: CappedCellModel;
+}): import("react").JSX.Element;

package/dist/admin/results/CappedCell.js

@@ -0,0 +1,24 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function CappedCell({ model }) {
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "xp-capped-cell",
+        style: {
+            color: 'var(--theme-text)'
+        },
+        children: [
+            /*#__PURE__*/ _jsx("span", {
+                children: model.statistic
+            }),
+            model.totalLine ? /*#__PURE__*/ _jsx("div", {
+                children: model.totalLine
+            }) : null,
+            model.cappedLine ? /*#__PURE__*/ _jsx("div", {
+                children: model.cappedLine
+            }) : null,
+            model.notice ? /*#__PURE__*/ _jsx("p", {
+                children: model.notice
+            }) : null
+        ]
+    });
+}

package/dist/admin/results/CiChart.d.ts

@@ -0,0 +1,10 @@
+import type { DocId } from '../../types/contracts.js';
+import type { PhaseSummary, ResultsResponse } from '../../types/endpoints.js';
+import type { Snapshot } from '../../types/snapshot.js';
+export declare function CiChart({ series, metricId, metricName, phase, contentChanges }: {
+    series?: ResultsResponse['series'];
+    metricId: DocId;
+    metricName: string;
+    phase: PhaseSummary;
+    contentChanges?: Snapshot['contentChanges'];
+}): import("react").JSX.Element;