@cosmicdrift/kumiko-renderer 0.327.0 → 0.328.1

package/dist/app/secrets-edit-body.js

@@ -0,0 +1,76 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo, useState } from "react";
+import { useDispatcher } from "../context/dispatcher-context.js";
+import { useQuery } from "../hooks/use-query.js";
+import { useTranslation } from "../i18n.js";
+import { usePrimitives } from "../primitives.js";
+import { dispatcherErrorText } from "./write-failed-error.js";
+// secrets:query:list never returns plaintext (only a redacted preview), so
+// unlike ConfigEditBody there is no server value to pre-fill a draft with —
+// every input starts at "" and stays that way unless the user types into it.
+export function SecretsEditBody({ screen, translate }) {
+    const { Banner, Form, Section, Field, Input, Button, Text } = usePrimitives();
+    const t = useTranslation();
+    const effectiveTranslate = translate ?? t;
+    const dispatcher = useDispatcher();
+    const listQuery = useQuery("secrets:query:list", {});
+    const [drafts, setDrafts] = useState({});
+    const [submitting, setSubmitting] = useState(false);
+    const [submitError, setSubmitError] = useState(null);
+    const rowsByQualifiedKey = useMemo(() => {
+        const out = new Map();
+        for (const row of listQuery.data ?? [])
+            out.set(row.key, row);
+        return out;
+    }, [listQuery.data]);
+    const setDraft = useCallback((fieldId, value) => {
+        setDrafts((prev) => ({ ...prev, [fieldId]: value }));
+    }, []);
+    const handleSubmit = useCallback(async () => {
+        const commands = Object.entries(screen.secretKeys).flatMap(([fieldId, qualified]) => {
+            const value = drafts[fieldId]?.trim();
+            return value ? [{ type: "secrets:write:set", payload: { key: qualified, value } }] : [];
+        });
+        if (commands.length === 0)
+            return;
+        setSubmitting(true);
+        setSubmitError(null);
+        const result = await dispatcher.batch(commands);
+        setSubmitting(false);
+        if (!result.isSuccess) {
+            setSubmitError(dispatcherErrorText(result.error, effectiveTranslate));
+            return;
+        }
+        setDrafts({});
+        await listQuery.refetch();
+    }, [dispatcher, drafts, screen.secretKeys, listQuery.refetch, effectiveTranslate]);
+    const handleDelete = useCallback(async (qualified) => {
+        const result = await dispatcher.write("secrets:write:delete", { key: qualified });
+        if (!result.isSuccess) {
+            setSubmitError(dispatcherErrorText(result.error, effectiveTranslate));
+            return;
+        }
+        await listQuery.refetch();
+    }, [dispatcher, listQuery.refetch, effectiveTranslate]);
+    if (listQuery.loading && listQuery.data === null) {
+        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+    }
+    if (listQuery.error) {
+        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(listQuery.error, effectiveTranslate) }));
+    }
+    return (_jsxs(Form, { onSubmit: () => {
+            void handleSubmit();
+        }, testId: "secrets-edit-form", ...(screen.description !== undefined && {
+            subtitle: effectiveTranslate(screen.description),
+        }), actions: _jsx(Button, { type: "submit", variant: "primary", loading: submitting, disabled: submitting, testId: "secrets-edit-submit", children: effectiveTranslate("kumiko.actions.save") }), children: [submitError !== null && (_jsx(Banner, { variant: "error", testId: "secrets-edit-error", children: submitError })), screen.sections.map((section, index) => (_jsx(Section, { ...(section.title !== undefined && { title: effectiveTranslate(section.title) }), children: section.fields.map((fieldId) => {
+                    const qualified = screen.secretKeys[fieldId];
+                    if (qualified === undefined)
+                        return null;
+                    const row = rowsByQualifiedKey.get(qualified);
+                    const hintKey = screen.fieldHints?.[fieldId];
+                    const isRequired = screen.requiredFields?.includes(fieldId) ?? false;
+                    return (_jsxs(Field, { id: fieldId, label: effectiveTranslate(screen.fieldLabels[fieldId] ?? fieldId), required: isRequired, testId: `field-${fieldId}`, fieldAppendix: _jsxs(_Fragment, { children: [hintKey !== undefined && (_jsx(Text, { variant: "small", children: effectiveTranslate(hintKey) })), row !== undefined ? (_jsxs(_Fragment, { children: [_jsx(Text, { variant: "small", testId: `secret-preview-${fieldId}`, children: row.redactedPreview ?? effectiveTranslate("config.secrets.set") }), _jsx(Button, { type: "button", variant: "danger-ghost", size: "sm", onClick: () => handleDelete(qualified), testId: `secret-delete-${fieldId}`, children: effectiveTranslate("config.secrets.delete") })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { variant: "small", testId: `secret-not-set-${fieldId}`, children: effectiveTranslate("config.secrets.notSet") }), isRequired && (_jsx(Text, { variant: "small", testId: `required-marker-${fieldId}`, children: effectiveTranslate("config.secrets.required") }))] }))] }), children: [_jsx(Text, { variant: "small", children: effectiveTranslate(row !== undefined
+                                    ? "config.secrets.replacePlaceholder"
+                                    : "config.secrets.placeholder") }), _jsx(Input, { kind: "password", id: fieldId, name: fieldId, value: drafts[fieldId] ?? "", onChange: (v) => setDraft(fieldId, v), autoComplete: "new-password", disabled: submitting, testId: `secret-input-${fieldId}` })] }, fieldId));
+                }) }, section.title ?? `section-${index}`)))] }));
+}

package/dist/app/use-embedded-screen.d.ts

@@ -0,0 +1,6 @@
+import type { FeatureSchema } from "./feature-schema.js";
+export type EmbeddedScreenTarget = {
+    readonly schema: FeatureSchema;
+    readonly qn: string;
+};
+export declare function useEmbeddedScreen(hostFeatureName: string, screen: string): EmbeddedScreenTarget | undefined;

package/dist/app/use-embedded-screen.js

@@ -0,0 +1,19 @@
+import { useUserRoles } from "../context/user-roles-context.js";
+import { useAppFeatures } from "./app-features-context.js";
+import { featureNameFromQualifiedScreenId, qualifyScreenId } from "./qualify-screen-id.js";
+import { screenAccessAllows } from "./screen-access.js";
+// Undefined (not KumikoScreen's access-denied banner) so the host can drop the whole tile.
+export function useEmbeddedScreen(hostFeatureName, screen) {
+    const features = useAppFeatures();
+    const userRoles = useUserRoles();
+    const crossFeatureName = featureNameFromQualifiedScreenId(screen);
+    const targetFeatureName = crossFeatureName ?? hostFeatureName;
+    const qn = crossFeatureName !== undefined ? screen : qualifyScreenId(hostFeatureName, screen);
+    const schema = features.find((f) => f.featureName === targetFeatureName);
+    const target = schema?.screens.find((s) => qualifyScreenId(targetFeatureName, s.id) === qn);
+    if (schema === undefined || target === undefined)
+        return undefined;
+    if (!screenAccessAllows(target.access, userRoles))
+        return undefined;
+    return { schema, qn };
+}

package/dist/app/variable-chips.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from "react";
+export type VariableChipsProps = {
+    readonly variables: readonly string[];
+    readonly onInsert: (name: string) => void;
+    readonly disabled?: boolean;
+};
+export declare function VariableChips({ variables, onInsert, disabled }: VariableChipsProps): ReactNode;

package/dist/app/variable-chips.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Editor-agnostic chip bar for a content editor's declared variables
+// (ContentCollectionDefinition.variableSchema). Renders next to the text
+// surface, never inside it — step 3 (rich/tiptap) reuses this same bar over
+// a different editor, so it must not assume a textarea underneath.
+import { Fragment } from "react";
+import { useTranslation } from "../i18n.js";
+import { usePrimitives } from "../primitives.js";
+// No wrapping element: @cosmicdrift/kumiko-renderer is DOM-free (native impls
+// have no <div>), and layout is a platform concern anyway — the caller
+// (PlainContentEditor et al.) places these buttons in its own container.
+export function VariableChips({ variables, onInsert, disabled }) {
+    const { Button } = usePrimitives();
+    const t = useTranslation();
+    return (_jsx(Fragment, { children: variables.map((name) => (_jsx(Button, { type: "button", variant: "secondary", size: "sm", disabled: disabled, onClick: () => onInsert(name), ariaLabel: t("kumiko.contentEditor.insertVariable", { name }), children: `{{${name}}}` }, name))) }));
+}

package/dist/app/write-failed-error.d.ts

@@ -0,0 +1,6 @@
+import type { DispatcherError } from "@cosmicdrift/kumiko-headless";
+export declare class WriteFailedError extends Error {
+    readonly dispatcherError: DispatcherError;
+    constructor(error: DispatcherError, message: string);
+}
+export declare function dispatcherErrorText(error: DispatcherError, translate: (key: string, params?: Readonly<Record<string, unknown>>) => string): string;

package/dist/app/write-failed-error.js

@@ -0,0 +1,21 @@
+// dispatcher.write wirft bei Server-Fehlern NICHT — es returnt
+// { isSuccess: false, error }. Action-Wiring das das Result verwirft,
+// macht Fehler unsichtbar ("Klick tut nichts"-Prod-Bug 2026-06-07).
+// Diese Klasse trägt den strukturierten DispatcherError dahin, wo eine
+// UI ihn anzeigen kann (Toast mit docsUrl).
+export class WriteFailedError extends Error {
+    dispatcherError;
+    constructor(error, message) {
+        super(message);
+        this.name = "WriteFailedError";
+        this.dispatcherError = error;
+    }
+}
+// i18nKey gewinnt wenn das Bundle ihn kennt (translate returnt den Key
+// unverändert wenn nicht — Renderer-Convention), sonst message, zuletzt code.
+export function dispatcherErrorText(error, translate) {
+    const translated = translate(error.i18nKey, error.i18nParams);
+    if (translated !== error.i18nKey)
+        return translated;
+    return error.message !== "" ? error.message : error.code;
+}

package/dist/components/embedded-list-field.d.ts

@@ -0,0 +1,10 @@
+import type { EditFieldViewModel, FieldIssue } from "@cosmicdrift/kumiko-headless";
+import { type ReactNode } from "react";
+export type EmbeddedListFieldProps = {
+    readonly field: EditFieldViewModel;
+    readonly id: string;
+    readonly onChange: (value: unknown) => void;
+    readonly allIssues: Readonly<Record<string, readonly FieldIssue[]>>;
+    readonly featureName: string;
+};
+export declare function EmbeddedListField({ field, id, onChange, allIssues, featureName, }: EmbeddedListFieldProps): ReactNode;

package/dist/components/embedded-list-field.js

@@ -0,0 +1,259 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { computeDerivedCellValue, currencyDecimals, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, } from "@cosmicdrift/kumiko-headless";
+import { useState } from "react";
+import { REFERENCE_COMBOBOX_LIMIT } from "../hooks/reference-limits.js";
+import { useQuery } from "../hooks/use-query.js";
+import { referenceLookupSource } from "../hooks/use-reference-lookup.js";
+import { useTranslation } from "../i18n.js";
+import { usePrimitives } from "../primitives.js";
+function withRecomputedDerived(row, derived, cells) {
+    if (derived === undefined)
+        return row;
+    // Read sources from an unchanged snapshot, never from `result` (which this
+    // loop mutates) — mirrors withDerivedCells server-side so chained derived
+    // cells (e.g. net=qty*price, then gross=sum(net,tax)) can't drift between
+    // client preview and server depending on Object.entries(derived) order.
+    const source = { ...row };
+    const result = { ...row };
+    for (const [derivedField, def] of Object.entries(derived)) {
+        const values = def.from.map((src) => {
+            const v = source[src];
+            return typeof v === "number" ? v : undefined;
+        });
+        const computed = computeDerivedCellValue(def.op, values);
+        const target = cells.find((c) => c.field === derivedField);
+        result[derivedField] =
+            computed !== undefined && target !== undefined
+                ? roundDerivedCellValue(computed, target)
+                : computed;
+    }
+    return result;
+}
+// Locale-aware decimal parse for pasted text: strips space/NBSP thousands
+// separators outright, then treats whichever of "," or "." appears LAST in
+// the string as the decimal separator and strips the other one — handles
+// both "1.234,56" (de) and "1,234.56" (en-US) pastes. Returns undefined for
+// anything that still doesn't parse as a finite number.
+function parseLocaleAwareDecimal(raw) {
+    const stripped = raw.replace(/[\s ]/g, "");
+    if (stripped === "")
+        return undefined;
+    const lastComma = stripped.lastIndexOf(",");
+    const lastDot = stripped.lastIndexOf(".");
+    const decimalIndex = Math.max(lastComma, lastDot);
+    if (decimalIndex === -1) {
+        const n = Number(stripped);
+        return Number.isFinite(n) ? n : undefined;
+    }
+    const integerPart = stripped.slice(0, decimalIndex).replace(/[.,]/g, "");
+    const fractionPart = stripped.slice(decimalIndex + 1);
+    if (!/^\d*$/.test(integerPart) || !/^\d*$/.test(fractionPart))
+        return undefined;
+    const n = Number(`${integerPart === "" ? "0" : integerPart}.${fractionPart === "" ? "0" : fractionPart}`);
+    return Number.isFinite(n) ? n : undefined;
+}
+function coerceCellValue(column, text, currency) {
+    switch (column.type) {
+        case "text":
+            return text;
+        case "number":
+        case "decimal": {
+            if (text.trim() === "")
+                return undefined;
+            const n = Number(text);
+            return Number.isFinite(n) ? n : undefined;
+        }
+        case "money": {
+            // Money cells are minor-unit integers (cents) in storage — paste
+            // arrives as a major-unit decimal string ("12,99"/"12.99"), so scale
+            // by the currency's decimal places. Must agree with the typed-in path
+            // (renderCellControl's MoneyInput, which scales by the same
+            // currencyDecimals) — a hardcoded ×100 here diverged for zero-/three-
+            // decimal currencies (JPY, BHD, ...), landing a pasted value 100x off
+            // from the same value typed by hand (kumiko-framework#1972).
+            // parseLocaleAwareDecimal handles both "1.234,56" (de) and
+            // "1,234.56" (en-US) thousands/decimal conventions — a naive
+            // `replace(",", ".")` mangled DE-locale pastes with thousands
+            // separators into NaN (kumiko-framework#1838).
+            if (text.trim() === "")
+                return undefined;
+            const n = parseLocaleAwareDecimal(text);
+            return n === undefined ? undefined : Math.round(n * 10 ** currencyDecimals(currency));
+        }
+        case "boolean":
+            return ["true", "1", "yes", "y", "ja"].includes(text.trim().toLowerCase());
+        case "date":
+        case "timestamp":
+            return text.trim();
+        case "select": {
+            const match = (column.options ?? []).find((opt) => opt === text || column.optionLabels?.[opt] === text);
+            return match;
+        }
+        case "reference": {
+            const match = (column.referenceOptions ?? []).find((o) => o.label === text || o.value === text);
+            return match?.value;
+        }
+        default: {
+            const exhaustiveCheck = column.type;
+            return exhaustiveCheck;
+        }
+    }
+}
+export function EmbeddedListField({ field, id, onChange, allIssues, featureName, }) {
+    const { EmbeddedListInput } = usePrimitives();
+    const t = useTranslation();
+    const [pasteWarning, setPasteWarning] = useState(null);
+    const cells = field.embeddedListCells ?? [];
+    const rows = Array.isArray(field.value) ? field.value : [];
+    const derived = field.embeddedListDerived;
+    const referenceCells = cells.filter((c) => c.type === "reference");
+    const referenceSources = referenceCells.map((cell) => cell.refOptionsQuery !== undefined
+        ? { queryQn: cell.refOptionsQuery, labelKey: "label" }
+        : referenceLookupSource(cell.refFeature ?? featureName, cell.refEntity ?? "", cell.refLabelField ?? "id"));
+    const referenceQueries = referenceSources.map((source) => 
+    // biome-ignore lint/correctness/useHookAtTopLevel: referenceCells comes from the entity-schema definition — fixed for the screen's lifetime, not a real conditional-hook risk.
+    useQuery(source.queryQn, {
+        limit: REFERENCE_COMBOBOX_LIMIT,
+    }));
+    if (EmbeddedListInput === undefined)
+        return null;
+    const columns = cells.map((cell) => {
+        const isDerived = derived?.[cell.field] !== undefined;
+        if (cell.type === "reference") {
+            const idx = referenceCells.indexOf(cell);
+            const query = referenceQueries[idx];
+            const labelKey = referenceSources[idx]?.labelKey ?? "id";
+            const referenceOptions = (query?.data?.rows ?? []).map((row) => ({
+                value: String(row["id"] ?? ""),
+                label: String(row[labelKey] ?? row["id"] ?? ""),
+            }));
+            return {
+                field: cell.field,
+                label: cell.label,
+                type: cell.type,
+                required: cell.required,
+                derived: isDerived,
+                referenceOptions,
+                referenceLoading: query?.loading ?? false,
+            };
+        }
+        return {
+            field: cell.field,
+            label: cell.label,
+            type: cell.type,
+            required: cell.required,
+            derived: isDerived,
+            ...(cell.options !== undefined && { options: cell.options }),
+            ...(cell.optionLabels !== undefined && { optionLabels: cell.optionLabels }),
+        };
+    });
+    const totals = (field.embeddedListTotals ?? []).map((subFieldName) => {
+        const cell = cells.find((c) => c.field === subFieldName);
+        return {
+            field: subFieldName,
+            label: cell?.label ?? subFieldName,
+            value: sumEmbeddedListColumn(rows, subFieldName),
+        };
+    });
+    const { listIssues, rowIssues, cellIssues } = groupEmbeddedListIssues(allIssues, field.field);
+    const combinedListIssues = pasteWarning === null
+        ? listIssues
+        : [
+            ...listIssues,
+            ...(pasteWarning.droppedRows > 0
+                ? [
+                    {
+                        path: field.field,
+                        code: "paste-rows-truncated",
+                        i18nKey: "kumiko.field.embedded-list.paste-rows-truncated",
+                        params: { count: pasteWarning.droppedRows },
+                    },
+                ]
+                : []),
+            ...(pasteWarning.unmatchedCells > 0
+                ? [
+                    {
+                        path: field.field,
+                        code: "paste-cells-unmatched",
+                        i18nKey: "kumiko.field.embedded-list.paste-cells-unmatched",
+                        params: { count: pasteWarning.unmatchedCells },
+                    },
+                ]
+                : []),
+        ];
+    function replaceRow(rowIndex, updater) {
+        const nextRows = rows.map((row, i) => (i === rowIndex ? updater(row) : row));
+        onChange(nextRows);
+    }
+    function handleCellChange(rowIndex, cellField, value) {
+        replaceRow(rowIndex, (row) => withRecomputedDerived({ ...row, [cellField]: value }, derived, cells));
+    }
+    function handleAddRow() {
+        onChange([...rows, withRecomputedDerived({}, derived, cells)]);
+    }
+    function handleRemoveRow(rowIndex) {
+        onChange(rows.filter((_, i) => i !== rowIndex));
+    }
+    function handleDuplicateRow(rowIndex) {
+        const source = rows[rowIndex];
+        if (source === undefined)
+            return;
+        const next = [...rows];
+        next.splice(rowIndex + 1, 0, { ...source });
+        onChange(next);
+    }
+    function handleMoveRow(fromIndex, toIndex) {
+        if (toIndex < 0 || toIndex >= rows.length)
+            return;
+        const next = [...rows];
+        const [moved] = next.splice(fromIndex, 1);
+        if (moved === undefined)
+            return;
+        next.splice(toIndex, 0, moved);
+        onChange(next);
+    }
+    function handlePasteCells(rowIndex, columnIndex, grid) {
+        const maxItems = field.embeddedListMaxItems;
+        const nextRows = [...rows];
+        const touchedIndices = new Set();
+        let droppedRows = 0;
+        let unmatchedCells = 0;
+        grid.forEach((gridRow, gridRowOffset) => {
+            const targetRowIndex = rowIndex + gridRowOffset;
+            if (targetRowIndex >= nextRows.length) {
+                if (maxItems !== undefined && nextRows.length >= maxItems) {
+                    droppedRows += 1;
+                    return;
+                }
+                nextRows.push({});
+            }
+            const targetRow = nextRows[targetRowIndex];
+            if (targetRow === undefined)
+                return;
+            let updatedRow = { ...targetRow };
+            gridRow.forEach((text, gridColOffset) => {
+                const column = columns[columnIndex + gridColOffset];
+                if (column === undefined)
+                    return;
+                const coerced = coerceCellValue(column, text, field.embeddedListCurrency ?? "EUR");
+                // Also covers an unparseable money paste (e.g. mangled thousands
+                // separators) — the cell must stay unchanged instead of silently
+                // clearing to undefined (kumiko-framework#1838).
+                const isUnmatchedOrUnparseable = (column.type === "select" || column.type === "reference" || column.type === "money") &&
+                    coerced === undefined &&
+                    text.trim() !== "";
+                if (isUnmatchedOrUnparseable) {
+                    unmatchedCells += 1;
+                    return;
+                }
+                updatedRow = { ...updatedRow, [column.field]: coerced };
+            });
+            nextRows[targetRowIndex] = updatedRow;
+            touchedIndices.add(targetRowIndex);
+        });
+        setPasteWarning(droppedRows > 0 || unmatchedCells > 0 ? { droppedRows, unmatchedCells } : null);
+        const recomputed = nextRows.map((row, i) => touchedIndices.has(i) ? withRecomputedDerived(row, derived, cells) : row);
+        onChange(recomputed);
+    }
+    return (_jsx(EmbeddedListInput, { id: id, columns: columns, rows: rows, totals: totals, currency: field.embeddedListCurrency, disabled: field.readOnly, minItems: field.embeddedListMinItems, maxItems: field.embeddedListMaxItems, listIssues: combinedListIssues, rowIssues: rowIssues, cellIssues: cellIssues, onCellChange: handleCellChange, onAddRow: handleAddRow, onRemoveRow: handleRemoveRow, onDuplicateRow: handleDuplicateRow, onMoveRow: handleMoveRow, onPasteCells: handlePasteCells, addLabel: t("kumiko.field.embedded-list.add-row"), removeLabel: t("kumiko.field.embedded-list.remove-row"), duplicateLabel: t("kumiko.field.embedded-list.duplicate-row"), moveUpLabel: t("kumiko.field.embedded-list.move-up"), moveDownLabel: t("kumiko.field.embedded-list.move-down"), emptyLabel: t("kumiko.field.embedded-list.empty"), emptyCtaLabel: t("kumiko.field.embedded-list.empty-cta"), testId: id }));
+}

package/dist/components/grid-cell-for-field.d.ts

@@ -0,0 +1,25 @@
+import type { EditFieldViewModel, FieldIssue } from "@cosmicdrift/kumiko-headless";
+import type { ReactNode } from "react";
+import type { usePrimitives } from "../primitives.js";
+export type GridCellForFieldProps = {
+    readonly field: EditFieldViewModel;
+    readonly columns: number;
+    readonly issues: readonly FieldIssue[] | undefined;
+    readonly onChange: (value: unknown) => void;
+    readonly GridCell: ReturnType<typeof usePrimitives>["GridCell"];
+    /** Tier 2.7e-3: passed through so Reference fields can build the correct
+     *  lookup query QN (`<feature>:query:<refEntity>:list`). */
+    readonly featureName: string;
+    readonly labelAppendix?: ReactNode;
+    readonly fieldAppendix?: ReactNode;
+    /** Full issues-by-path map (FormSnapshot.errors) — passed through for
+     *  embedded-list fields, which bucket row-/cell-level issues themselves. */
+    readonly allIssues: Readonly<Record<string, readonly FieldIssue[]>>;
+    /** Passed through to RenderField unchanged — see RenderEditProps.valueDisplay. */
+    readonly valueDisplay: "form" | "text";
+    /** Passed through to RenderField as `row` — see RenderFieldProps.row. */
+    readonly row: Readonly<Record<string, unknown>>;
+    readonly changed?: boolean;
+    readonly flow?: boolean;
+};
+export declare function GridCellForField({ field, columns, issues, onChange, GridCell, featureName, labelAppendix, fieldAppendix, allIssues, valueDisplay, row, changed, flow, }: GridCellForFieldProps): ReactNode;

package/dist/components/grid-cell-for-field.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RenderField } from "./render-field.js";
+const FIELD_CELL_WIDTH_BY_TYPE = {
+    number: "number",
+    decimal: "number",
+    bigInt: "number",
+    money: "money",
+    date: "date",
+    select: "select",
+    multiSelect: "select",
+    boolean: "auto",
+    longText: "full",
+    embedded: "full",
+    jsonb: "full",
+    file: "full",
+    files: "full",
+    image: "full",
+    images: "full",
+};
+function fieldCellWidth(field) {
+    if (field.span !== undefined || (field.type === "text" && field.multiline))
+        return "full";
+    return FIELD_CELL_WIDTH_BY_TYPE[field.type] ?? "text";
+}
+export function GridCellForField({ field, columns, issues, onChange, GridCell, featureName, labelAppendix, fieldAppendix, allIssues, valueDisplay, row, changed, flow, }) {
+    // RenderField renders nothing for a hidden field, but the GridCell around it still claims the row.
+    if (!field.visible)
+        return null;
+    const effectiveSpan = field.span !== undefined ? Math.min(field.span, columns) : 1;
+    return (_jsx(GridCell, { span: effectiveSpan, ...(flow === true && { width: fieldCellWidth(field) }), children: _jsx(RenderField, { field: field, ...(issues !== undefined && { issues }), onChange: onChange, featureName: featureName, ...(labelAppendix !== undefined && { labelAppendix }), ...(fieldAppendix !== undefined && { fieldAppendix }), allIssues: allIssues, valueDisplay: valueDisplay, row: row, ...(changed === true && { changed }) }) }));
+}

package/dist/components/multi-select-checkboxes.d.ts

@@ -0,0 +1,14 @@
+import type { EditFieldViewModel } from "@cosmicdrift/kumiko-headless";
+import type { ReactNode } from "react";
+export type MultiSelectCheckboxOption = {
+    readonly value: string;
+    readonly label: string;
+};
+export type MultiSelectCheckboxesProps = {
+    readonly field: EditFieldViewModel;
+    readonly id: string;
+    readonly options: readonly MultiSelectCheckboxOption[];
+    readonly value: readonly string[];
+    readonly onChange: (value: readonly string[]) => void;
+};
+export declare function MultiSelectCheckboxes({ field, id, options, value, onChange, }: MultiSelectCheckboxesProps): ReactNode;

package/dist/components/multi-select-checkboxes.js

@@ -0,0 +1,36 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslation } from "../i18n.js";
+import { usePrimitives } from "../primitives.js";
+// Renders MultiSelectFieldDef's `display: "checkboxes"` mode — every option
+// as a visible checkbox plus a select-all toggle, built purely from the
+// platform-neutral Primitives contract (Grid/GridCell/Field/Input kind
+// "boolean", the same primitive `case "boolean"` uses in render-field.tsx).
+// No renderer-web import here — this file must stay usable from Expo too.
+export function MultiSelectCheckboxes({ field, id, options, value, onChange, }) {
+    const { Grid, GridCell, Field, Input, Button } = usePrimitives();
+    const t = useTranslation();
+    const disabled = field.readOnly;
+    const selected = new Set(value);
+    const allSelected = options.length > 0 && options.every((opt) => selected.has(opt.value));
+    // Always emits in `field.options` order (MultiSelectFieldDef's documented
+    // ordering guarantee), never in click/selection order.
+    const emitOrdered = (next) => {
+        onChange(options.filter((opt) => next.has(opt.value)).map((opt) => opt.value));
+    };
+    const toggleOption = (optionValue, checked) => {
+        const next = new Set(selected);
+        if (checked) {
+            next.add(optionValue);
+        }
+        else {
+            next.delete(optionValue);
+        }
+        emitOrdered(next);
+    };
+    const toggleAll = () => {
+        emitOrdered(allSelected ? new Set() : new Set(options.map((opt) => opt.value)));
+    };
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { type: "button", variant: "secondary", size: "sm", disabled: disabled, onClick: toggleAll, testId: `${id}-select-all`, children: allSelected
+                    ? t("kumiko.field.multiSelect.deselect-all")
+                    : t("kumiko.field.multiSelect.select-all") }), _jsx(Grid, { columns: field.columns ?? 2, testId: `${id}-checkboxes`, ...(field.maxRows !== undefined && { maxRows: field.maxRows }), children: options.map((opt) => (_jsx(GridCell, { children: _jsx(Field, { id: `${id}-${opt.value}`, label: opt.label, layout: "inline", children: _jsx(Input, { kind: "boolean", id: `${id}-${opt.value}`, name: `${id}-${opt.value}`, value: selected.has(opt.value), onChange: (checked) => toggleOption(opt.value, checked), disabled: disabled }) }) }, opt.value))) })] }));
+}

package/dist/components/reference-create-dialog.d.ts

@@ -0,0 +1,13 @@
+import type { EntityDefinition, EntityEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import { type ReactNode } from "react";
+export declare function extractIdField(data: unknown, field: string): string | undefined;
+export declare function extractCreatedId(data: unknown): string | undefined;
+export type ReferenceCreateDialogProps = {
+    readonly open: boolean;
+    readonly onClose: () => void;
+    readonly onCreated: (id: string | undefined) => void;
+    readonly featureName: string;
+    readonly screen: EntityEditScreenDefinition;
+    readonly entity: EntityDefinition;
+};
+export declare function ReferenceCreateDialog({ open, onClose, onCreated, featureName, screen, entity, }: ReferenceCreateDialogProps): ReactNode;

package/dist/components/reference-create-dialog.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { buildInitialValues } from "../app/kumiko-screen.js";
+import { toKebab } from "../app/qn.js";
+import { useTranslation } from "../i18n.js";
+import { usePrimitives } from "../primitives.js";
+import { RenderEdit } from "./render-edit.js";
+// Hosts a target entity's create-form inside a bare Modal so a reference
+// field can create a missing record without leaving the current form
+// (kumiko-framework#1681) — same create wiring as EntityEditCreateBody
+// (kumiko-screen.tsx), but reports the new id back via a callback instead
+// of navigating to the entity's list screen.
+function entityWriteCommand(featureName, entity) {
+    return `${toKebab(featureName)}:write:${toKebab(entity)}:create`;
+}
+// The create handler's success payload is `{ kind: "save", id, ... }`
+// (see event-store-executor-write.ts) but RenderEdit's onSubmit only
+// types it as `unknown` — narrow defensively instead of casting through it.
+// `field` is author-declared (ActionFormRedirect.idFrom, fw#2670), never
+// user input; the own-property check keeps a prototype key like
+// "constructor" from resolving to anything.
+export function extractIdField(data, field) {
+    if (typeof data !== "object" || data === null)
+        return undefined;
+    if (!Object.hasOwn(data, field))
+        return undefined;
+    const value = data[field];
+    return typeof value === "string" ? value : undefined;
+}
+export function extractCreatedId(data) {
+    return extractIdField(data, "id");
+}
+export function ReferenceCreateDialog({ open, onClose, onCreated, featureName, screen, entity, }) {
+    const { Modal } = usePrimitives();
+    const t = useTranslation();
+    const initial = useMemo(() => buildInitialValues(entity.fields, entity.defaultCurrency ?? "EUR"), [entity.fields, entity.defaultCurrency]);
+    const writeCommand = entityWriteCommand(featureName, screen.entity);
+    const handleSubmitted = (result) => {
+        if (result.validationBlocked || !result.isSuccess)
+            return;
+        onCreated(extractCreatedId(result.data));
+    };
+    if (!open)
+        return null;
+    return (_jsx(Modal, { open: open, onOpenChange: (next) => !next && onClose(), title: t("kumiko.actions.create"), children: _jsx(RenderEdit, { screen: screen, entity: entity, featureName: featureName, initial: initial, writeCommand: writeCommand, onSubmit: handleSubmitted, onCancel: onClose, ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }) }) }));
+}

package/dist/components/related-list-section.d.ts

@@ -0,0 +1,25 @@
+import type { RowActionDrawer } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { EditRelatedListSectionViewModel, Translate } from "@cosmicdrift/kumiko-headless";
+import { type ReactNode } from "react";
+export declare function RelatedListSection({ section, parentId, record, featureName, translate, hideTitle, grow, onOpenDrawer, actions, }: {
+    readonly section: EditRelatedListSectionViewModel;
+    readonly parentId: string;
+    /** The enclosing projectionDetail's own record (the "Akte") — evaluates
+     *  toolbarActions' `visible`/`params` (RelatedListToolbarAction), the same
+     *  record header actions already use. */
+    readonly record: Readonly<Record<string, unknown>>;
+    readonly featureName: string;
+    readonly translate?: Translate;
+    readonly hideTitle?: boolean;
+    /** Under a fixed-height screen the tab panel chain stretches so the count footer sits at the bottom. */
+    readonly grow?: boolean;
+    /** Opens a drawer-kind rowAction (fw#2710). Supplied by the parent
+     *  (ProjectionDetailBody), which owns schema + the actual Drawer render —
+     *  this component only ever invokes the callback. */
+    readonly onOpenDrawer?: (action: RowActionDrawer, initialValues: Readonly<Record<string, unknown>> | undefined) => void;
+    /** section.actions, already resolved into buttons by the caller —
+     *  rendered in the Section's title row. Only reachable in the standalone
+     *  (non-`hideTitle`) branch below — `hideTitle` uses `FillContainer`, which
+     *  has no title row to render actions into (see the comment on that branch). */
+    readonly actions?: ReactNode;
+}): ReactNode;