@cosmicdrift/kumiko-renderer 0.384.0 → 0.386.0

package/dist/components/render-edit-helpers.js

@@ -0,0 +1,121 @@
+import { evalFieldCondition, isFieldsEditSection, normalizeEditField, sectionFieldSpecs, } from "@cosmicdrift/kumiko-framework/ui-types";
+import { relevantFieldIssues, zodErrorToFieldIssues } from "../headless/index.js";
+// End-to-end renderer for an entityEdit screen. Renders exclusively
+// through primitives, no raw HTML. A native renderer that fills the same
+// primitives registry gets the form without further changes.
+function toConditionValue(cond) {
+    if (typeof cond === "boolean")
+        return cond;
+    // @cast-boundary form-values: TValues is structurally a record.
+    return (values) => evalFieldCondition(cond, values);
+}
+// Tab-strip key. The boot-validator makes `id` mandatory on a tabs layout and
+// entityEdit only ever has "fields"/"extension" sections (relatedList and
+// writeForm are rejected outright), so the positional fallback is unreachable
+// for a tabs screen — it only keeps this total for other layouts.
+export function tabIdAt(section, index) {
+    const declared = section?.kind === "fields" || section?.kind === "extension" ? section.id : undefined;
+    return declared ?? `section-${index}`;
+}
+export function deriveFormFields(screen) {
+    const out = {};
+    for (const section of screen.layout.sections) {
+        // relatedList carries no `fields` for the form-condition map either.
+        if (!isFieldsEditSection(section))
+            continue;
+        for (const spec of sectionFieldSpecs(section)) {
+            const normalized = normalizeEditField(spec);
+            out[normalized.field] = {
+                ...(normalized.visible !== undefined && {
+                    visible: toConditionValue(normalized.visible),
+                }),
+                ...(normalized.readOnly !== undefined && {
+                    readonly: toConditionValue(normalized.readOnly),
+                }),
+                ...(normalized.required !== undefined && {
+                    required: toConditionValue(normalized.required),
+                }),
+            };
+        }
+    }
+    return out;
+}
+// Dry-run parse against `schema` — NOT controller.validate(), which writes
+// field errors into the snapshot. Undefined when the values parse cleanly.
+// Parse once, then narrow per scope with scopedDryRunIssues: the wizard step
+// check would otherwise re-parse the whole form per section on every keystroke.
+export function dryRunParse(schema, snapshot) {
+    const parsed = schema.safeParse(snapshot.values);
+    if (parsed.success)
+        return undefined;
+    const hiddenFields = new Set(Object.entries(snapshot.fields)
+        .filter(([, state]) => !state.visible)
+        .map(([fieldKey]) => fieldKey));
+    return { issues: zodErrorToFieldIssues(parsed.error), hiddenFields };
+}
+// Issues are filtered exactly like the controller's validate(): hidden
+// fields never count, `scope` narrows.
+function scopedDryRunIssues(parse, scope, includeRoot) {
+    if (parse === undefined)
+        return [];
+    return relevantFieldIssues(parse.issues, {
+        hiddenFields: parse.hiddenFields,
+        ...(scope !== undefined && { scope }),
+        includeRoot,
+    });
+}
+export function dryRunFieldIssues(schema, snapshot, scope, includeRoot) {
+    return scopedDryRunIssues(dryRunParse(schema, snapshot), scope, includeRoot);
+}
+// Index-independent: indices shift when a fields section hides.
+export function wizardStepKey(section, index) {
+    const declaredId = section.kind === "fields" || section.kind === "extension" ? section.id : undefined;
+    return declaredId ?? section.title ?? `step-${index}`;
+}
+function isMoneyValue(value) {
+    return typeof value === "object" && value !== null && "amount" in value;
+}
+// The seeds buildInitialValues writes for NULL columns of an existing record.
+function isEmptyFormValue(value) {
+    if (value === null || value === undefined || value === "" || value === 0 || value === false) {
+        return true;
+    }
+    if (Array.isArray(value))
+        return value.length === 0;
+    return isMoneyValue(value) && value.amount === 0;
+}
+// select/boolean are excluded from the "holds user data" check: they are
+// often pre-filled (defaults, server-set values), so they say nothing about
+// whether the step was filled in. They still count through the validation.
+export function isFieldsStepFilled(section, parse) {
+    const fieldNames = section.fields.map((f) => f.field);
+    if (scopedDryRunIssues(parse, fieldNames, false).length > 0)
+        return false;
+    return section.fields.some((f) => f.visible &&
+        !f.readOnly &&
+        f.type !== "boolean" &&
+        f.type !== "select" &&
+        !isEmptyFormValue(f.value));
+}
+export function formSectionDomId(sectionIndex) {
+    return `form-section-${sectionIndex}`;
+}
+/** A record title is a non-blank string; anything else leaves the screen title alone. */
+export function resolveRecordTitle(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+const TITLE_PLACEHOLDER_PATTERN = /\{(\w+)\}/g;
+// Falls back to the plain title while any placeholder value is still empty,
+// so the header never shows "Add  " mid-typing.
+export function resolveTitleTemplate(template, values, translate, fallback) {
+    if (template === undefined)
+        return fallback;
+    const placeholders = [...translate(template).matchAll(TITLE_PLACEHOLDER_PATTERN)].map((match) => match[1] ?? "");
+    const isFilled = (name) => {
+        const value = values[name];
+        return value !== undefined && value !== null && String(value).trim() !== "";
+    };
+    if (!placeholders.every(isFilled))
+        return fallback;
+    return translate(template, values);
+}

package/dist/components/render-edit.d.ts

@@ -1,8 +1,5 @@
+import { type ReactNode } from "react";
 import type { FormValues } from "../headless/index.ts";
 import type { RenderEditProps } from "./render-edit-types.ts";
 export type { RenderEditAction, RenderEditChangeState, RenderEditControls, RenderEditProps, } from "./render-edit-types.ts";
-import { type ReactNode } from "react";
-export declare const PATCH_DRAFT_SAVE_DEBOUNCE_MS = 500;
-/** A record title is a non-blank string; anything else leaves the screen title alone. */
-export declare function resolveRecordTitle(value: unknown): string | undefined;
 export declare function RenderEdit<TValues extends FormValues, TCtx = unknown>(props: RenderEditProps<TValues, TCtx>): ReactNode;