@cosmicdrift/kumiko-renderer 0.328.0 → 0.328.1

package/dist/app/extension-sections.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+/** Extrahiert den `__component`-Namen aus einer PlatformComponent. Liest
+ *  react- und native-Branch (die App-Author registriert beide unter dem
+ *  gleichen Namen); returnt den ersten gefundenen string. Pure narrowing
+ *  via `in` — kein cast, kein assertion. */
+export function extensionSectionName(component) {
+    for (const branch of [component.react, component.native]) {
+        if (branch !== null && typeof branch === "object" && "__component" in branch) {
+            const candidate = branch.__component;
+            if (typeof candidate === "string")
+                return candidate;
+        }
+    }
+    return undefined;
+}
+const ExtensionSectionsContext = createContext(undefined);
+export function ExtensionSectionsProvider({ children, value, }) {
+    return (_jsx(ExtensionSectionsContext.Provider, { value: value, children: children }));
+}
+/** Schaut die Component für einen extension-section-Namen nach. Returnt
+ *  undefined wenn weder Provider gemounted noch der Name in der Map
+ *  registriert ist — der Caller (RenderEdit) zeigt dann seinen
+ *  Placeholder-Banner. `name` ist optional damit Caller den Hook
+ *  unkonditional aufrufen können (Rules-of-Hooks), ohne einen Stub-Key
+ *  wie `""` reichen zu müssen — analog `useColumnRenderer`. */
+export function useExtensionSectionComponent(name) {
+    const map = useContext(ExtensionSectionsContext);
+    if (name === undefined || name === "")
+        return undefined;
+    if (map === undefined)
+        return undefined;
+    return map[name];
+}

package/dist/app/feature-schema.d.ts

@@ -0,0 +1,4 @@
+import type { AppSchema, FeatureSchema, QualifiedContentCollection, WorkspaceSchema } from "@cosmicdrift/kumiko-framework/ui-types";
+export type { AppSchema, FeatureSchema, QualifiedContentCollection, WorkspaceSchema };
+export declare function toAppSchema(input: FeatureSchema | AppSchema): AppSchema;
+export declare function isAppSchema(input: FeatureSchema | AppSchema): input is AppSchema;

package/{src/app/feature-schema.ts → dist/app/feature-schema.js}

@@ -21,40 +21,30 @@
 //   };
 //
 //   // feature.ts  (server-only — imports defineFeature)
-//   import { taskEntity, editScreen, ... } from "./feature-schema";
+//   import { taskEntity, editScreen, ... } from "./feature-schema.js";
 //   export const taskFeature = defineFeature("tasks", (r) => {
 //     r.entity("task", taskEntity);
 //     r.writeHandler(...);
 //     r.screen(editScreen);
 //     ...
 //   });
-
-import type {
-  AppSchema,
-  FeatureSchema,
-  QualifiedContentCollection,
-  WorkspaceSchema,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-
-export type { AppSchema, FeatureSchema, QualifiedContentCollection, WorkspaceSchema };
-
 // Normalisiert FeatureSchema → AppSchema. Idempotent für AppSchema.
 // Hebt eine Feature-lokal deklarierte `workspaces`-Liste (Legacy) auf
 // App-Ebene hoch, damit alle Layouts mit der neuen Form arbeiten können
 // ohne dass alte clientSchemas migriert werden müssen.
-export function toAppSchema(input: FeatureSchema | AppSchema): AppSchema {
-  if ("features" in input) return input;
-  // Old single-feature shape — wrap.
-  const { workspaces, ...feature } = input;
-  return {
-    features: [feature],
-    ...(workspaces !== undefined && { workspaces }),
-  };
+export function toAppSchema(input) {
+    if ("features" in input)
+        return input;
+    // Old single-feature shape — wrap.
+    const { workspaces, ...feature } = input;
+    return {
+        features: [feature],
+        ...(workspaces !== undefined && { workspaces }),
+    };
 }
-
 // TypeGuard — Caller die schon zur Laufzeit unterscheiden müssen
 // (selten; meist reicht toAppSchema). Nicht via `"features" in x` inline
 // machen — narrow'd TS dann auf den join-Typ statt die echte Differenz.
-export function isAppSchema(input: FeatureSchema | AppSchema): input is AppSchema {
-  return "features" in input;
+export function isAppSchema(input) {
+    return "features" in input;
 }

package/dist/app/form-schema.d.ts

@@ -0,0 +1,4 @@
+import type { EntityDefinition, EntityEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import * as z from "zod";
+export declare const REQUIRED_FIELD_I18N_KEY = "kumiko.validation.required";
+export declare function buildFormSchema(entity: EntityDefinition, screen: EntityEditScreenDefinition): z.ZodType;

package/dist/app/form-schema.js

@@ -0,0 +1,85 @@
+import { evalFieldCondition, NO_WIDGET_FIELD_TYPES } from "@cosmicdrift/kumiko-framework/ui-types";
+import { I18N_KEY_PARAM } from "@cosmicdrift/kumiko-headless";
+import * as z from "zod";
+import { layoutEditFields } from "./layout-fields.js";
+// `required` means "has a value", not "is truthy" — `false` and `0` count
+// as present, only the actually-empty representations don't.
+function isPresent(value) {
+    if (value === undefined || value === null || value === "")
+        return false;
+    if (Array.isArray(value) && value.length === 0)
+        return false;
+    return true;
+}
+function isEmbeddedListField(field) {
+    return field.type === "embedded" && field.multiple === true;
+}
+// Renders raw to the user without a de+en default in i18n-defaults.ts.
+export const REQUIRED_FIELD_I18N_KEY = "kumiko.validation.required";
+// Client-side presence validation for the auto-wired entityEdit path —
+// checks that every rendered required field HAS a value, not that the
+// value has the right shape. Format/range/type validation stays server-
+// authoritative (buildInsertSchema/buildUpdateSchema): the form-state
+// representation of a value can diverge from the server-payload shape (e.g.
+// money is `{amount,currency}`, not a bare number), so a format check here
+// would either reject valid values or need per-representation branches that
+// rot the moment either side changes.
+//
+// One `superRefine` instead of a per-field shape: a field-level `.refine()`
+// wouldn't run at all for a key that's simply absent from `values` —
+// `superRefine` sees the whole object and catches that case too.
+// `.passthrough()` is load-bearing: the default `z.object({})` STRIPS every
+// key (there's no declared shape), so `superRefine` would see an empty
+// object regardless of what was actually submitted — every required field
+// would misreport as missing.
+//
+// Iterates the screen's layout field specs, not `entity.fields` — `required`
+// and `readOnly` are per-spec, evaluated against the current values the
+// same way `view-model/edit.ts` resolves them for the rendered form. Not
+// checked here: `visible`. `runValidate` already filters issues on hidden
+// fields via `computeFieldStates(options.fields, …)` (form-controller.ts:163,181),
+// fed by `deriveFormFields(screen)` in render-edit.tsx.
+export function buildFormSchema(entity, screen) {
+    const fields = layoutEditFields(screen);
+    return z
+        .object({})
+        .passthrough()
+        .superRefine((values, ctx) => {
+        // `.passthrough()` types `values` as a plain object but doesn't declare
+        // its keys — the runtime object always carries every form field.
+        // @cast-boundary form-values
+        const record = values;
+        for (const spec of fields) {
+            const field = entity.fields[spec.field];
+            if (!field)
+                continue;
+            // Not operable by the user — a presence error would be unresolvable,
+            // same reason as the NO_WIDGET_FIELD_TYPES check below.
+            if (spec.readOnly !== undefined && evalFieldCondition(spec.readOnly, record))
+                continue;
+            // Screen-spec `required` overrides the entity default, mirroring
+            // `view-model/edit.ts` — the rendered form is the reference, and a
+            // presence check stricter than the form blocks the user for nothing.
+            const entityRequired = "required" in field && field.required === true;
+            const isRequired = spec.required === undefined ? entityRequired : evalFieldCondition(spec.required, record);
+            if (!isRequired)
+                continue;
+            // Embedded LIST fields get their own EmbeddedListField grid widget
+            // (#1838) — they're fillable, so NO_WIDGET_FIELD_TYPES's "embedded"
+            // entry must not exempt them. A statically-`required: true` field
+            // with no bound widget is also caught at boot
+            // (validateNoWidgetRequiredField in boot-validator/screens.ts).
+            if (NO_WIDGET_FIELD_TYPES.includes(field.type) && !isEmbeddedListField(field))
+                continue;
+            if (isPresent(record[spec.field]))
+                continue;
+            ctx.addIssue({
+                code: "custom",
+                path: [spec.field],
+                message: `"${spec.field}" is required.`,
+                // I18N_KEY_PARAM override, see packages/headless/src/form/zod-bridge.ts.
+                params: { [I18N_KEY_PARAM]: REQUIRED_FIELD_I18N_KEY },
+            });
+        }
+    });
+}

package/dist/app/kumiko-screen.d.ts

@@ -0,0 +1,43 @@
+import type { ScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { ListRowViewModel, Translate } from "@cosmicdrift/kumiko-headless";
+import { type ReactNode } from "react";
+import { type ListSort } from "../hooks/use-list-url-state.js";
+import type { FeatureSchema } from "./feature-schema.js";
+import { qualifyScreenId } from "./qualify-screen-id.js";
+import { screenAccessAllows } from "./screen-access.js";
+export type KumikoScreenProps = {
+    readonly schema: FeatureSchema;
+    readonly qn: string;
+    readonly translate?: Translate;
+    readonly entityId?: string;
+    readonly onRowClick?: (row: ListRowViewModel, entityName: string) => void;
+    readonly onCopyLink?: () => Promise<void> | void;
+};
+export { qualifyScreenId };
+/** Mirrors qualifyScreenId for nav QNs (registry form `<feature>:nav:<short-id>`).
+ *  Callers building QNs (e.g. the WorkspaceShell resolver) should use this instead of string-concat, so a QN-schema change only touches one place. */
+export declare function qualifyNavId(featureName: string, navId: string): string;
+export { screenAccessAllows };
+export declare function KumikoScreen({ schema, qn, translate, entityId, onRowClick, onCopyLink, }: KumikoScreenProps): ReactNode;
+export declare function buildInitialValues(fields: Readonly<Record<string, unknown>>, defaultCurrency?: string, moneyCurrencyOverrides?: Readonly<Record<string, string>>): Readonly<Record<string, unknown>>;
+export declare function literalCurrencyOverrides(fields: Readonly<Record<string, unknown>>): Readonly<Record<string, string>>;
+export type InitialValueSources = {
+    readonly searchParams: Readonly<Record<string, string>>;
+    readonly urlPrefillFields: readonly string[] | undefined;
+    readonly renderableFields?: ReadonlySet<string>;
+    readonly defaultCurrency?: string;
+    readonly moneyCurrencyOverrides?: Readonly<Record<string, string>>;
+    readonly drawerOverrides?: Readonly<Record<string, unknown>>;
+    readonly handoffValues?: Readonly<Record<string, unknown>>;
+};
+export declare function mergeSearchParamsIntoInitial(fields: Readonly<Record<string, unknown>>, sources: InitialValueSources): Record<string, unknown>;
+export declare function buildListQueryPayload(state: {
+    readonly limit: number;
+    readonly search: string;
+    readonly sort: ListSort | null;
+    readonly usePager: boolean;
+    readonly page: number;
+    readonly useInfinite: boolean;
+    readonly cursor: string | undefined;
+}): Record<string, unknown>;
+export type { ScreenDefinition };