@jini-ai/admin 0.4.5 → 0.4.7

package/dist/forms/field-settings.d.ts

@@ -0,0 +1,142 @@
+import { type FieldType } from "@jini-ai/cms/forms";
+import type { AdminFormField } from "./models.js";
+/** Plain-language type names (translation keys). Exhaustive over the registry by type. */
+export declare const FIELD_TYPE_LABELS: Record<FieldType, string>;
+export type FieldBounds = "number" | "date" | "time" | "datetime-local";
+export type FieldDefaultKind = "text" | "textarea" | "number" | "temporal" | "boolean" | "choice" | "choices";
+/** Which builder settings apply to one field type. */
+export interface FieldSettings {
+    placeholder: boolean;
+    helpText: boolean;
+    length: boolean;
+    pattern: boolean;
+    /** Native input type for min/max, or `null` when the type has no bounds. */
+    bounds: FieldBounds | null;
+    step: boolean;
+    options: boolean;
+    multiple: boolean;
+    defaultKind: FieldDefaultKind | null;
+    upload: boolean;
+}
+/**
+ * Settings for one type, from its registry kind. Unknown (legacy or host-added) types get help
+ * text only, so the editor never offers a setting the server would refuse.
+ * @complexity O(1).
+ */
+export declare function fieldSettingsFor({ type }: {
+    type: string;
+}, _optional?: Record<string, never>): FieldSettings;
+export type FieldTypeGroup = "Text" | "Numbers and dates" | "Choices" | "Other";
+/**
+ * The type picker's `<optgroup>`s, in registry order within each group. A stored type the
+ * registry does not know is kept as its own trailing option so loading never changes it.
+ * @complexity O(t) in registered types.
+ */
+export declare function fieldTypeGroups({ current }: {
+    current?: string;
+}, _optional?: Record<string, never>): Array<{
+    group: FieldTypeGroup;
+    types: Array<{
+        type: string;
+        label: string;
+    }>;
+}>;
+/** Lowercase letters, digits and `_`, starting with a letter: the CMS `FIELD_ID_PATTERN`. */
+export declare function fieldIdFromLabel({ label }: {
+    label: string;
+}, _optional?: Record<string, never>): string;
+/**
+ * A label edit on an unsaved field also renames its id while the id still follows the label (empty
+ * or equal to the old label's slug). A hand-typed id, or any saved id, is never touched.
+ * @complexity O(n) in label length.
+ */
+export declare function labelChangePatch({ field, label, isExisting }: {
+    field: AdminFormField;
+    label: string;
+    isExisting: boolean;
+}, _optional?: Record<string, never>): Partial<AdminFormField>;
+/**
+ * Change a field's type, dropping every setting the new type does not support (the CMS refuses
+ * them) and seeding two options for a new choice field, which needs at least one.
+ * Identity, label, help text and styling always survive.
+ * @complexity O(1) apart from copying the option list.
+ */
+export declare function retypeField({ field, type }: {
+    field: AdminFormField;
+    type: AdminFormField["type"];
+}, _optional?: Record<string, never>): AdminFormField;
+export interface OptionRow {
+    _rowId: number;
+    value: string;
+    label: string;
+}
+/** String draft of every builder setting; numbers stay text until Save. */
+export interface FieldSettingsForm {
+    placeholder: string;
+    helpText: string;
+    defaultText: string;
+    defaultChecked: boolean;
+    defaultChoices: string[];
+    minLength: string;
+    maxLength: string;
+    pattern: string;
+    min: string;
+    max: string;
+    step: string;
+    options: OptionRow[];
+    accept: string[];
+    maxFileSizeMb: string;
+}
+/** Seed the draft from a stored field. @complexity O(o) in options. */
+export declare function settingsFormFromField({ field }: {
+    field: AdminFormField;
+}, _optional?: Record<string, never>): FieldSettingsForm;
+/**
+ * Edit one option row. A value that still mirrors its label follows label edits, so typing labels
+ * is enough for most forms; an edited value stays put.
+ * @complexity O(o).
+ */
+export declare function updateOptionRow({ rows, rowId, patch }: {
+    rows: OptionRow[];
+    rowId: number;
+    patch: Partial<Pick<OptionRow, "value" | "label">>;
+}, _optional?: Record<string, never>): OptionRow[];
+/** @complexity O(o). */
+export declare function addOptionRow({ rows }: {
+    rows: OptionRow[];
+}, _optional?: Record<string, never>): OptionRow[];
+/** @complexity O(o). */
+export declare function removeOptionRow({ rows, rowId }: {
+    rows: OptionRow[];
+    rowId: number;
+}, _optional?: Record<string, never>): OptionRow[];
+/** Swap a row with its neighbour; moving past either end is a no-op. @complexity O(o). */
+export declare function moveOptionRow({ rows, rowId, offset }: {
+    rows: OptionRow[];
+    rowId: number;
+    offset: -1 | 1;
+}, _optional?: Record<string, never>): OptionRow[];
+/** Upload groups offered as checkboxes; values are accept entries the CMS recognizes. */
+export declare const UPLOAD_CHOICES: {
+    value: string;
+    label: string;
+}[];
+export declare const MAX_UPLOAD_MB: number;
+export type FieldSettingsPatchResult = {
+    ok: true;
+    patch: Partial<AdminFormField>;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Parse and check the dialog draft into a field patch. Settings the type does not support come out
+ * `undefined`, so Save also clears anything stale. Max length instead uses `null` when blank and
+ * is omitted for unsupported types; `retypeField` already drops it on a type change. First failure wins.
+ * @complexity O(o) in options.
+ */
+export declare function buildFieldSettingsPatch({ form, field }: {
+    form: FieldSettingsForm;
+    field: Pick<AdminFormField, "type" | "checkboxValue">;
+}, _optional?: Record<string, never>): FieldSettingsPatchResult;
+//# sourceMappingURL=field-settings.d.ts.map

package/dist/forms/field-settings.js

@@ -0,0 +1,327 @@
+import { FIELD_TYPE_REGISTRY, isBrowserSafeFieldPattern, MAX_FORM_FILE_BYTES, SAFE_FORM_FILE_TYPES } from "@jini-ai/cms/forms";
+const kindOf = (type) => Object.hasOwn(FIELD_TYPE_REGISTRY, type) ? FIELD_TYPE_REGISTRY[type] : undefined;
+/** Plain-language type names (translation keys). Exhaustive over the registry by type. */
+export const FIELD_TYPE_LABELS = {
+    text: "Short text", textarea: "Paragraph", email: "Email", phone: "Phone", url: "Website address",
+    number: "Number", range: "Slider", date: "Date", time: "Time", datetime: "Date and time",
+    select: "Dropdown", "multi-select": "Multi-select list", radio: "Radio buttons", checkbox: "Checkbox",
+    "checkbox-group": "Checkboxes", toggle: "Toggle switch", file: "File upload", hidden: "Hidden value",
+};
+const NO_SETTINGS = { placeholder: false, helpText: true, length: false, pattern: false, bounds: null, step: false, options: false, multiple: false, defaultKind: null, upload: false };
+const BOUNDS = new Set(["number", "range", "date", "time", "datetime-local"]);
+/** The default value a control can carry, read from its registry kind. */
+function defaultKindOf(kind) {
+    if (kind.choices)
+        return kind.multiple ? "choices" : "choice";
+    if (kind.htmlType === "file")
+        return null;
+    if (kind.htmlType === "checkbox")
+        return "boolean";
+    if (kind.htmlType === "number" || kind.htmlType === "range")
+        return "number";
+    if (BOUNDS.has(kind.htmlType))
+        return "temporal";
+    return kind.control === "textarea" ? "textarea" : "text";
+}
+/**
+ * Settings for one type, from its registry kind. Unknown (legacy or host-added) types get help
+ * text only, so the editor never offers a setting the server would refuse.
+ * @complexity O(1).
+ */
+export function fieldSettingsFor({ type }, _optional = {}) {
+    const kind = kindOf(type);
+    if (!kind)
+        return NO_SETTINGS;
+    const hidden = kind.htmlType === "hidden";
+    const numeric = kind.htmlType === "number" || kind.htmlType === "range";
+    const bounds = BOUNDS.has(kind.htmlType) ? (numeric ? "number" : kind.htmlType) : null;
+    return {
+        // A single-choice select shows its placeholder as the empty first option.
+        placeholder: !hidden && ((kind.textual === true && kind.control !== "select") || kind.htmlType === "number" || (kind.control === "select" && !kind.multiple)),
+        helpText: !hidden,
+        length: kind.textual === true,
+        pattern: kind.textual === true && !hidden,
+        bounds,
+        step: numeric,
+        options: kind.choices === true,
+        multiple: kind.multiple === true,
+        defaultKind: defaultKindOf(kind),
+        upload: kind.htmlType === "file",
+    };
+}
+const GROUP_ORDER = ["Text", "Choices", "Numbers and dates", "Other"];
+function groupOf(type) {
+    const settings = fieldSettingsFor({ type });
+    if (settings.options || settings.defaultKind === "boolean")
+        return "Choices";
+    if (settings.bounds)
+        return "Numbers and dates";
+    if (settings.length && settings.helpText)
+        return "Text";
+    return "Other";
+}
+/**
+ * The type picker's `<optgroup>`s, in registry order within each group. A stored type the
+ * registry does not know is kept as its own trailing option so loading never changes it.
+ * @complexity O(t) in registered types.
+ */
+export function fieldTypeGroups({ current }, _optional = {}) {
+    const types = Object.keys(FIELD_TYPE_REGISTRY);
+    const groups = GROUP_ORDER.map((group) => ({ group, types: types.filter((type) => groupOf(type) === group).map((type) => ({ type, label: FIELD_TYPE_LABELS[type] })) }));
+    if (current && !kindOf(current))
+        groups[groups.length - 1].types.push({ type: current, label: current });
+    return groups.filter((entry) => entry.types.length > 0);
+}
+/** Lowercase letters, digits and `_`, starting with a letter: the CMS `FIELD_ID_PATTERN`. */
+export function fieldIdFromLabel({ label }, _optional = {}) {
+    const slug = label.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 60);
+    return slug === "" ? "" : /^[a-z]/.test(slug) ? slug : `field_${slug}`;
+}
+/**
+ * A label edit on an unsaved field also renames its id while the id still follows the label (empty
+ * or equal to the old label's slug). A hand-typed id, or any saved id, is never touched.
+ * @complexity O(n) in label length.
+ */
+export function labelChangePatch({ field, label, isExisting }, _optional = {}) {
+    const followsLabel = field.id === "" || field.id === fieldIdFromLabel({ label: field.label });
+    return !isExisting && followsLabel ? { label, id: fieldIdFromLabel({ label }) } : { label };
+}
+const SEED_OPTIONS = [{ value: "Option 1", label: "Option 1" }, { value: "Option 2", label: "Option 2" }];
+/**
+ * Change a field's type, dropping every setting the new type does not support (the CMS refuses
+ * them) and seeding two options for a new choice field, which needs at least one.
+ * Identity, label, help text and styling always survive.
+ * @complexity O(1) apart from copying the option list.
+ */
+export function retypeField({ field, type }, _optional = {}) {
+    const before = fieldSettingsFor({ type: field.type });
+    const after = fieldSettingsFor({ type });
+    const next = { id: field.id, label: field.label, type, required: after.helpText ? field.required : false };
+    if (after.helpText && field.helpText !== undefined)
+        next.helpText = field.helpText;
+    if (field.className !== undefined)
+        next.className = field.className;
+    if (field.attributes !== undefined)
+        next.attributes = { ...field.attributes };
+    if (after.placeholder && field.placeholder !== undefined)
+        next.placeholder = field.placeholder;
+    if (after.length) {
+        if (field.maxLength != null)
+            next.maxLength = field.maxLength;
+        if (field.minLength !== undefined)
+            next.minLength = field.minLength;
+    }
+    if (after.pattern && field.pattern !== undefined)
+        next.pattern = field.pattern;
+    if (after.bounds && after.bounds === before.bounds) {
+        if (field.min !== undefined)
+            next.min = field.min;
+        if (field.max !== undefined)
+            next.max = field.max;
+    }
+    if (after.step && field.step !== undefined)
+        next.step = field.step;
+    if (after.options)
+        next.options = field.options?.length ? field.options.map((option) => ({ ...option })) : SEED_OPTIONS.map((option) => ({ ...option }));
+    if (after.upload) {
+        if (field.accept !== undefined)
+            next.accept = [...field.accept];
+        if (field.maxFileSize !== undefined)
+            next.maxFileSize = field.maxFileSize;
+    }
+    // A default only survives when its shape is unchanged (text to text, one choice to one choice).
+    if (field.default !== undefined && after.defaultKind !== null && after.defaultKind === before.defaultKind && after.bounds === before.bounds)
+        next.default = field.default;
+    return next;
+}
+/** Local React keys for option rows; same module-counter pattern as `rules.ts`'s attribute rows. */
+let nextOptionRowId = 0;
+const text = (value) => (value === undefined || value === null ? "" : String(value));
+/** Seed the draft from a stored field. @complexity O(o) in options. */
+export function settingsFormFromField({ field }, _optional = {}) {
+    const defaults = field.default;
+    return {
+        placeholder: text(field.placeholder), helpText: text(field.helpText),
+        defaultText: typeof defaults === "boolean" || Array.isArray(defaults) ? "" : text(defaults),
+        defaultChecked: defaults === true || (field.checkboxValue !== undefined && defaults === field.checkboxValue),
+        defaultChoices: Array.isArray(defaults) ? [...defaults] : typeof defaults === "string" && fieldSettingsFor({ type: field.type }).options ? [defaults] : [],
+        minLength: text(field.minLength), maxLength: text(field.maxLength), pattern: text(field.pattern),
+        min: text(field.min), max: text(field.max), step: text(field.step),
+        options: (field.options ?? []).map((option) => ({ _rowId: nextOptionRowId++, value: option.value, label: option.label })),
+        accept: [...(field.accept ?? [])],
+        maxFileSizeMb: field.maxFileSize === undefined ? "" : String(Math.round((field.maxFileSize / 1024 / 1024) * 100) / 100),
+    };
+}
+/**
+ * Edit one option row. A value that still mirrors its label follows label edits, so typing labels
+ * is enough for most forms; an edited value stays put.
+ * @complexity O(o).
+ */
+export function updateOptionRow({ rows, rowId, patch }, _optional = {}) {
+    return rows.map((row) => {
+        if (row._rowId !== rowId)
+            return row;
+        const followsLabel = patch.label !== undefined && patch.value === undefined && row.value === row.label;
+        return { ...row, ...patch, ...(followsLabel ? { value: patch.label } : {}) };
+    });
+}
+/** @complexity O(o). */
+export function addOptionRow({ rows }, _optional = {}) {
+    return [...rows, { _rowId: nextOptionRowId++, value: "", label: "" }];
+}
+/** @complexity O(o). */
+export function removeOptionRow({ rows, rowId }, _optional = {}) {
+    return rows.filter((row) => row._rowId !== rowId);
+}
+/** Swap a row with its neighbour; moving past either end is a no-op. @complexity O(o). */
+export function moveOptionRow({ rows, rowId, offset }, _optional = {}) {
+    const from = rows.findIndex((row) => row._rowId === rowId);
+    const to = from + offset;
+    if (from < 0 || to < 0 || to >= rows.length)
+        return rows;
+    const next = [...rows];
+    [next[from], next[to]] = [next[to], next[from]];
+    return next;
+}
+/** Upload groups offered as checkboxes; values are accept entries the CMS recognizes. */
+// The CMS widens `image/*`/`video/*` to its safe formats only; PDF is its one safe document type.
+export const UPLOAD_CHOICES = [
+    { value: "image/*", label: "Images" },
+    { value: "video/*", label: "Videos" },
+    ...(Object.hasOwn(SAFE_FORM_FILE_TYPES, "application/pdf") ? [{ value: "application/pdf", label: "PDF" }] : []),
+];
+export const MAX_UPLOAD_MB = MAX_FORM_FILE_BYTES / 1024 / 1024;
+const isBlank = (value) => value.trim() === "";
+function optionalNumber(value, error, { integer = false } = {}) {
+    if (isBlank(value))
+        return { ok: true, value: undefined };
+    const number = Number(value);
+    return Number.isFinite(number) && (!integer || (Number.isInteger(number) && number >= 0)) ? { ok: true, value: number } : { ok: false, error };
+}
+/** Text length, pattern and placeholder settings. */
+function textPatch(form, settings) {
+    const patch = { placeholder: settings.placeholder && !isBlank(form.placeholder) ? form.placeholder : undefined, pattern: undefined, minLength: undefined };
+    if (settings.length) {
+        const min = optionalNumber(form.minLength, "Length must be a whole number.", { integer: true });
+        const max = optionalNumber(form.maxLength, "Length must be a whole number.", { integer: true });
+        if (!min.ok)
+            return min;
+        if (!max.ok)
+            return max;
+        if (min.value !== undefined && max.value !== undefined && min.value > max.value)
+            return { ok: false, error: "Minimum must not be above maximum." };
+        patch.minLength = min.value;
+        // The wire contract clears a text length with null; unsupported types omit the key entirely.
+        patch.maxLength = max.value ?? null;
+    }
+    if (settings.pattern && !isBlank(form.pattern)) {
+        // Browser-safe too: a `v`-flag-invalid pattern is silently ignored by browsers (2026-10-11).
+        if (!isBrowserSafeFieldPattern({ pattern: form.pattern }))
+            return { ok: false, error: "That pattern isn't supported." };
+        patch.pattern = form.pattern;
+    }
+    return { ok: true, value: patch };
+}
+/** Numeric or date/time bounds, plus a numeric step. Native date/time strings compare as text. */
+function boundsPatch(form, settings) {
+    const patch = { min: undefined, max: undefined, step: undefined };
+    if (settings.bounds === "number") {
+        const min = optionalNumber(form.min, "Enter numbers for min, max and step.");
+        const max = optionalNumber(form.max, "Enter numbers for min, max and step.");
+        const step = optionalNumber(form.step, "Enter numbers for min, max and step.");
+        if (!min.ok)
+            return min;
+        if (!max.ok)
+            return max;
+        if (!step.ok)
+            return step;
+        if (step.value !== undefined && step.value <= 0)
+            return { ok: false, error: "Step must be above 0." };
+        if (min.value !== undefined && max.value !== undefined && min.value > max.value)
+            return { ok: false, error: "Minimum must not be above maximum." };
+        return { ok: true, value: { min: min.value, max: max.value, step: step.value } };
+    }
+    if (settings.bounds) {
+        const min = isBlank(form.min) ? undefined : form.min;
+        const max = isBlank(form.max) ? undefined : form.max;
+        if (min !== undefined && max !== undefined && min > max)
+            return { ok: false, error: "Minimum must not be above maximum." };
+        return { ok: true, value: { min, max } };
+    }
+    return { ok: true, value: patch };
+}
+/** Choice options: blank rows are skipped; the rest need a label and a unique value. */
+function optionsPatch(form, settings) {
+    if (!settings.options)
+        return { ok: true, value: undefined };
+    const options = form.options.filter((row) => !(isBlank(row.value) && isBlank(row.label))).map((row) => ({ value: row.value.trim(), label: row.label.trim() }));
+    if (options.length === 0)
+        return { ok: false, error: "Add at least one option." };
+    if (options.some((option) => !option.value || !option.label) || new Set(options.map((option) => option.value)).size !== options.length) {
+        return { ok: false, error: "Each option needs a label and a unique value." };
+    }
+    return { ok: true, value: options };
+}
+/** The default in the stored shape for its kind; choices drop values no longer offered. */
+function defaultValue(form, settings, { options, checkboxValue }) {
+    const offered = new Set((options ?? []).map((option) => option.value));
+    switch (settings.defaultKind) {
+        // A box with an authored value submits that value, so its "checked" default is that value too.
+        case "boolean": return { ok: true, value: form.defaultChecked ? checkboxValue ?? true : undefined };
+        case "choice": return { ok: true, value: form.defaultChoices.find((value) => offered.has(value)) };
+        case "choices": {
+            const chosen = form.defaultChoices.filter((value) => offered.has(value));
+            return { ok: true, value: chosen.length ? chosen : undefined };
+        }
+        case "number": return optionalNumber(form.defaultText, "Default must be a number.");
+        case "text":
+        case "textarea":
+        case "temporal": return { ok: true, value: isBlank(form.defaultText) ? undefined : form.defaultText };
+        default: return { ok: true, value: undefined };
+    }
+}
+/** Upload limits: no boxes ticked means every safe type; size is whole megabytes up to the cap. */
+function uploadPatch(form, settings) {
+    if (!settings.upload)
+        return { ok: true, value: {} };
+    const size = optionalNumber(form.maxFileSizeMb, "Max size must be up to 10 MB.");
+    if (!size.ok)
+        return size;
+    if (size.value !== undefined && (size.value <= 0 || size.value > MAX_UPLOAD_MB))
+        return { ok: false, error: "Max size must be up to 10 MB." };
+    return { ok: true, value: {
+            accept: form.accept.length ? [...form.accept] : undefined,
+            maxFileSize: size.value === undefined ? undefined : Math.min(MAX_FORM_FILE_BYTES, Math.max(1, Math.round(size.value * 1024 * 1024))),
+        } };
+}
+/**
+ * Parse and check the dialog draft into a field patch. Settings the type does not support come out
+ * `undefined`, so Save also clears anything stale. Max length instead uses `null` when blank and
+ * is omitted for unsupported types; `retypeField` already drops it on a type change. First failure wins.
+ * @complexity O(o) in options.
+ */
+export function buildFieldSettingsPatch({ form, field }, _optional = {}) {
+    const settings = fieldSettingsFor({ type: field.type });
+    const textual = textPatch(form, settings);
+    if (!textual.ok)
+        return textual;
+    const bounds = boundsPatch(form, settings);
+    if (!bounds.ok)
+        return bounds;
+    const options = optionsPatch(form, settings);
+    if (!options.ok)
+        return options;
+    const fallback = defaultValue(form, settings, { options: options.value, checkboxValue: field.checkboxValue });
+    if (!fallback.ok)
+        return fallback;
+    const upload = uploadPatch(form, settings);
+    if (!upload.ok)
+        return upload;
+    return { ok: true, patch: {
+            ...textual.value, ...bounds.value, ...upload.value,
+            helpText: settings.helpText && !isBlank(form.helpText) ? form.helpText : undefined,
+            options: options.value,
+            default: fallback.value,
+        } };
+}
+//# sourceMappingURL=field-settings.js.map

package/dist/forms/form-editor-dirty.d.ts

@@ -0,0 +1,42 @@
+import type { AdminFormDefinition, AdminFormField } from "./models.js";
+/**
+ * @file What "unsaved" means on the form editor, so Back can warn before it discards edits.
+ *
+ * Back used to discard an edited, unsaved form silently (Chrome check, 2026-10-11). The editor
+ * feeds these two drafts to `useDirtyGuard` (the post and widget editors' guard): it warns on
+ * reload/close, and its `isDirty` gates the in-app confirm modal on Back.
+ */
+/** The parts of the editor a Save writes. `notify` has no UI here, so it is never a pending edit. */
+export interface FormEditorDraft {
+    name: string;
+    slug: string;
+    fields: AdminFormField[];
+    mode: "builder" | "html";
+    /** Only counted in HTML mode: a Builder save never sends it, so a starter left behind by a
+     *  Builder → HTML → Builder round trip is not an edit. */
+    html: string;
+}
+/**
+ * @param input The live editor values.
+ * @returns The comparable draft.
+ * @complexity O(1).
+ */
+export declare function formEditorDraft(input: {
+    name: string;
+    slug: string;
+    fields: AdminFormField[];
+    mode: "builder" | "html";
+    html: string;
+}): FormEditorDraft;
+/**
+ * The draft the editor started from: the loaded form, or the blank new-form state.
+ * @param input.form The loaded form; `null` until it loads.
+ * @param input.isNew Whether this is the "new form" screen.
+ * @returns `null` while an existing form is still loading — nothing to lose yet, so never dirty.
+ * @complexity O(1).
+ */
+export declare function formEditorBaseline(input: {
+    form: AdminFormDefinition | null;
+    isNew: boolean;
+}): FormEditorDraft | null;
+//# sourceMappingURL=form-editor-dirty.d.ts.map

package/dist/forms/form-editor-dirty.js

@@ -0,0 +1,25 @@
+import { blankField } from "./rules.js";
+/**
+ * @param input The live editor values.
+ * @returns The comparable draft.
+ * @complexity O(1).
+ */
+export function formEditorDraft(input) {
+    return { name: input.name, slug: input.slug, fields: input.fields, mode: input.mode, html: input.mode === "html" ? input.html : "" };
+}
+/**
+ * The draft the editor started from: the loaded form, or the blank new-form state.
+ * @param input.form The loaded form; `null` until it loads.
+ * @param input.isNew Whether this is the "new form" screen.
+ * @returns `null` while an existing form is still loading — nothing to lose yet, so never dirty.
+ * @complexity O(1).
+ */
+export function formEditorBaseline(input) {
+    if (input.isNew)
+        return formEditorDraft({ name: "", slug: "", fields: [blankField()], mode: "builder", html: "" });
+    if (!input.form)
+        return null;
+    const mode = input.form.mode ?? "builder";
+    return formEditorDraft({ name: input.form.name, slug: input.form.slug, fields: input.form.fields, mode, html: input.form.html ?? "" });
+}
+//# sourceMappingURL=form-editor-dirty.js.map

package/dist/forms/forms.module.d.ts

@@ -68,6 +68,8 @@ export declare const formsModule: {
         readonly "Load more": "Load more";
         readonly "Loading\u2026": "Loading…";
         readonly "No submissions yet.": "No submissions yet.";
+        readonly Yes: "Yes";
+        readonly No: "No";
         readonly "Create form": "Create form";
         readonly Form: "Form";
         readonly "Configure a new form's fields.": "Configure a new form's fields.";
@@ -104,6 +106,76 @@ export declare const formsModule: {
         readonly "failed to load submission": "failed to load submission";
         readonly "delete failed": "delete failed";
         readonly "Unknown field": "Unknown field";
+        readonly "Short text": "Short text";
+        readonly Paragraph: "Paragraph";
+        readonly Email: "Email";
+        readonly Phone: "Phone";
+        readonly "Website address": "Website address";
+        readonly Number: "Number";
+        readonly Slider: "Slider";
+        readonly Date: "Date";
+        readonly Time: "Time";
+        readonly "Date and time": "Date and time";
+        readonly Dropdown: "Dropdown";
+        readonly "Multi-select list": "Multi-select list";
+        readonly "Radio buttons": "Radio buttons";
+        readonly Checkbox: "Checkbox";
+        readonly Checkboxes: "Checkboxes";
+        readonly "Toggle switch": "Toggle switch";
+        readonly "File upload": "File upload";
+        readonly "Hidden value": "Hidden value";
+        readonly Text: "Text";
+        readonly Choices: "Choices";
+        readonly "Numbers and dates": "Numbers and dates";
+        readonly Other: "Other";
+        readonly "Field settings \u2014": "Field settings —";
+        readonly "Settings for field \"{name}\"": "Settings for field \"{name}\"";
+        readonly "CSS classes and HTML attributes": "CSS classes and HTML attributes";
+        readonly Required: "Required";
+        readonly Settings: "Settings";
+        readonly Placeholder: "Placeholder";
+        readonly "Help text": "Help text";
+        readonly "Shown under the field and read out by screen readers.": "Shown under the field and read out by screen readers.";
+        readonly Options: "Options";
+        readonly "The label is what visitors see. The value is what the submission stores; it follows the label until you edit it.": "The label is what visitors see. The value is what the submission stores; it follows the label until you edit it.";
+        readonly "Option {n} label": "Option {n} label";
+        readonly "Option {n} value": "Option {n} value";
+        readonly "Option {n} selected by default": "Option {n} selected by default";
+        readonly "Move option {n} up": "Move option {n} up";
+        readonly "Move option {n} down": "Move option {n} down";
+        readonly "Remove option {n}": "Remove option {n}";
+        readonly "Add option": "Add option";
+        readonly Default: "Default";
+        readonly "Checked by default": "Checked by default";
+        readonly None: "None";
+        readonly Length: "Length";
+        readonly "Min length": "Min length";
+        readonly Min: "Min";
+        readonly Max: "Max";
+        readonly Pattern: "Pattern";
+        readonly "Optional. The whole answer must match it, e.g. [0-9]+ for digits only. Groups, | and repeating more than once are not supported.": "Optional. The whole answer must match it, e.g. [0-9]+ for digits only. Groups, | and repeating more than once are not supported.";
+        readonly Range: "Range";
+        readonly Step: "Step";
+        readonly Files: "Files";
+        readonly "Leave all unticked to accept every safe type: images, video and PDF.": "Leave all unticked to accept every safe type: images, video and PDF.";
+        readonly Images: "Images";
+        readonly Videos: "Videos";
+        readonly PDF: "PDF";
+        readonly "Max size (MB)": "Max size (MB)";
+        readonly "Length must be a whole number.": "Length must be a whole number.";
+        readonly "Minimum must not be above maximum.": "Minimum must not be above maximum.";
+        readonly "That pattern isn't supported.": "That pattern isn't supported.";
+        readonly "Enter numbers for min, max and step.": "Enter numbers for min, max and step.";
+        readonly "Step must be above 0.": "Step must be above 0.";
+        readonly "Add at least one option.": "Add at least one option.";
+        readonly "Each option needs a label and a unique value.": "Each option needs a label and a unique value.";
+        readonly "Default must be a number.": "Default must be a number.";
+        readonly "Max size must be up to 10 MB.": "Max size must be up to 10 MB.";
+        readonly "Discard unsaved changes?": "Discard unsaved changes?";
+        readonly "Your changes to this form have not been saved.": "Your changes to this form have not been saved.";
+        readonly "Discard changes": "Discard changes";
+        readonly "Keep editing": "Keep editing";
+        readonly "Classes are unrestricted, e.g. Tailwind md:col-span-2. Attribute names must be aria-*, data-* or a safe layout attribute; event handlers like onclick are rejected.": "Classes are unrestricted, e.g. Tailwind md:col-span-2. Attribute names must be aria-*, data-* or a safe layout attribute; event handlers like onclick are rejected.";
     };
     readonly pages: {
         readonly list: {