@cosmicdrift/kumiko-renderer 0.388.0 → 0.390.0

package/dist/components/render-edit-wizard-navigation.js

@@ -0,0 +1,115 @@
+import { tabIdAt, wizardStepKey } from "./render-edit-helpers.js";
+import { findFirstErroringSectionIndex, resolveExtensionEntityId } from "./render-edit-logic.js";
+// Rebuilt every render on purpose: the closures read this render's step and
+// section state, and the wizard refs publish the current ones.
+export function createWizardNavigation({ props, state, form, draft, sections, steps }, saveDraft) {
+    const { disabled } = props;
+    const { isCreateMode, isTabs, setRawStep } = state;
+    const { filteredSections } = sections;
+    const { currentStep, lastStepIndex } = steps;
+    const { hasNavigatedRef } = draft.refs;
+    // Persist all composed extension sections using the resolved entityId.
+    // false means a section failed and its i18n key is shown in the banner. Without
+    // entity context (create mode without a route id), there is nothing to write.
+    async function persistExtensions() {
+        const entityId = resolveExtensionEntityId(props.entityId, sections.vm.id);
+        if (entityId === null)
+            return true;
+        const results = await state.runExtensionSubmits({ entityId });
+        const failed = results.find((r) => !r.isSuccess);
+        if (failed !== undefined) {
+            state.setExtensionErrorKey(failed.errorKey ?? "kumiko.form.extension.save-failed");
+            return false;
+        }
+        return true;
+    }
+    function jumpToStep(index) {
+        setRawStep(index);
+        if (isTabs)
+            state.setActiveTabId(tabIdAt(filteredSections[index], index));
+    }
+    function currentStepHasFieldErrors() {
+        const section = filteredSections[currentStep];
+        const fieldNames = section?.kind === "fields" ? section.fields.map((f) => f.field) : [];
+        return fieldNames.length > 0 && !form.controller.validate(fieldNames);
+    }
+    function markCurrentStepPassed() {
+        const leftSection = filteredSections[currentStep];
+        // skip: no current section to mark as passed
+        if (leftSection === undefined)
+            return;
+        const leftKey = wizardStepKey(leftSection, currentStep);
+        state.setPassedStepKeys((prev) => (prev.has(leftKey) ? prev : new Set(prev).add(leftKey)));
+    }
+    // Next: scoped validate() on the current step's fields — errors stay
+    // attached to the field and block the step transition. Extension steps
+    // have no field scope here (they validate via the controlled-mode
+    // controls.validate() API), so no call, no clearing of unrelated errors.
+    function handleWizardNext() {
+        const next = Math.min(currentStep + 1, lastStepIndex);
+        hasNavigatedRef.current = true;
+        // Locked state: `disabled` means "no input/no write", not "no
+        // navigation" — a disabled wizard must still be steppable so Back/Next
+        // reach every step. But neither validate() (would block on an empty
+        // required field nobody can fill in) nor saveDraft() (would mint a
+        // draftId / dispatch a write — exactly what `disabled` forbids) may run.
+        if (disabled) {
+            setRawStep(next);
+            // skip: locked wizard only steps, no validate or draft save
+            return;
+        }
+        // skip: the current step has field errors — no transition, no draft save.
+        if (currentStepHasFieldErrors())
+            return;
+        if (!isCreateMode)
+            markCurrentStepPassed();
+        setRawStep(next);
+        saveDraft(next);
+    }
+    function handleWizardBack() {
+        handleWizardStepSelect(currentStep - 1);
+    }
+    // Update mode: the record already exists and the final Save validates the
+    // whole form and jumps to the first erroring step (findFirstErroringStep), so
+    // skipping steps forward is safe; leaving the current step still goes through
+    // its validate gate.
+    function handleWizardStepSelect(targetStep) {
+        // skip: already on the target step
+        if (targetStep === currentStep)
+            return;
+        const isForward = targetStep > currentStep;
+        // Create mode: a forward jump would skip the per-step validate() gate.
+        // skip: create mode has no forward jump
+        if (isForward && isCreateMode)
+            return;
+        // skip: current step has field errors
+        if (isForward && !disabled && currentStepHasFieldErrors())
+            return;
+        const clampedTarget = Math.min(Math.max(targetStep, 0), lastStepIndex);
+        hasNavigatedRef.current = true;
+        setRawStep(clampedTarget);
+        if (!disabled)
+            saveDraft(clampedTarget);
+    }
+    // Stepped modes (wizard, tabs): locates the first step whose "fields"
+    // section contains one of the given field paths — matched on the path's
+    // first segment, since `FieldIssue.path`/`snapshot.errors` keys can be
+    // dotted (embedded-list rows, e.g. `tasks.2.title`) while a section's field
+    // name is always the plain top-level name. Returns undefined for a
+    // root-level issue (path `"(root)"`, see zod-bridge.ts) or one that matches
+    // no rendered field — callers must NOT suppress the error banner in that
+    // case, there is nowhere to jump the user to. Extension sections are not
+    // jump targets by design: they validate through the controlled-mode
+    // controls.validate() API and own no field specs to match against.
+    function findFirstErroringStep(fieldPaths) {
+        return findFirstErroringSectionIndex(filteredSections, fieldPaths);
+    }
+    return {
+        persistExtensions,
+        jumpToStep,
+        handleWizardNext,
+        handleWizardBack,
+        handleWizardStepSelect,
+        findFirstErroringStep,
+    };
+}

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

@@ -1,5 +1,5 @@
-import { type ReactNode } from "react";
+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";
-export declare function RenderEdit<TValues extends FormValues, TCtx = unknown>(props: RenderEditProps<TValues, TCtx>): ReactNode;
+export declare function RenderEdit<TValues extends FormValues, TCtx = unknown>(rawProps: RenderEditProps<TValues, TCtx>): ReactNode;