@phis/ui 0.2.1 → 0.4.0

package/components/forms/compound-form-controls.js

@@ -1,16 +1,18 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPhiRecord } from "../../helpers/is-record";
 import { useMemo, useRef, useState } from "react";
-import { DeleteOutlined, PlusOutlined } from "@ant-design/icons";
 import { PhiTableControl, } from "../controls/phi-table-control";
 import { PhiTreeControl } from "../controls/phi-tree-control";
 import { PhiButtonControl } from "../controls/phi-button-control";
 import { PhiCollectionHeaderControl } from "../controls/phi-collection-header-control";
 import { PhiToolbarControl } from "../controls/phi-toolbar-control";
 import { readPhiDotPath as readPath } from "../../helpers/dot-path";
+import { movePhiTableBindingRows } from "../../helpers/table-binding";
+import { PhiIcon } from "../shell/phi-icon";
 function readRecords(value) {
     return Array.isArray(value)
-        ? value.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)).map((entry) => ({ ...entry }))
+        ? value.filter((entry) => isPhiRecord(entry)).map((entry) => ({ ...entry }))
         : [];
 }
 function setPath(record, path, value) {
@@ -21,7 +23,7 @@ function setPath(record, path, value) {
     let cursor = next;
     for (const segment of segments.slice(0, -1)) {
         const child = cursor[segment];
-        const cloned = child && typeof child === "object" && !Array.isArray(child) ? { ...child } : {};
+        const cloned = isPhiRecord(child) ? { ...child } : {};
         cursor[segment] = cloned;
         cursor = cloned;
     }
@@ -32,7 +34,7 @@ function readControlOptions(value) {
     if (!Array.isArray(value))
         return undefined;
     const options = value.flatMap((entry) => {
-        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        if (!isPhiRecord(entry))
             return [];
         const option = entry;
         if (typeof option.value !== "string" && typeof option.value !== "number")
@@ -47,7 +49,7 @@ function readControlOptions(value) {
     return options.length === 0 ? undefined : options;
 }
 function readTableCellEditor(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
+    if (!isPhiRecord(value))
         return undefined;
     const editor = value;
     const type = editor.type;
@@ -61,7 +63,7 @@ function readTableCellEditor(value) {
         type !== "date" &&
         type !== "datetime")
         return undefined;
-    const constraints = editor.constraints && typeof editor.constraints === "object" && !Array.isArray(editor.constraints)
+    const constraints = isPhiRecord(editor.constraints)
         ? editor.constraints
         : null;
     return {
@@ -94,19 +96,18 @@ function readTableCellEditor(value) {
 }
 function applyMove(rows, identityPath, parentPath, move) {
     const movedIdentity = "movedRowIdentity" in move ? move.movedRowIdentity : move.movedNodeIdentity;
-    const movedIndex = rows.findIndex((row) => String(readPath(row, identityPath)) === String(movedIdentity));
-    if (movedIndex < 0)
-        return rows;
-    const [moved] = rows.splice(movedIndex, 1);
     const parentIdentity = "targetParentRowIdentity" in move ? move.targetParentRowIdentity : move.targetParentNodeIdentity;
-    const beforeIdentity = "beforeRowIdentity" in move ? move.beforeRowIdentity : move.beforeNodeIdentity;
-    const afterIdentity = "afterRowIdentity" in move ? move.afterRowIdentity : move.afterNodeIdentity;
-    const nextMoved = parentPath ? setPath(moved, parentPath, parentIdentity) : moved;
-    const anchorIdentity = beforeIdentity ?? afterIdentity;
-    const anchorIndex = anchorIdentity == null ? -1 : rows.findIndex((row) => String(readPath(row, identityPath)) === String(anchorIdentity));
-    const insertionIndex = anchorIndex < 0 ? rows.length : anchorIndex + (afterIdentity == null ? 0 : 1);
-    rows.splice(insertionIndex, 0, nextMoved);
-    return rows;
+    // One placement rule for Tables and Trees: the row before which it lands wins, else just after the other.
+    const moved = movePhiTableBindingRows(rows, identityPath, {
+        movedRowIdentity: movedIdentity,
+        beforeRowIdentity: "beforeRowIdentity" in move ? move.beforeRowIdentity : move.beforeNodeIdentity,
+        afterRowIdentity: "afterRowIdentity" in move ? move.afterRowIdentity : move.afterNodeIdentity,
+    });
+    if (!parentPath)
+        return moved;
+    return moved.map((row) => String(readPath(row, identityPath)) === String(movedIdentity)
+        ? setPath(row, parentPath, parentIdentity)
+        : row);
 }
 export function PhiCompoundTableFormControl({ field, label, description, value, onChange, disabled, readOnly, formContext, }) {
     const rows = useMemo(() => readRecords(value), [value]);
@@ -114,25 +115,25 @@ export function PhiCompoundTableFormControl({ field, label, description, value,
     const config = field.config ?? {};
     const identityPath = typeof config.rowIdentityPath === "string" ? config.rowIdentityPath : "id";
     const locked = disabled === true || readOnly === true;
-    const addConfig = config.add && typeof config.add === "object" && !Array.isArray(config.add)
+    const addConfig = isPhiRecord(config.add)
         ? config.add
         : null;
-    const removeConfig = config.remove && typeof config.remove === "object" && !Array.isArray(config.remove)
+    const removeConfig = isPhiRecord(config.remove)
         ? config.remove
         : null;
     const addEnabled = addConfig?.enabled === true;
     const removeEnabled = removeConfig?.enabled === true;
     const addLabel = typeof addConfig?.label === "string" ? addConfig.label : "Add";
     const removeLabel = typeof removeConfig?.label === "string" ? removeConfig.label : "Remove";
-    const addSourceFields = addConfig?.sourceFields && typeof addConfig.sourceFields === "object" && !Array.isArray(addConfig.sourceFields)
+    const addSourceFields = isPhiRecord(addConfig?.sourceFields)
         ? addConfig.sourceFields
         : null;
-    const addResetFields = addConfig?.resetFields && typeof addConfig.resetFields === "object" && !Array.isArray(addConfig.resetFields)
+    const addResetFields = isPhiRecord(addConfig?.resetFields)
         ? addConfig.resetFields
         : null;
     const rawColumns = useMemo(() => Array.isArray(config.columns) ? config.columns : [], [config.columns]);
     const columns = useMemo(() => rawColumns.flatMap((entry) => {
-        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        if (!isPhiRecord(entry))
             return [];
         const column = entry;
         const key = typeof column.key === "string" ? column.key : "";
@@ -162,13 +163,13 @@ export function PhiCompoundTableFormControl({ field, label, description, value,
         fieldPath: identityPath,
         fixed: "right",
         sizing: { mode: "content" },
-        render: (identity) => (_jsx(PhiButtonControl, { ariaLabel: removeLabel, tooltip: removeLabel, icon: _jsx(DeleteOutlined, {}), type: "text", danger: true, size: "small", disabled: locked, onClick: () => onChange?.(rows.filter((row) => String(readPath(row, identityPath)) !== String(identity))) })),
+        render: (identity) => (_jsx(PhiButtonControl, { ariaLabel: removeLabel, tooltip: removeLabel, icon: _jsx(PhiIcon, { name: "delete", size: "inherit" }), type: "text", danger: true, size: "small", disabled: locked, onClick: () => onChange?.(rows.filter((row) => String(readPath(row, identityPath)) !== String(identity))) })),
     } : null, [identityPath, locked, onChange, removeEnabled, removeLabel, rows]);
     const renderedColumns = actionColumn == null ? columns : [...columns, actionColumn];
     const columnOrder = renderedColumns.map((column) => column.key);
     const layout = (config.layout && typeof config.layout === "object" ? config.layout : { mode: "auto", overflowX: "auto" });
     const appendRow = () => {
-        let defaultRow = addConfig?.defaultRow && typeof addConfig.defaultRow === "object" && !Array.isArray(addConfig.defaultRow)
+        let defaultRow = isPhiRecord(addConfig?.defaultRow)
             ? { ...addConfig.defaultRow }
             : {};
         const formValues = formContext?.getValues() ?? {};
@@ -190,12 +191,12 @@ export function PhiCompoundTableFormControl({ field, label, description, value,
                             label: addLabel,
                             ariaLabel: addLabel,
                             tooltip: addLabel,
-                            icon: _jsx(PlusOutlined, {}),
+                            icon: _jsx(PhiIcon, { name: "plus", size: "inherit" }),
                             type: "primary",
                         }], compact: true, showLabels: true, size: "small", disabled: locked, onActivate: (key) => { if (key === "add")
                         appendRow(); } })) : null }), _jsx(PhiTableControl, { rows: rows, rowIdentityPath: identityPath, columns: renderedColumns, columnOrder: columnOrder, sortingMode: "none", sorts: [], bordered: config.bordered === true, striped: config.striped === true, size: "small", emptyText: typeof config.emptyText === "string" ? config.emptyText : undefined, layout: layout, rowReordering: config.reorder === true && !locked ? {
                     enabled: true,
-                    onMove: (move) => onChange?.(applyMove([...rows], identityPath, typeof config.parentRowIdentityPath === "string" ? config.parentRowIdentityPath : null, move)),
+                    onMove: (move) => onChange?.(applyMove(rows, identityPath, typeof config.parentRowIdentityPath === "string" ? config.parentRowIdentityPath : null, move)),
                 } : undefined })] }));
 }
 export function PhiCompoundTreeFormControl({ field, label, description, value, onChange, disabled, readOnly }) {
@@ -210,5 +211,5 @@ export function PhiCompoundTreeFormControl({ field, label, description, value, o
         blockNode: true,
         node: { titleFieldKey: typeof config.titleFieldKey === "string" ? config.titleFieldKey : "title" },
     });
-    return (_jsxs("div", { "data-phi-form-keyboard-scope": true, style: { display: "grid", gap: "var(--ant-padding-sm)", minWidth: 0, width: "100%" }, children: [_jsx(PhiCollectionHeaderControl, { title: label, description: description }), _jsx(PhiTreeControl, { nodes: nodes, nodeIdentityPath: identityPath, parentNodeIdentityPath: parentPath, presentation: presentation, disabled: disabled || readOnly, selectedNodeIdentities: selected, checkedNodeIdentities: checked, expandedNodeIdentities: expanded, selectionMode: config.selectionMode === "multiple" ? "multiple" : config.selectionMode === "none" ? "none" : "single", checking: config.checking === true, editing: config.editing === true && !disabled && !readOnly, draggable: config.reorder === true && !disabled && !readOnly, onSelectionChange: setSelected, onCheckingChange: setChecked, onExpansionChange: setExpanded, onCommitField: (identity, fieldKey, proposed) => onChange?.(nodes.map((node) => String(readPath(node, identityPath)) === String(identity) ? setPath(node, fieldKey, proposed) : node)), onDrop: (move) => onChange?.(applyMove([...nodes], identityPath, parentPath, move)) })] }));
+    return (_jsxs("div", { "data-phi-form-keyboard-scope": true, style: { display: "grid", gap: "var(--ant-padding-sm)", minWidth: 0, width: "100%" }, children: [_jsx(PhiCollectionHeaderControl, { title: label, description: description }), _jsx(PhiTreeControl, { nodes: nodes, nodeIdentityPath: identityPath, parentNodeIdentityPath: parentPath, presentation: presentation, disabled: disabled || readOnly, selectedNodeIdentities: selected, checkedNodeIdentities: checked, expandedNodeIdentities: expanded, selectionMode: config.selectionMode === "multiple" ? "multiple" : config.selectionMode === "none" ? "none" : "single", checking: config.checking === true, editing: config.editing === true && !disabled && !readOnly, draggable: config.reorder === true && !disabled && !readOnly, onSelectionChange: setSelected, onCheckingChange: setChecked, onExpansionChange: setExpanded, onCommitField: (identity, fieldKey, proposed) => onChange?.(nodes.map((node) => String(readPath(node, identityPath)) === String(identity) ? setPath(node, fieldKey, proposed) : node)), onDrop: (move) => onChange?.(applyMove(nodes, identityPath, parentPath, move)) })] }));
 }

package/components/forms/content-entry-curation-config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Where the page that places the curation Form names the two empty choices -- "Nobody", "None" -- in its
+ * language.
+ *
+ * The options come from a Client Provider, which has no Label Set; the placement does, and the Provider
+ * reads its config (`site-locales-config.ts` hands the languages over the same way). One constant for both
+ * sides, because a key spelled twice is a choice that is silently unlabelled on one of them.
+ */
+export declare const PHI_CONTENT_ENTRY_CURATION_NONE_CONFIG_KEYS: {
+    readonly author: "authorNoneLabel";
+    readonly category: "categoryNoneLabel";
+};

package/components/forms/content-entry-curation-config.js

@@ -0,0 +1,12 @@
+/**
+ * Where the page that places the curation Form names the two empty choices -- "Nobody", "None" -- in its
+ * language.
+ *
+ * The options come from a Client Provider, which has no Label Set; the placement does, and the Provider
+ * reads its config (`site-locales-config.ts` hands the languages over the same way). One constant for both
+ * sides, because a key spelled twice is a choice that is silently unlabelled on one of them.
+ */
+export const PHI_CONTENT_ENTRY_CURATION_NONE_CONFIG_KEYS = {
+    author: "authorNoneLabel",
+    category: "categoryNoneLabel",
+};

package/components/forms/content-entry-forms.d.ts

@@ -0,0 +1,52 @@
+import type { PhiFormId } from "../../types/form-id";
+import type { PhiRuntimeModuleId } from "../../types";
+import { type PhiContentEntryKind } from "../../constants/content-entry-kinds";
+/** Where the page that places the entry Form names the Site's source language, for the empty "Written in". */
+export declare const PHI_CONTENT_ENTRY_SOURCE_LOCALE_PLACEHOLDER_CONFIG_KEY = "sourceLocalePlaceholder";
+/**
+ * A kind's Forms and their handlers, owned by the kind's Module (`CONTENT_ENTRIES.md`).
+ *
+ * One Form per act, because the acts have different authorities. The entry states words: what it says,
+ * where it lives, which language it is written in. The publication states when it is seen. Curation states
+ * who it is by and what it is filed under, and a category is one entry of the Site's order. Core keeps
+ * them apart -- content editing for the first, publishing for the rest -- so one Form covering two would be
+ * reachable by whoever may do the lesser of them.
+ *
+ * Both relay through the Form gateway with the viewer's Site session, because both endpoints are guarded by
+ * a role. Neither takes a CSRF token of its own -- the gateway adds the internal one -- and neither has a
+ * second phase. The ids and handler keys are the Module's, so two kinds never share a Form.
+ */
+export declare function definePhiContentEntryForms({ kind, ownerModuleId, formIds, titles, }: {
+    kind: PhiContentEntryKind;
+    ownerModuleId: PhiRuntimeModuleId;
+    formIds: {
+        entry: PhiFormId;
+        publication: PhiFormId;
+        curation: PhiFormId;
+        category: PhiFormId;
+    };
+    /** How the Form catalogue names them: "News entry", "News publication", "News curation", "News category". */
+    titles: {
+        entry: string;
+        publication: string;
+        curation: string;
+        category: string;
+    };
+}): {
+    forms: import("./form-registry").PhiRuntimeModuleFormDefinition[];
+    handlers: {
+        key: `${string}/${string}`;
+        ownerModuleId: `${string}/${string}`;
+        title: string;
+        phase: "submit";
+        handlerKey: "news.entry" | "blog.entry" | "news.publication" | "blog.publication" | "news.curation" | "blog.curation" | "news.category" | "blog.category";
+        category: "forms";
+        transport: "relay";
+        method: "POST" | "PUT" | "PATCH";
+        endpointKey: null;
+        upstreamPath: string;
+        csrfPath: null;
+        requiresCsrf: false;
+        credentialPolicy: "site-session";
+    }[];
+};

package/components/forms/content-entry-forms.js

@@ -0,0 +1,328 @@
+import { definePhiRuntimeModuleForm } from "./form-registry";
+import { flattenPhiFormLabels } from "./form-labels";
+import { PHI_FORM_FIELD_PROVIDER_KEYS, PHI_FORM_LINK_TARGET_LABEL_KEYS, PHI_FORM_VALIDATION_PROVIDER_KEYS, createPhiSharedFormProviderKey, } from "./form-provider-contract";
+import { readPhiServerApiCredentials } from "../../helpers/phis-server-credentials";
+import { resolvePhiContentEntryEditorApiPaths, } from "../../constants/content-entry-kinds";
+import { PHI_CORE_RUNTIME_DATA_PROVIDER_KEYS } from "../../constants/core-data-provider-keys";
+/** Where the page that places the entry Form names the Site's source language, for the empty "Written in". */
+export const PHI_CONTENT_ENTRY_SOURCE_LOCALE_PLACEHOLDER_CONFIG_KEY = "sourceLocalePlaceholder";
+const label = (key, fallback) => ({ kind: "label", key, fallback });
+const required = (key, fallback) => [{
+        providerKey: PHI_FORM_VALIDATION_PROVIDER_KEYS.required,
+        message: label(key, fallback),
+    }];
+function entryFields(kind) {
+    return [
+        /*
+         * Empty for a new entry, which is how one `PUT` serves both: with an id it is that entry, without one it
+         * is a new entry at the slug below.
+         */
+        { key: "contentId", fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.hidden },
+        /*
+         * The version the row showed, sent back as the base of the save: a save that does not build on the
+         * current version is refused rather than overwriting somebody else's (phis-server CONTENT.md).
+         */
+        { key: "versionId", fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.hidden },
+        {
+            key: "slug",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.text,
+            label: label("slugLabel", "Address"),
+            placeholder: label("slugPlaceholder", "news-entry-address"),
+            /*
+             * Core's own rule (`ENTRY_SLUG_PATTERN` in the entries route), stated here so a space or a capital is
+             * answered at the field rather than by a refused save.
+             */
+            validation: [
+                ...required("slugError", "An address is required."),
+                {
+                    providerKey: PHI_FORM_VALIDATION_PROVIDER_KEYS.pattern,
+                    message: label("slugError", "Lower-case letters, digits and hyphens only."),
+                    config: { source: "^[a-z0-9][a-z0-9-]{0,119}$" },
+                },
+            ],
+        },
+        {
+            key: "title",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.text,
+            label: label("titleLabel", "Title"),
+            validation: required("titleError", "A title is required."),
+        },
+        {
+            key: "subtitle",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.text,
+            label: label("subtitleLabel", "Subtitle"),
+        },
+        {
+            key: "content",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.textarea,
+            label: label("contentLabel", "Body"),
+            placeholder: label("contentPlaceholder", "Markdown"),
+            validation: required("contentError", "A body is required."),
+            config: { rows: 8 },
+        },
+        // A Page of the Public Area, where the list is read, or an address elsewhere -- never a typed path.
+        {
+            key: "link",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.linkTarget,
+            label: label("linkLabel", "Link"),
+            config: { area: "public" },
+        },
+        /*
+         * Offered from what the Site already uses, and typed where a tag is new: a Site with no tagged entry
+         * yet has nothing to pick. The string is a tag's identity, so Core lower-cases and deduplicates what it
+         * is given, and the offer keeps the spellings to the ones already in use.
+         */
+        {
+            key: "tags",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.multiSelect,
+            label: label("tagsLabel", "Tags"),
+            optionsProvider: { providerKey: PHI_CORE_RUNTIME_DATA_PROVIDER_KEYS.contentEntryTags },
+            // `kind` names whose tags are offered; the Options Provider reads it from the field.
+            config: { allowCustom: true, kind },
+        },
+        /*
+         * The Site's languages, handed over by the page that places the Form (`site-locales-config.ts`). Empty
+         * means the Site's own language, which is why the field clears and its placeholder names that language:
+         * the page writes its label into the placement as `sourceLocalePlaceholder`.
+         */
+        {
+            key: "sourceLocale",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.select,
+            label: label("sourceLocaleLabel", "Written in"),
+            placeholder: { kind: "config", key: PHI_CONTENT_ENTRY_SOURCE_LOCALE_PLACEHOLDER_CONFIG_KEY, fallback: "The Site's source language" },
+            optionsProvider: { providerKey: PHI_CORE_RUNTIME_DATA_PROVIDER_KEYS.siteLocales },
+            config: { allowClear: true },
+        },
+        {
+            key: "translate",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.switch,
+            label: label("translateLabel", "May be translated"),
+            initialValue: true,
+        },
+    ];
+}
+const publicationFields = [
+    { key: "contentId", fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.hidden },
+    // The version the Publisher saw in the row is the one that goes live, not whatever was saved since.
+    { key: "versionId", fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.hidden },
+    /*
+     * Both optional, and both meaning something when empty: no publication date keeps the one the entry has
+     * or takes now, no expiry means none. A publish states the whole term, which is why neither carries over
+     * silently from the last one.
+     */
+    {
+        key: "publishedAt",
+        fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.datetime,
+        label: label("publishedAtLabel", "Published from"),
+        // Empty is the moment of publishing, or the date an entry already has: Core takes now where none is.
+        placeholder: label("publishedAtPlaceholder", "Now"),
+    },
+    {
+        key: "expiresAt",
+        fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.datetime,
+        label: label("expiresAtLabel", "Until"),
+        placeholder: label("expiresAtPlaceholder", "No end"),
+    },
+];
+/*
+ * Who an entry is attributed to and what it is filed under: the Publisher's, and not a word of the text,
+ * so its own Form (phis-server CONTENT.md, Curation).
+ *
+ * Both choices are stated on every save, and "none" is a choice of its own -- an empty value, which Core
+ * reads as nobody or no category. A cleared select would send nothing, and Core reads nothing as "leave it".
+ */
+function curationFields(kind) {
+    return [
+        { key: "contentId", fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.hidden },
+        {
+            key: "authorUserId",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.select,
+            label: label("authorLabel", "Author"),
+            optionsProvider: { providerKey: PHI_CORE_RUNTIME_DATA_PROVIDER_KEYS.contentEntryAuthors },
+            config: { kind },
+        },
+        {
+            key: "categoryId",
+            fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.select,
+            label: label("categoryLabel", "Category"),
+            optionsProvider: { providerKey: PHI_CORE_RUNTIME_DATA_PROVIDER_KEYS.contentEntryCategoryOptions },
+            config: { kind },
+        },
+    ];
+}
+/*
+ * One category, stated whole: a new one without an id, a correction with one. The address may be left
+ * empty and is then made from the label, the way Core makes a tag's.
+ */
+const categoryFields = [
+    { key: "id", fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.hidden },
+    {
+        key: "label",
+        fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.text,
+        label: label("categoryNameLabel", "Name"),
+        validation: required("categoryNameError", "A name is required."),
+    },
+    {
+        key: "slug",
+        fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.text,
+        label: label("slugLabel", "Address"),
+        placeholder: label("categorySlugPlaceholder", "Made from the name"),
+    },
+    {
+        key: "sortOrder",
+        fieldProviderKey: PHI_FORM_FIELD_PROVIDER_KEYS.number,
+        label: label("categoryOrderLabel", "Order"),
+    },
+];
+function entryDescriptor(formId, ownerModuleId, fields) {
+    return { schemaVersion: 1, key: formId, labelSetKey: `${ownerModuleId}/labels/forms`, fields };
+}
+async function loadContentEntryFormLabels(context) {
+    const { getPhiContentEntryEditorLabels } = await import("../widgets/label-sets/content-entries");
+    const labels = await getPhiContentEntryEditorLabels({
+        apiBaseUrl: readPhiServerApiCredentials().apiBaseUrl,
+        internalToken: readPhiServerApiCredentials().internalToken,
+        locale: context.runtime.locale.current,
+    });
+    return flattenPhiFormLabels({
+        saveLabel: labels.form.save,
+        savingLabel: labels.form.save,
+        slugLabel: labels.columns.slug,
+        slugPlaceholder: labels.form.slugPlaceholder,
+        slugError: labels.form.slugError,
+        titleLabel: labels.columns.title,
+        titleError: labels.form.titleError,
+        subtitleLabel: labels.form.subtitleLabel,
+        contentLabel: labels.form.contentLabel,
+        contentPlaceholder: labels.form.contentPlaceholder,
+        contentError: labels.form.contentError,
+        linkLabel: labels.form.linkLabel,
+        [PHI_FORM_LINK_TARGET_LABEL_KEYS.none]: labels.form.link.none,
+        [PHI_FORM_LINK_TARGET_LABEL_KEYS.page]: labels.form.link.page,
+        [PHI_FORM_LINK_TARGET_LABEL_KEYS.external]: labels.form.link.external,
+        [PHI_FORM_LINK_TARGET_LABEL_KEYS.pagePlaceholder]: labels.form.link.pagePlaceholder,
+        [PHI_FORM_LINK_TARGET_LABEL_KEYS.externalPlaceholder]: labels.form.link.externalPlaceholder,
+        [PHI_FORM_LINK_TARGET_LABEL_KEYS.newTab]: labels.form.link.newTab,
+        [PHI_FORM_LINK_TARGET_LABEL_KEYS.pagesUnavailable]: labels.form.link.pagesUnavailable,
+        tagsLabel: labels.columns.tags,
+        sourceLocaleLabel: labels.columns.language,
+        translateLabel: labels.form.translateLabel,
+        publishedAtLabel: labels.columns.published,
+        publishedAtPlaceholder: labels.form.publishedAtPlaceholder,
+        expiresAtLabel: labels.columns.expires,
+        expiresAtPlaceholder: labels.form.expiresAtPlaceholder,
+        authorLabel: labels.columns.author,
+        categoryLabel: labels.columns.category,
+        categoryNameLabel: labels.categories.columns.label,
+        categoryNameError: labels.categories.form.labelError,
+        categorySlugPlaceholder: labels.categories.form.slugPlaceholder,
+        categoryOrderLabel: labels.categories.columns.order,
+    });
+}
+/**
+ * A kind's Forms and their handlers, owned by the kind's Module (`CONTENT_ENTRIES.md`).
+ *
+ * One Form per act, because the acts have different authorities. The entry states words: what it says,
+ * where it lives, which language it is written in. The publication states when it is seen. Curation states
+ * who it is by and what it is filed under, and a category is one entry of the Site's order. Core keeps
+ * them apart -- content editing for the first, publishing for the rest -- so one Form covering two would be
+ * reachable by whoever may do the lesser of them.
+ *
+ * Both relay through the Form gateway with the viewer's Site session, because both endpoints are guarded by
+ * a role. Neither takes a CSRF token of its own -- the gateway adds the internal one -- and neither has a
+ * second phase. The ids and handler keys are the Module's, so two kinds never share a Form.
+ */
+export function definePhiContentEntryForms({ kind, ownerModuleId, formIds, titles, }) {
+    const handlerKeys = {
+        entry: `${kind}.entry`,
+        publication: `${kind}.publication`,
+        curation: `${kind}.curation`,
+        category: `${kind}.category`,
+    };
+    const paths = resolvePhiContentEntryEditorApiPaths(kind);
+    const forms = [
+        definePhiRuntimeModuleForm({
+            ownerModuleId,
+            areas: ["editor"],
+            formId: formIds.entry,
+            version: 1,
+            flags: 0,
+            title: titles.entry,
+            description: `The words of one ${kind} entry, stated whole.`,
+            category: "forms",
+            tags: [kind, "content"],
+            descriptor: entryDescriptor(formIds.entry, ownerModuleId, entryFields(kind)),
+            submitHandlerKey: handlerKeys.entry,
+            loadLabels: loadContentEntryFormLabels,
+        }),
+        definePhiRuntimeModuleForm({
+            ownerModuleId,
+            areas: ["editor"],
+            formId: formIds.publication,
+            version: 1,
+            flags: 0,
+            title: titles.publication,
+            description: `When one ${kind} entry is answered, and until when.`,
+            category: "forms",
+            tags: [kind, "publishing"],
+            descriptor: entryDescriptor(formIds.publication, ownerModuleId, publicationFields),
+            submitHandlerKey: handlerKeys.publication,
+            loadLabels: loadContentEntryFormLabels,
+        }),
+        definePhiRuntimeModuleForm({
+            ownerModuleId,
+            areas: ["editor"],
+            formId: formIds.curation,
+            version: 1,
+            flags: 0,
+            title: titles.curation,
+            description: `Who one ${kind} entry is by, and what it is filed under.`,
+            category: "forms",
+            tags: [kind, "publishing"],
+            descriptor: entryDescriptor(formIds.curation, ownerModuleId, curationFields(kind)),
+            submitHandlerKey: handlerKeys.curation,
+            loadLabels: loadContentEntryFormLabels,
+        }),
+        definePhiRuntimeModuleForm({
+            ownerModuleId,
+            areas: ["editor"],
+            formId: formIds.category,
+            version: 1,
+            flags: 0,
+            title: titles.category,
+            description: `One category ${kind} entries are filed under, stated whole.`,
+            category: "forms",
+            tags: [kind, "publishing"],
+            descriptor: entryDescriptor(formIds.category, ownerModuleId, categoryFields),
+            submitHandlerKey: handlerKeys.category,
+            loadLabels: loadContentEntryFormLabels,
+        }),
+    ];
+    /*
+     * A save states the whole entry, and a category whole, so both are a PUT; a publication is an act, so it
+     * is a POST; curation changes two things about an entry and leaves the rest, so it is a PATCH.
+     */
+    const methods = { entry: "PUT", publication: "POST", curation: "PATCH", category: "PUT" };
+    const upstreamPaths = {
+        entry: paths.entries,
+        publication: paths.publish,
+        curation: paths.curation,
+        category: paths.categories,
+    };
+    const handlers = ["entry", "publication", "curation", "category"].map((key) => ({
+        key: createPhiSharedFormProviderKey("handler", `${kind}-${key}`),
+        ownerModuleId,
+        title: `${titles[key]}`,
+        phase: "submit",
+        handlerKey: handlerKeys[key],
+        category: "forms",
+        transport: "relay",
+        method: methods[key],
+        endpointKey: null,
+        upstreamPath: upstreamPaths[key],
+        csrfPath: null,
+        requiresCsrf: false,
+        credentialPolicy: "site-session",
+    }));
+    return { forms, handlers };
+}

package/components/forms/extended-form-field-controls.js

@@ -3,7 +3,24 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { PhiCascaderControl } from "../controls/phi-cascader-control";
 import { PhiNumberControl } from "../controls/phi-number-control";
 import { PhiSliderControl } from "../controls/phi-slider-control";
+import { resolvePhiFormText } from "./form-descriptor-contract";
 import { PHI_STORAGE_SIZE_UNIT_LABEL, phiBytesToStorageSize, phiStorageSizeToBytes, } from "./storage-size";
+/**
+ * The unit beside a number, which is the value's and not the field's name ("days", not "Window (days)").
+ *
+ * A symbol nobody translates -- `ms`, `px` -- is written as a string. A word is a label reference
+ * (`{ kind: "label", key, fallback }`) and is read from the Form's labels like the field's own label,
+ * so "days" is "Tage" where the Form is German.
+ */
+function readPhiNumberFieldPrefix(prefix, labels) {
+    if (typeof prefix === "string")
+        return prefix;
+    const text = prefix;
+    if (text?.kind === "label" && typeof text.key === "string" && typeof text.fallback === "string") {
+        return resolvePhiFormText({ kind: "label", key: text.key, fallback: text.fallback }, labels);
+    }
+    return undefined;
+}
 /*
  * Field kinds most forms never have, loaded only where one is rendered: the slider, the cascader and
  * the number fields.
@@ -23,7 +40,7 @@ export const PhiSliderFormControl = ({ field, value, onChange, disabled, readOnl
     return field.config?.showInput === true ? (_jsxs("div", { style: { display: "grid", gridTemplateColumns: "minmax(96px, 1fr) minmax(0, 2fr)", gap: "var(--ant-padding-sm)", alignItems: "center", minWidth: 0 }, children: [_jsx(PhiNumberControl, { value: numericValue ?? null, min: min, max: max, step: step, precision: typeof field.config?.precision === "number" ? field.config.precision : undefined, disabled: disabled, readOnly: readOnly, style: { width: "100%" }, onChange: (nextValue) => onChange?.(nextValue) }), slider] })) : slider;
 };
 export const PhiCascaderFormControl = ({ field, value, onChange, options, placeholder, disabled, readOnly }) => (_jsx(PhiCascaderControl, { value: typeof value === "string" ? value : undefined, placeholder: placeholder, disabled: disabled, readOnly: readOnly, options: options ?? [], allowRoot: field.config?.allowRoot !== false, allowClear: field.config?.allowClear === true, separator: typeof field.config?.separator === "string" ? field.config.separator : "/", rootValue: typeof field.config?.rootValue === "string" ? field.config.rootValue : "/", normalize: field.config?.normalize === "path" ? "path" : "raw", onChange: (nextValue) => onChange?.(nextValue) }));
-export const PhiNumberFormControl = ({ id, field, value, onChange, placeholder, disabled, readOnly, }) => (_jsx(PhiNumberControl, { id: id, value: typeof value === "number" ? value : null, disabled: disabled, readOnly: readOnly, placeholder: placeholder, min: typeof field.config?.min === "number" ? field.config.min : undefined, max: typeof field.config?.max === "number" ? field.config.max : undefined, step: typeof field.config?.step === "number" ? field.config.step : undefined, precision: typeof field.config?.precision === "number" ? field.config.precision : undefined, prefix: typeof field.config?.prefix === "string" ? field.config.prefix : undefined, style: { width: "100%" }, onChange: (nextValue) => onChange?.(nextValue) }));
+export const PhiNumberFormControl = ({ id, field, value, onChange, placeholder, disabled, readOnly, labels, }) => (_jsx(PhiNumberControl, { id: id, value: typeof value === "number" ? value : null, disabled: disabled, readOnly: readOnly, placeholder: placeholder, min: typeof field.config?.min === "number" ? field.config.min : undefined, max: typeof field.config?.max === "number" ? field.config.max : undefined, step: typeof field.config?.step === "number" ? field.config.step : undefined, precision: typeof field.config?.precision === "number" ? field.config.precision : undefined, prefix: readPhiNumberFieldPrefix(field.config?.prefix, labels), style: { width: "100%" }, onChange: (nextValue) => onChange?.(nextValue) }));
 /*
  * The field holds bytes and shows megabytes, so both conversions sit on this one Control: the value a
  * form carries is bytes before it reaches here and bytes again the moment it leaves, and no submit

package/components/forms/form-descriptor-contract.d.ts

@@ -150,15 +150,6 @@ export declare function phiFormFieldFollowsLayoutColumns(input: {
  * in, and moving the first column would take the form off its own left edge.
  */
 export declare function phiFormCellOpensColumn(range: PhiFormGridRange, sibling: PhiFormGridRange): boolean;
-/**
- * `grid-column` for the two halves of a row a Form Layout may move the boundary of.
- *
- * The line is substituted by CSS rather than by us, through the custom property the Form Layout writes.
- * It has to be CSS: the Layout renders on the server and hands this form in as an already-rendered
- * child, so nothing React carries can reach from one to the other. The descriptor's own line stands as
- * the fallback, which is what a form outside any Form Layout uses.
- */
-export declare const PHI_FORM_LABEL_END_PROPERTY = "--phi-form-label-end";
 export declare function phiFormLabelGridColumn(range: PhiFormGridRange, followsLayout: boolean): string;
 export declare function phiFormControlGridColumn(range: PhiFormGridRange, followsLayout: boolean): string;
 /** The `grid-column` shorthand for a range, which is the only form CSS accepts. */

package/components/forms/form-descriptor-contract.js

@@ -174,7 +174,7 @@ export function phiFormCellOpensColumn(range, sibling) {
  * child, so nothing React carries can reach from one to the other. The descriptor's own line stands as
  * the fallback, which is what a form outside any Form Layout uses.
  */
-export const PHI_FORM_LABEL_END_PROPERTY = "--phi-form-label-end";
+const PHI_FORM_LABEL_END_PROPERTY = "--phi-form-label-end";
 export function phiFormLabelGridColumn(range, followsLayout) {
     return followsLayout
         ? `1 / var(${PHI_FORM_LABEL_END_PROPERTY}, ${range.end})`