@chelone/vue 0.0.0-stage → 0.1.0

package/dist/form/use-form.d.ts

@@ -0,0 +1,78 @@
+/**
+ * `useForm` — the Vue form-core bridge, the twin of `@chelone/react`'s standalone
+ * `useForm` (`form-hooks.ts`). It constructs a vanilla `FormController` (D6
+ * `revalidateLogic` + schema-as-validator pulled from the resource registry,
+ * same as core/react), bridges its reactive state into Vue via the form-core
+ * subscribe seam, provides the form to descendant `useInput`s, and exposes the
+ * narrow surface a view needs: `{ form, values, submit, submitting, reset }`.
+ *
+ * Bridge choice (spec §A / Task 6 fallback): `@tanstack/vue-store` is NOT a
+ * dependency here, AND — more fundamentally — a `FormController` exposes only
+ * form-core's `subscribe` + `getSnapshot`, where `subscribe` drives the 4R
+ * `form.mount()` refcount. Bridging via the V1-a subscribe pattern
+ * ({@link useSubscribable}) mounts the form on `setup` and unmounts on scope
+ * disposal; subscribing to the raw `form.store` directly would read state but
+ * never mount its validators. So the bridge goes THROUGH the controller.
+ *
+ * The submit pipeline (server-error mapping via `form.setErrorMap({onSubmit})`,
+ * post-save `form.reset(saved)`) all lives inside `createFormController` — this
+ * composable only wires the P4 `save` (the caller's `onSubmit`), the registry
+ * schema, and the ambient services (`notifications`/`translate`).
+ */
+import type { CheloneFormApi, FieldErrors, FormControllerOptions, FormLevelValidate } from "@chelone/core";
+import { type ComputedRef } from "vue";
+/** The Standard Schema slot, referenced structurally so no extra type import is needed. */
+type FormSchema<TFormData> = FormControllerOptions<TFormData>["schema"];
+/**
+ * The caller-supplied save. Follows the P4 contract: resolve the server's
+ * `fieldErrors` on a validation failure (they map onto the form's `onSubmit`
+ * error channel), resolve nullish on success. A `void`/`Promise<void>` return
+ * is treated as success — a create/edit view that persists through its own
+ * controller and has no field errors to surface.
+ */
+export type FormSubmit<TFormData> = (data: TFormData) => Promise<FieldErrors | undefined> | FieldErrors | undefined | Promise<void>;
+export interface UseFormOptions<TFormData> {
+    /**
+     * Seed values → the form's `defaultValues` (ra's "the record"): an edit view
+     * passes the fetched record, a create view its seed. Post-save `reset`
+     * rebaselines against the saved values.
+     */
+    record?: TFormData;
+    /** The save callback (P4 contract) — receives the typed form values on submit. */
+    onSubmit: FormSubmit<TFormData>;
+    /**
+     * Target resource for the DEFAULT schema validator; defaults to the ambient
+     * `<Resource>` name. Only used to look up the registry schema — a form
+     * without a resource simply has no default schema.
+     */
+    resource?: string;
+    /** Explicit Standard Schema override (else the resource-registry schema). */
+    schema?: FormSchema<TFormData>;
+    /** Form-level validate fn (ra contract). */
+    validate?: FormLevelValidate<TFormData>;
+    /** ra parity: nullify/strip empty top-level values before save. Default false. */
+    sanitizeEmptyValues?: boolean;
+    /**
+     * The sanitize baseline (ra: "the record"): an emptied key that exists on it
+     * is sent as `null`, any other is omitted. Read live at save time, so an edit
+     * view can return the record that hydrated after setup.
+     */
+    getRecord?: () => Partial<TFormData> | undefined;
+    /** Rebaseline the form from the saved values on success (D5). Default true. */
+    resetOnSuccess?: boolean;
+}
+/** The narrow reactive surface `useForm` exposes to a view. */
+export interface UseFormReturn<TFormData> {
+    /** The wrapped FormApi — field bindings hang off it (see `useInput`). */
+    form: CheloneFormApi<TFormData>;
+    /** The live form values (whole-values view; re-emits per keystroke by design). */
+    values: ComputedRef<TFormData>;
+    /** The submit pipeline (validate → save → server-error map → reset). */
+    submit: () => Promise<void>;
+    /** Reactive submitting flag. */
+    submitting: ComputedRef<boolean>;
+    /** Imperative reset/rebaseline (defaults to the current defaults when omitted). */
+    reset: (values?: TFormData) => void;
+}
+export declare function useForm<TFormData = Record<string, unknown>>(options: UseFormOptions<TFormData>): UseFormReturn<TFormData>;
+export {};

package/dist/form/use-form.js

@@ -0,0 +1,44 @@
+import { createFormController } from "@chelone/core";
+import { computed } from "vue";
+import { useCheloneContext } from "../context.js";
+import { useResourceContext } from "../resource-context.js";
+import { provideCheloneForm } from "./form-context.js";
+import { useSubscribable } from "./subscribe-ref.js";
+function registrySchema(resources, resource) {
+  if (!resources || !resource) return void 0;
+  const entry = resources[resource];
+  return entry?.schema;
+}
+function useForm(options) {
+  const ctx = useCheloneContext();
+  const resource = useResourceContext({ resource: options.resource });
+  const translate = ctx.i18n ? (key) => ctx.i18n?.translate(key) ?? key : void 0;
+  const schema = options.schema ?? registrySchema(ctx.resources, resource);
+  const controller = createFormController(
+    {
+      defaultValues: options.record,
+      schema,
+      validate: options.validate,
+      sanitizeEmptyValues: options.sanitizeEmptyValues,
+      getRecord: options.getRecord,
+      resetOnSuccess: options.resetOnSuccess,
+      // Adapt the caller's save to the P4 `Promise<FieldErrors | undefined>`
+      // contract: a nullish/void resolution is success.
+      save: async (data) => await options.onSubmit(data) ?? void 0,
+      notifications: ctx.notifications,
+      translate
+    }
+  );
+  const state = useSubscribable(controller);
+  provideCheloneForm({ form: controller.form, submit: controller.submit });
+  return {
+    form: controller.form,
+    values: computed(() => state.value.values),
+    submit: controller.submit,
+    submitting: computed(() => state.value.isSubmitting),
+    reset: (values) => controller.form.reset(values)
+  };
+}
+export {
+  useForm
+};

package/dist/form/use-input.d.ts

@@ -0,0 +1,60 @@
+/**
+ * `useInput` — the Vue input workhorse, the twin of `@chelone/react`'s `useInput`
+ * (`form-hooks.ts`, ra's `useInput` rebridged onto form-core). It binds ONE field
+ * to the ambient form (injected from `useForm`'s provider) through a vanilla
+ * `FieldBinding`, and exposes the two-way binding + validation surface an input
+ * SFC needs: `{ id, name, value, setValue, blur, error, touched, isRequired }`.
+ *
+ * The 4R lifecycle rides the binding's `subscribe`: {@link useSubscribable}
+ * subscribes on `setup`, so the field mounts (seeds the guarded default,
+ * registers with the form so submit-time / schema validation sees it, runs
+ * onMount), and `onScopeDispose` unmounts on teardown. This is exactly the React
+ * twin's commit-phase attach, mapped to Vue's effect scope.
+ *
+ * `error` is the first displayable field error — a `string | TranslatableMessage`
+ * normalized by {@link firstFieldError} — rendered through i18n, never a raw
+ * `error.root.message`. Schema issues (from the form's registry schema) and
+ * server field errors (mapped onto the form's `onSubmit` channel) both surface
+ * here once the field is registered.
+ */
+import type { TranslatableMessage, Validator } from "@chelone/core";
+import { type ComputedRef } from "vue";
+export interface UseInputOptions {
+    /** The field path RELATIVE to the ambient source scope (iterator rows compose it). */
+    source: string;
+    /**
+     * Input-level default (ra precedence): seeds ONLY into a hole (an untouched
+     * field whose form value is `undefined`); an existing record value wins.
+     */
+    defaultValue?: unknown;
+    /** ra-contract validators — composed, first error wins. */
+    validate?: Validator | readonly Validator[];
+    /** Read transform (raw form value → input value). Default `defaultFormat`. */
+    format?: (value: unknown) => unknown;
+    /** Write transform (input value → stored value). Default `defaultParse`. */
+    parse?: (input: unknown) => unknown;
+    /** Forces the required marker; ORed with `required()` detection on `validate`. */
+    isRequired?: boolean;
+    /** Explicit element id; a `useId` value is generated otherwise. */
+    id?: string;
+}
+/** The reactive input surface — spread onto / bound into the input SFC. */
+export interface UseInputReturn {
+    /** Stable element id (for `<label for>` / `aria-describedby`). */
+    id: string;
+    /** The FINAL field path (source-scoped). */
+    name: string;
+    /** The input-facing value: `format(raw)` — `''` for nullish under the default. */
+    value: ComputedRef<unknown>;
+    /** Writes `parse(value)` to the field (marks touched+dirty, validates per mode). */
+    setValue: (input: unknown) => void;
+    /** Marks the field blurred and runs blur-cause validation. */
+    blur: () => void;
+    /** The first displayable field error, or `undefined` when valid. */
+    error: ComputedRef<string | TranslatableMessage | undefined>;
+    /** Whether the field has been touched. */
+    touched: ComputedRef<boolean>;
+    /** Whether a required validator is present (or `isRequired` was forced). */
+    isRequired: boolean;
+}
+export declare function useInput(options: UseInputOptions): UseInputReturn;

package/dist/form/use-input.js

@@ -0,0 +1,45 @@
+import { createFieldBinding, defaultFormat, isRequired } from "@chelone/core";
+import { useId, computed } from "vue";
+import { firstFieldError } from "./field-error.js";
+import { useCheloneFormContext, useSourceScope } from "./form-context.js";
+import { useRegisterFieldGroup } from "./form-groups.js";
+import { useSubscribable } from "./subscribe-ref.js";
+function extractEventValue(input) {
+  if (typeof input === "object" && input !== null && "target" in input) {
+    const { target } = input;
+    if (typeof target === "object" && target !== null && ("value" in target || "checked" in target)) {
+      const element = target;
+      return element.type === "checkbox" ? element.checked : element.value;
+    }
+  }
+  return input;
+}
+function useInput(options) {
+  const { form } = useCheloneFormContext();
+  const scope = useSourceScope();
+  const source = scope.getSource(options.source);
+  const generatedId = useId();
+  useRegisterFieldGroup(source);
+  const binding = createFieldBinding(form, {
+    source,
+    defaultValue: options.defaultValue,
+    format: options.format,
+    parse: options.parse,
+    validate: options.validate
+  });
+  const state = useSubscribable(binding);
+  const format = options.format ?? defaultFormat;
+  return {
+    id: options.id ?? generatedId,
+    name: source,
+    value: computed(() => format(state.value.value)),
+    setValue: (input) => binding.setValue(extractEventValue(input)),
+    blur: () => binding.blur(),
+    error: computed(() => firstFieldError(state.value.meta.errorMap)),
+    touched: computed(() => state.value.meta.isTouched),
+    isRequired: options.isRequired === true || isRequired(options.validate)
+  };
+}
+export {
+  useInput
+};

package/dist/form/use-warn-when-unsaved-changes.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `useWarnWhenUnsavedChanges` — the Vue twin of `@chelone/react`'s
+ * `warn-unsaved-changes.tsx`. Warns the user before they leave a form with
+ * unsaved changes, in two independent halves:
+ *
+ * 1. **Router block** (SPA navigation) on the adapter's `useBlocker`. The dirty
+ *    signal is `!isDefaultValue`, NOT the sticky `isDirty` (which stays true
+ *    after an edit-then-revert). A save clears the block until the next edit.
+ * 2. **`beforeunload`** (tab close / reload) — pure DOM, so it works without a
+ *    router.
+ *
+ * Without a `RouterAdapter` above, or when the adapter cannot block, the router
+ * half is inert and the hook warns once; `beforeunload` still works.
+ */
+import { type MaybeRefOrGetter, type Ref } from "vue";
+/** The headless decision `useWarnWhenUnsavedChanges` returns. */
+export interface WarnWhenUnsavedChangesDecision {
+    /** True while a navigation is blocked awaiting the user's confirm/cancel. */
+    isBlocked: Readonly<Ref<boolean>>;
+    /** Confirm: discard changes and continue the blocked navigation. No-op unless blocked. */
+    proceed: () => void;
+    /** Cancel: stay on the form, keep the changes. No-op unless blocked. */
+    cancel: () => void;
+}
+export declare function useWarnWhenUnsavedChanges(enable: MaybeRefOrGetter<boolean>, formRootPathname?: MaybeRefOrGetter<string | undefined>): WarnWhenUnsavedChangesDecision;

package/dist/form/use-warn-when-unsaved-changes.js

@@ -0,0 +1,78 @@
+import { shallowRef, onScopeDispose, computed, toValue, watchEffect } from "vue";
+import { useRouterAdapterOptional } from "../router/adapter.js";
+import { useCheloneFormContext } from "./form-context.js";
+import { subscribeStore } from "./subscribe-ref.js";
+function isUnder(pathname, base) {
+  return pathname === base || pathname.startsWith(`${base}/`);
+}
+function isNavigatingAwayFromForm(nextPathname, formRoot) {
+  const root = formRoot.replace(/\/+$/, "");
+  return !isUnder(nextPathname, root) || isUnder(nextPathname, `${root}/show`);
+}
+function useWarnWhenUnsavedChanges(enable, formRootPathname) {
+  const { form } = useCheloneFormContext();
+  let savedValues;
+  let wasSubmitSuccessful = false;
+  const readFormState = () => {
+    const { isDefaultValue, isSubmitSuccessful, isValid, values } = form.store.state;
+    if (!isSubmitSuccessful) savedValues = void 0;
+    else if (!wasSubmitSuccessful) savedValues = isValid ? values : void 0;
+    wasSubmitSuccessful = isSubmitSuccessful;
+    return {
+      isDefaultValue,
+      isSaved: savedValues !== void 0 && values === savedValues
+    };
+  };
+  const formState = shallowRef(readFormState());
+  onScopeDispose(
+    subscribeStore(form.store, () => {
+      const next = readFormState();
+      const current = formState.value;
+      if (current.isDefaultValue === next.isDefaultValue && current.isSaved === next.isSaved) {
+        return;
+      }
+      formState.value = next;
+    })
+  );
+  const shouldBlock = computed(
+    () => toValue(enable) && !formState.value.isDefaultValue && !formState.value.isSaved
+  );
+  if (typeof window !== "undefined") {
+    const beforeunload = (event) => {
+      if (!shouldBlock.value) return;
+      event.preventDefault();
+      event.returnValue = true;
+    };
+    window.addEventListener("beforeunload", beforeunload);
+    onScopeDispose(
+      () => window.removeEventListener("beforeunload", beforeunload)
+    );
+  }
+  const adapter = useRouterAdapterOptional();
+  const canBlock = adapter?.useCanBlock() ?? false;
+  let warned = false;
+  watchEffect(() => {
+    if (canBlock || warned || !toValue(enable)) return;
+    warned = true;
+    console.warn(
+      "useWarnWhenUnsavedChanges: no router that can block navigation is available. SPA-navigation warnings are disabled; the beforeunload (tab-close) warning still applies. Mount <Admin> under Chelone's router to enable it."
+    );
+  });
+  const mountedPathname = adapter?.useLocation().value.pathname;
+  const blocker = adapter && canBlock ? adapter.useBlocker(
+    ({ nextLocation }) => {
+      if (!shouldBlock.value) return false;
+      const formRoot = toValue(formRootPathname) ?? mountedPathname;
+      if (formRoot === void 0) return false;
+      return isNavigatingAwayFromForm(nextLocation.pathname, formRoot);
+    }
+  ) : null;
+  return {
+    isBlocked: computed(() => blocker?.state.value === "blocked"),
+    proceed: () => blocker?.proceed(),
+    cancel: () => blocker?.reset()
+  };
+}
+export {
+  useWarnWhenUnsavedChanges
+};

package/dist/form/use-wizard-form.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The wizard controller of `<WizardForm>`, the twin of `@chelone/react`'s
+ * `useWizardForm`. The step index is local state; advancing runs
+ * validate-before-advance through the caller's `validateStep`.
+ */
+import { type ComputedRef, type MaybeRefOrGetter, type Ref } from "vue";
+/** The headless wizard controller surface. */
+export interface UseWizardFormResult {
+    /** Zero-based index of the visible step. */
+    currentStep: Readonly<Ref<number>>;
+    /** Whether a further step exists after the current one. */
+    hasNext: ComputedRef<boolean>;
+    /** Whether a step exists before the current one. */
+    hasPrev: ComputedRef<boolean>;
+    /**
+     * Validate the current step and advance only if it passes. Resolves `true`
+     * when it advanced, `false` when validation blocked it or there is no next
+     * step.
+     */
+    next(): Promise<boolean>;
+    /** Move back one step; a no-op on the first step. */
+    prev(): void;
+    /** Jump to a step, clamped into `[0, stepCount - 1]`. */
+    goToStep(index: number): void;
+    /** Submit the whole form: collects values from every (mounted) step. */
+    submit(): Promise<void>;
+}
+/**
+ * Local step index plus validate-before-advance. `stepNames` is the ordered
+ * list of step names (index i is step i); `validateStep` reports whether the
+ * named step is valid.
+ */
+export declare function useWizardForm(stepNames: MaybeRefOrGetter<readonly string[]>, submit: () => Promise<void>, validateStep: (stepName: string) => Promise<boolean>): UseWizardFormResult;
+/** Provide the controller and the active step name (called by `<WizardForm>`). */
+export declare function provideWizardForm(wizard: UseWizardFormResult, activeStep: Readonly<Ref<string | undefined>>): void;
+/** The ambient wizard controller; throws outside a `<WizardForm>`. */
+export declare function useWizardFormContext(): UseWizardFormResult;
+/** The active step name, for `<WizardFormStep>` to show or hide itself. */
+export declare function useActiveWizardStep(): Readonly<Ref<string | undefined>>;

package/dist/form/use-wizard-form.js

@@ -0,0 +1,54 @@
+import { computed, toValue, ref, provide, inject } from "vue";
+function useWizardForm(stepNames, submit, validateStep) {
+  const lastIndex = computed(() => Math.max(0, toValue(stepNames).length - 1));
+  const clamp = (index) => Number.isNaN(index) ? 0 : Math.min(Math.max(Math.trunc(index), 0), lastIndex.value);
+  const selected = ref(0);
+  const currentStep = computed(() => clamp(selected.value));
+  return {
+    currentStep,
+    hasNext: computed(() => currentStep.value < lastIndex.value),
+    hasPrev: computed(() => currentStep.value > 0),
+    goToStep(index) {
+      selected.value = clamp(index);
+    },
+    prev() {
+      selected.value = clamp(currentStep.value - 1);
+    },
+    async next() {
+      const index = currentStep.value;
+      if (index >= lastIndex.value) return false;
+      const stepName = toValue(stepNames)[index];
+      const valid = stepName === void 0 || await validateStep(stepName);
+      if (!valid || currentStep.value !== index) return false;
+      selected.value = clamp(index + 1);
+      return true;
+    },
+    submit
+  };
+}
+const WizardFormContextKey = /* @__PURE__ */ Symbol(
+  "chelone-wizard-form-context"
+);
+const ActiveWizardStepKey = /* @__PURE__ */ Symbol("chelone-wizard-form-active-step");
+function provideWizardForm(wizard, activeStep) {
+  provide(WizardFormContextKey, wizard);
+  provide(ActiveWizardStepKey, activeStep);
+}
+function useWizardFormContext() {
+  const ctx = inject(WizardFormContextKey, null);
+  if (!ctx) {
+    throw new Error(
+      "useWizardFormContext: no <WizardForm> found above this component."
+    );
+  }
+  return ctx;
+}
+function useActiveWizardStep() {
+  return inject(ActiveWizardStepKey, void 0) ?? ref(void 0);
+}
+export {
+  provideWizardForm,
+  useActiveWizardStep,
+  useWizardForm,
+  useWizardFormContext
+};

package/dist/form/wizard-form-shell.vue.d.ts

@@ -0,0 +1,14 @@
+/** Props for {@link WizardFormShell}. */
+export interface WizardFormShellProps {
+    stepNames: readonly string[];
+    submit: () => Promise<void>;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<WizardFormShellProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<WizardFormShellProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/form/wizard-form-shell.vue.js

@@ -0,0 +1,40 @@
+import { defineComponent, computed, renderSlot } from "vue";
+import { useCheloneFormContext } from "./form-context.js";
+import { useFormGroups } from "./form-groups.js";
+import { useWizardForm, provideWizardForm } from "./use-wizard-form.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "wizard-form-shell",
+  props: {
+    stepNames: {},
+    submit: { type: Function }
+  },
+  setup(__props) {
+    const props = __props;
+    const { form } = useCheloneFormContext();
+    const groups = useFormGroups();
+    async function validateStep(stepName) {
+      const members = groups.getMembers(stepName);
+      if (members.length === 0) return true;
+      await Promise.all(
+        members.map(
+          (source) => Promise.resolve(form.validateField(source, "submit"))
+        )
+      );
+      const fieldMeta = form.store.state.fieldMeta;
+      return members.every((source) => fieldMeta[source]?.isValid !== false);
+    }
+    const wizard = useWizardForm(
+      () => props.stepNames,
+      () => props.submit(),
+      validateStep
+    );
+    const activeStep = computed(() => props.stepNames[wizard.currentStep.value]);
+    provideWizardForm(wizard, activeStep);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/form/wizard-form-shell2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./wizard-form-shell.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/form/wizard-form-step.vue.d.ts

@@ -0,0 +1,14 @@
+/** Props for {@link WizardFormStep}. */
+export interface WizardFormStepProps {
+    /** The step name, also its form group name: its inputs register into it. */
+    name: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<WizardFormStepProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<WizardFormStepProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/form/wizard-form-step.vue.js

@@ -0,0 +1,27 @@
+import { defineComponent, computed, openBlock, createElementBlock, renderSlot } from "vue";
+import { provideFormGroup } from "./form-groups.js";
+import { useActiveWizardStep } from "./use-wizard-form.js";
+const _hoisted_1 = ["data-chelone-wizard-step", "hidden"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "wizard-form-step",
+  props: {
+    name: {}
+  },
+  setup(__props) {
+    const props = __props;
+    provideFormGroup(() => props.name);
+    const activeStep = useActiveWizardStep();
+    const hidden = computed(() => activeStep.value !== props.name);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        "data-chelone-wizard-step": __props.name,
+        hidden: hidden.value
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 8, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/form/wizard-form-step2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./wizard-form-step.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/form/wizard-form.vue.d.ts

@@ -0,0 +1,22 @@
+import type { OptionalSaveFormProps } from "./form-scope.js";
+/**
+ * Props for {@link WizardForm}. With `save` the form builds its own form and
+ * takes every form option; without it the form drives the one of the view above
+ * it (`<Edit>`, `<Create>`), which takes the other options.
+ */
+export type WizardFormProps<TFormData> = OptionalSaveFormProps<TFormData>;
+declare const _default: <TFormData>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & WizardFormProps<TFormData> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/form/wizard-form.vue.js

@@ -0,0 +1,57 @@
+import { defineComponent, useSlots, openBlock, createBlock, unref, withCtx, renderSlot, Fragment } from "vue";
+import { useFormScope } from "./form-scope.js";
+import { provideFormGroups } from "./form-groups.js";
+import _sfc_main$1 from "./wizard-form-shell.vue.js";
+import _sfc_main$2 from "./wizard-form-step.vue.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "wizard-form",
+  props: {
+    record: {},
+    resource: {},
+    schema: {},
+    validate: {},
+    sanitizeEmptyValues: { type: Boolean },
+    getRecord: {},
+    resetOnSuccess: { type: Boolean, default: true },
+    save: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const slots = useSlots();
+    const submit = useFormScope("WizardForm", props);
+    provideFormGroups();
+    function collectSteps(nodes) {
+      const names = [];
+      for (const node of nodes) {
+        if (node.type === Fragment && Array.isArray(node.children)) {
+          names.push(...collectSteps(node.children));
+        } else if (node.type === _sfc_main$2) {
+          names.push(String(node.props?.name));
+        }
+      }
+      return names;
+    }
+    let stepNames = [];
+    function readSteps() {
+      const next = collectSteps(slots.default?.() ?? []);
+      if (next.length !== stepNames.length || next.some((name, i) => name !== stepNames[i])) {
+        stepNames = next;
+      }
+      return stepNames;
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, {
+        "step-names": readSteps(),
+        submit: unref(submit)
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["step-names", "submit"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/form/wizard-form2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./wizard-form.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/i18n/use-locale.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `useLocale` / `useSetLocale` / `useLocaleState` / `useLocales` — the Vue twins of
+ * `@chelone/react`'s locale hooks (`i18n-hooks.ts`). The locale is a readonly
+ * ref fed by `i18n.subscribe`, so any computed or template that reads it
+ * re-evaluates on `setLocale`.
+ *
+ * Unlike the React twin, `useLocale` gives `"en"` without an i18n instance
+ * instead of throwing: components such as the currency field and input render
+ * without one. `useSetLocale` still throws then, as there is nothing to set.
+ */
+import { type Ref } from "vue";
+/** The app locale as a readonly ref, `"en"` when no i18n was passed to `<Admin>`. */
+export declare function useLocale(): Readonly<Ref<string>>;
+/** A stable `setLocale`. Throws when no i18n was passed to `<Admin>`. */
+export declare function useSetLocale(): (locale: string) => void;
+/** The `[locale, setLocale]` pair. */
+export declare function useLocaleState(): [
+    Readonly<Ref<string>>,
+    (locale: string) => void
+];
+/**
+ * The locales the i18n instance registers, each named in its own language
+ * ("Deutsch", not "German") so a user lost in the wrong language can find theirs.
+ *
+ * `getLocales()` returns bare codes. A code `Intl` rejects keeps the code as its
+ * name. Without an i18n instance the list is empty rather than throwing, so
+ * `<AppBar>` keeps rendering in an app that never passed one.
+ */
+export declare function useLocales(): {
+    locale: string;
+    name: string;
+}[];