nuxt-ui-tools 0.1.0

package/dist/runtime/form/composables/use-form-runtime.js

@@ -0,0 +1,403 @@
+import { computed, inject, provide, ref, watch } from "vue";
+import { createPublicFormApi } from "../utils/api.js";
+import { resolveFieldDependencies } from "../utils/dependencies.js";
+import { resolveFormLayoutConfig } from "../utils/layout.js";
+import { isRecord } from "../utils/path.js";
+import {
+  childParentPath,
+  collectFormFieldPaths,
+  collectFormFieldsPaths,
+  fieldPath,
+  getSchemaFields,
+  getSchemaLayout,
+  getSchemaSteps,
+  isSteppedSchema,
+  shouldRenderField
+} from "../utils/state.js";
+import { getSchemaContext, useFormContextResources } from "./use-form-context-resources.js";
+import { useFormFocus } from "./use-form-focus.js";
+import { useFormOptionRegistry } from "./use-form-option-registry.js";
+import { useFormState } from "./use-form-state.js";
+import { useFormSubmitController } from "./use-form-submit.js";
+import { useFormUploadRegistry } from "./use-form-upload-registry.js";
+import { useFormValidation } from "./use-form-validation.js";
+const formRuntimeKey = Symbol("nuxt-ui-tools-form-runtime");
+export function provideFormRuntime(runtime) {
+  provide(formRuntimeKey, runtime);
+}
+export function useFormRuntimeContext() {
+  const runtime = inject(formRuntimeKey);
+  if (!runtime) throw new Error("Form runtime is not provided.");
+  return runtime;
+}
+export function useFormRuntime(params) {
+  const { context, setContext } = useFormContextResources();
+  const optionRegistry = useFormOptionRegistry();
+  const uploadRegistry = useFormUploadRegistry();
+  const currentStepIndex = ref(0);
+  const navigationActionPending = ref(null);
+  setContext(getSchemaContext(params.schema.value));
+  const apiFactory = (path, field) => createFieldApi({
+    path,
+    field,
+    getValue: state.getValue,
+    setValue: state.setValue,
+    resetValue: state.resetValue,
+    ctx: context,
+    state: state.state,
+    optionRegistry,
+    uploadRegistry,
+    focusField: () => focus.focusField(path),
+    setExternalError: (message) => validation.setError(path, message),
+    clearExternalError: () => validation.clearError(path),
+    validateField: () => field ? validation.validateFields([field], path.slice(0, -1)) : Promise.resolve(true)
+  });
+  const state = useFormState({
+    schema: params.schema,
+    input: params.input,
+    context,
+    apiFactory
+  });
+  const validation = useFormValidation({
+    schema: () => params.schema.value,
+    state: state.state,
+    context,
+    apiFactory,
+    getValidationMode: () => params.validationMode?.value ?? true
+  });
+  const focus = useFormFocus({
+    getErrors: () => validation.errors.value
+  });
+  async function validate(options) {
+    const valid = await validation.validate();
+    if (!valid && options?.focus) await focus.focusFirstInvalid();
+    return valid;
+  }
+  async function validateCurrentStep(options) {
+    const valid = await validation.validateFields(
+      currentFields.value,
+      currentStepRoot.value ? [currentStepRoot.value] : []
+    );
+    if (!valid && options?.focus) await focus.focusFirstInvalid();
+    return valid;
+  }
+  const submit = useFormSubmitController({
+    validate: () => {
+      validation.markAllTouched(collectFormFieldPaths(params.schema.value));
+      return validate();
+    },
+    focusFirstInvalid: focus.focusFirstInvalid,
+    getOutput: () => state.output.value,
+    getApi: () => createPublicFormApi(runtime),
+    getSchema: () => params.schema.value,
+    getContext: () => context
+  });
+  state.initialize();
+  if (params.input)
+    watch(params.input, (input) => state.syncInput(input, params.syncInput?.value ?? false), {
+      deep: true
+    });
+  watch(params.schema, (schema) => {
+    currentStepIndex.value = 0;
+    validation.clearError();
+    setContext(getSchemaContext(schema));
+    state.initialize(params.input?.value);
+  });
+  const currentFields = computed(() => {
+    if (!isSteppedSchema(params.schema.value)) return getSchemaFields(params.schema.value);
+    return getSchemaSteps(params.schema.value)[currentStepIndex.value]?.fields ?? [];
+  });
+  const currentStepRoot = computed(() => {
+    if (!isSteppedSchema(params.schema.value)) return void 0;
+    return getSchemaSteps(params.schema.value)[currentStepIndex.value]?.root;
+  });
+  const currentLayout = computed(() => {
+    const schemaLayout = getSchemaLayout(params.schema.value);
+    if (!isSteppedSchema(params.schema.value)) return resolveFormLayoutConfig(schemaLayout);
+    return resolveFormLayoutConfig(
+      schemaLayout,
+      getSchemaSteps(params.schema.value)[currentStepIndex.value]?.layout
+    );
+  });
+  const steps = computed(
+    () => getSchemaSteps(params.schema.value).map((step, index) => ({
+      key: step.key ?? String(index + 1),
+      label: typeof step.title === "function" ? String(step.title()) : String(step.title ?? step.key ?? `Step ${index + 1}`),
+      active: currentStepIndex.value === index,
+      index,
+      root: step.root
+    }))
+  );
+  const currentStep = computed(() => steps.value[currentStepIndex.value] ?? null);
+  const isStepped = computed(() => isSteppedSchema(params.schema.value));
+  const isFirstStep = computed(() => currentStepIndex.value <= 0);
+  const isLastStep = computed(() => currentStepIndex.value >= steps.value.length - 1);
+  const canGoPrevious = computed(() => isStepped.value && !isFirstStep.value);
+  const canGoNext = computed(() => isStepped.value && !isLastStep.value);
+  const actionPending = computed(() => navigationActionPending.value ?? submit.actionPending.value);
+  async function runBeforeNext() {
+    const handler = getSchemaLifecycleHandler(params.schema.value, "onBeforeNext");
+    if (!handler) return true;
+    try {
+      const result = await withNavigationPending(
+        "next",
+        () => handler(createStepLifecycleParams(currentStepIndex.value))
+      );
+      return result !== false;
+    } catch {
+      return false;
+    }
+  }
+  async function runBeforePrevious() {
+    const handler = getSchemaLifecycleHandler(params.schema.value, "onBeforePrevious");
+    if (!handler) return true;
+    try {
+      await withNavigationPending(
+        "previous",
+        () => handler(createStepLifecycleParams(currentStepIndex.value))
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async function withNavigationPending(action, callback) {
+    navigationActionPending.value = action;
+    try {
+      return await callback();
+    } finally {
+      navigationActionPending.value = null;
+    }
+  }
+  function resolveNextStepIndex() {
+    let targetIndex = currentStepIndex.value + 1;
+    const schemaSteps = getSchemaSteps(params.schema.value);
+    while (targetIndex < schemaSteps.length && shouldSkipStep(targetIndex)) {
+      notifyStepSkipped(targetIndex);
+      targetIndex += 1;
+    }
+    return targetIndex < schemaSteps.length ? targetIndex : null;
+  }
+  function resolvePreviousStepIndex() {
+    let targetIndex = currentStepIndex.value - 1;
+    while (targetIndex >= 0 && shouldSkipStep(targetIndex)) {
+      notifyStepSkipped(targetIndex);
+      targetIndex -= 1;
+    }
+    return targetIndex >= 0 ? targetIndex : null;
+  }
+  function shouldSkipStep(stepIndex) {
+    const handler = getSchemaLifecycleHandler(params.schema.value, "skipStep");
+    return handler ? handler(createStepLifecycleParams(stepIndex)) === true : false;
+  }
+  function notifyStepSkipped(stepIndex) {
+    const handler = getSchemaLifecycleHandler(params.schema.value, "onStepSkipped");
+    handler?.(createStepLifecycleParams(stepIndex));
+  }
+  function createStepLifecycleParams(stepIndex) {
+    return {
+      step: getSchemaSteps(params.schema.value)[stepIndex],
+      stepIndex,
+      formData: state.output.value,
+      stepData: state.output.value,
+      api: createPublicFormApi(runtime)
+    };
+  }
+  const runtime = {
+    schema: params.schema,
+    state: state.state,
+    output: state.output,
+    dirtyPaths: state.dirtyPaths,
+    isDirty: state.isDirty,
+    errors: validation.errors,
+    context,
+    actionPending,
+    currentStepIndex,
+    currentFields,
+    currentStepRoot,
+    currentLayout,
+    currentStep,
+    steps,
+    isStepped,
+    isFirstStep,
+    isLastStep,
+    canGoPrevious,
+    canGoNext,
+    getValue: state.getValue,
+    setValue: state.setValue,
+    getFieldApi: apiFactory,
+    getFieldCallbackParams: (path, field) => fieldCallbackParams({
+      field,
+      state: state.state,
+      ctx: context,
+      api: apiFactory(path, field),
+      parentPath: path.slice(0, -1)
+    }),
+    registerFieldOptions: optionRegistry.register,
+    registerFieldUpload: uploadRegistry.register,
+    refreshFieldOptions: optionRegistry.refreshMany,
+    getFieldError: validation.getFieldError,
+    markFieldTouched: validation.markTouched,
+    isFieldTouched: validation.isTouched,
+    shouldRender: (field, path) => shouldRenderField(
+      field,
+      fieldCallbackParams({
+        field,
+        state: state.state,
+        ctx: context,
+        api: apiFactory(path, field),
+        parentPath: path.slice(0, -1)
+      })
+    ),
+    validate,
+    validateCurrentStep,
+    focusRequest: focus.request,
+    registerFieldElement: focus.registerField,
+    focusField: focus.focusField,
+    focusFirstInvalid: focus.focusFirstInvalid,
+    clearErrors: () => validation.clearError(),
+    submitHandler: submit.submitHandler,
+    submit: async () => {
+      const result = await submit.submitHandler();
+      return result.success;
+    },
+    reset: () => {
+      validation.clearError();
+      state.reset();
+    },
+    nextStep: async () => {
+      validation.markAllTouched(
+        collectFormFieldsPaths(
+          currentFields.value,
+          currentStepRoot.value ? [currentStepRoot.value] : []
+        )
+      );
+      const valid = await validateCurrentStep({ focus: true });
+      if (!valid) return false;
+      const canProceed = await runBeforeNext();
+      if (!canProceed) return false;
+      const nextIndex = resolveNextStepIndex();
+      if (nextIndex === null) return false;
+      currentStepIndex.value = nextIndex;
+      return true;
+    },
+    previousStep: async () => {
+      const canProceed = await runBeforePrevious();
+      if (!canProceed) return false;
+      const previousIndex = resolvePreviousStepIndex();
+      if (previousIndex === null) return false;
+      currentStepIndex.value = previousIndex;
+      return true;
+    },
+    goToStep: async (index) => {
+      const nextIndex = Math.min(Math.max(index, 0), steps.value.length - 1);
+      if (nextIndex === currentStepIndex.value) return true;
+      if (nextIndex > currentStepIndex.value) {
+        validation.markAllTouched(
+          collectFormFieldsPaths(
+            currentFields.value,
+            currentStepRoot.value ? [currentStepRoot.value] : []
+          )
+        );
+        const valid = await validateCurrentStep({ focus: true });
+        if (!valid) return false;
+        const canProceed = await runBeforeNext();
+        if (!canProceed) return false;
+      }
+      currentStepIndex.value = nextIndex;
+      return true;
+    }
+  };
+  return runtime;
+}
+function createFieldApi(params) {
+  function contextResource(key) {
+    const resource = params.ctx[key];
+    if (!resource) throw new Error(`Unknown form context resource: ${key}`);
+    return resource;
+  }
+  const api = {
+    value: {
+      get: () => params.getValue(params.path),
+      set: (value) => params.setValue(params.path, value),
+      reset: () => params.resetValue(params.path)
+    },
+    options: {
+      get: () => params.optionRegistry.get(params.path).items.value,
+      pending: () => params.optionRegistry.get(params.path).pending.value,
+      fetching: () => params.optionRegistry.get(params.path).fetching.value,
+      loading: () => params.optionRegistry.get(params.path).loading.value,
+      creating: () => params.optionRegistry.get(params.path).creating.value,
+      refreshable: () => params.optionRegistry.get(params.path).refreshable.value,
+      error: () => params.optionRegistry.get(params.path).error.value,
+      refresh: () => params.optionRegistry.get(params.path).refresh(),
+      add: (option) => params.optionRegistry.get(params.path).add(option),
+      create: (label) => params.optionRegistry.get(params.path).create(label)
+    },
+    upload: {
+      start: async () => await params.uploadRegistry.get(params.path)?.start(),
+      cancel: async () => await params.uploadRegistry.get(params.path)?.cancel(),
+      retry: async () => await params.uploadRegistry.get(params.path)?.retry(),
+      remove: async (value) => await params.uploadRegistry.get(params.path)?.remove(value)
+    },
+    context: {
+      get: (key) => contextResource(key),
+      set: (key, value) => {
+        contextResource(key).value = value;
+      },
+      update: (key, updater) => {
+        updateContextResourceValue(contextResource(key), updater);
+      },
+      patch: (key, value) => patchContextResourceValue(contextResource(key), value),
+      refresh: async (key) => {
+        const resource = params.ctx[key];
+        if (isRefreshableResource(resource)) await resource.refresh();
+      },
+      refreshAll: async () => {
+        const refreshTasks = Object.values(params.ctx).map(
+          (resource) => isRefreshableResource(resource) ? resource.refresh() : Promise.resolve()
+        );
+        await Promise.all(refreshTasks);
+      }
+    },
+    validation: {
+      validate: params.validateField,
+      setError: params.setExternalError,
+      clearError: params.clearExternalError
+    },
+    focus: params.focusField
+  };
+  return api;
+}
+function updateContextResourceValue(resource, updater) {
+  resource.value = updater(resource.value);
+}
+function patchContextResourceValue(resource, patch) {
+  if (!isContextValueResource(resource)) return;
+  const current = resource.value;
+  const patchValue = typeof patch === "function" ? patch(current) : patch;
+  if (isRecord(current) && isRecord(patchValue)) {
+    resource.value = { ...current, ...patchValue };
+    return;
+  }
+  resource.value = patchValue;
+}
+function isContextValueResource(value) {
+  return typeof value === "object" && value !== null && "value" in value;
+}
+function isRefreshableResource(value) {
+  return typeof value === "object" && value !== null && "refresh" in value && typeof value.refresh === "function";
+}
+function getSchemaLifecycleHandler(schema, key) {
+  if (!isRecord(schema)) return void 0;
+  const handler = Object.getOwnPropertyDescriptor(schema, key)?.value;
+  return typeof handler === "function" ? handler : void 0;
+}
+function fieldCallbackParams(params) {
+  return {
+    ctx: params.ctx,
+    deps: resolveFieldDependencies(params),
+    api: params.api
+  };
+}
+export { childParentPath, fieldPath };

package/dist/runtime/form/composables/use-form-state.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef } from 'vue';
+import type { FormField, FormFieldApi, FormObject } from '../types/index.js';
+import type { FormRuntimeContext } from '../types/index.js';
+export type FormFieldApiFactory = (path: readonly string[], field?: FormField) => FormFieldApi;
+export declare function useFormState(params: {
+    schema: ComputedRef<unknown>;
+    input?: ComputedRef<FormObject | undefined>;
+    context: FormRuntimeContext;
+    apiFactory: FormFieldApiFactory;
+}): {
+    state: import("../../shared/index.js").GenericObject;
+    output: ComputedRef<import("../../shared/index.js").GenericObject>;
+    dirtyPaths: ComputedRef<readonly string[]>;
+    isDirty: ComputedRef<boolean>;
+    initialize: (input?: import("../../shared/index.js").GenericObject | undefined) => void;
+    syncInput: (input: FormObject | undefined, paths: boolean | readonly string[]) => void;
+    reset: () => void;
+    resetValue: (path: string | readonly string[]) => void;
+    getValue: (path: string | readonly string[]) => unknown;
+    setValue: (path: string | readonly string[], value: unknown) => void;
+};

package/dist/runtime/form/composables/use-form-state.js

@@ -0,0 +1,76 @@
+import { computed, reactive, ref } from "vue";
+import { cloneFormValue, getPathValue, isRecord, setPathValue } from "../utils/path.js";
+import { buildFormOutput, buildInitialFormState } from "../utils/state.js";
+export function useFormState(params) {
+  const state = reactive({});
+  const initialState = ref({});
+  const output = computed(
+    () => buildFormOutput(params.schema.value, state, params.context, params.apiFactory)
+  );
+  const dirtyPaths = computed(() => collectDirtyPaths(initialState.value, state));
+  const isDirty = computed(() => dirtyPaths.value.length > 0);
+  function initialize(input = params.input?.value) {
+    for (const key of Object.keys(state)) delete state[key];
+    const initial = buildInitialFormState(params.schema.value, params.context, input);
+    initialState.value = cloneFormObject(initial);
+    for (const [key, value] of Object.entries(initial)) state[key] = value;
+  }
+  function reset() {
+    initialize();
+  }
+  function resetValue(path) {
+    setPathValue(state, path, cloneFormValue(getPathValue(initialState.value, path)));
+  }
+  function syncInput(input, paths) {
+    if (!paths || Array.isArray(paths) && paths.length === 0) return;
+    if (paths === true) {
+      initialize(input);
+      return;
+    }
+    const next = buildInitialFormState(params.schema.value, params.context, input);
+    for (const path of paths) {
+      const value = cloneFormValue(getPathValue(next, path));
+      setPathValue(state, path, value);
+      setPathValue(initialState.value, path, cloneFormValue(value));
+    }
+  }
+  return {
+    state,
+    output,
+    dirtyPaths,
+    isDirty,
+    initialize,
+    syncInput,
+    reset,
+    resetValue,
+    getValue: (path) => getPathValue(state, path),
+    setValue: (path, value) => setPathValue(state, path, value)
+  };
+}
+function cloneFormObject(value) {
+  const cloned = cloneFormValue(value);
+  return isRecord(cloned) ? cloned : {};
+}
+function collectDirtyPaths(initial, current, path = []) {
+  if (Array.isArray(initial) || Array.isArray(current))
+    return collectArrayDirtyPaths(
+      Array.isArray(initial) ? initial : [],
+      Array.isArray(current) ? current : [],
+      path
+    );
+  if (isRecord(initial) || isRecord(current)) {
+    const initialObject = isRecord(initial) ? initial : {};
+    const currentObject = isRecord(current) ? current : {};
+    const keys = /* @__PURE__ */ new Set([...Object.keys(initialObject), ...Object.keys(currentObject)]);
+    return [...keys].flatMap(
+      (key) => collectDirtyPaths(initialObject[key], currentObject[key], [...path, key])
+    );
+  }
+  return Object.is(initial, current) ? [] : [path.join(".")];
+}
+function collectArrayDirtyPaths(initial, current, path) {
+  if (initial.length !== current.length) return [path.join(".")];
+  return current.flatMap(
+    (value, index) => collectDirtyPaths(initial[index], value, [...path, String(index)])
+  );
+}

package/dist/runtime/form/composables/use-form-submit.d.ts

@@ -0,0 +1,23 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { GenericObject } from '../../shared/types/utils.js';
+import type { ExtractFormOutput, FormApi, FormContextData, FormObject, FormSubmitAction, FormSubmitHandler, FormSubmitHandlerResult, FormSubmitTarget } from '../types/index.js';
+export declare function useFormSubmit<const TSchema extends GenericObject, TSubmitData = unknown>(params: {
+    formRef: Ref<FormSubmitTarget<ExtractFormOutput<TSchema>, TSubmitData> | null | undefined>;
+    schema: MaybeRefOrGetter<TSchema>;
+    onSubmit: FormSubmitHandler<ExtractFormOutput<TSchema>, TSubmitData>;
+}): {
+    schema: import("vue").ComputedRef<TSchema>;
+    submit: () => Promise<boolean>;
+    isSubmitting: import("vue").ComputedRef<boolean>;
+};
+export declare function useFormSubmitController<TSubmitData = unknown>(params: {
+    validate: () => Promise<boolean>;
+    focusFirstInvalid?: () => Promise<boolean>;
+    getOutput: () => FormObject;
+    getApi: () => FormApi;
+    getSchema: () => unknown;
+    getContext: () => FormContextData;
+}): {
+    actionPending: import("vue").ComputedRef<FormSubmitAction | null>;
+    submitHandler: (externalSubmitHandler?: FormSubmitHandler<FormObject, TSubmitData>) => Promise<FormSubmitHandlerResult<TSubmitData>>;
+};

package/dist/runtime/form/composables/use-form-submit.js

@@ -0,0 +1,71 @@
+import { computed, ref, toValue } from "vue";
+import { isRecord } from "../utils/path.js";
+export function useFormSubmit(params) {
+  const isSubmitting = computed(() => params.formRef.value?.actionPending.value === "submit");
+  async function submit() {
+    const form = params.formRef.value;
+    if (!form) return false;
+    const result = await form.submitHandler(params.onSubmit);
+    return result.success;
+  }
+  return {
+    schema: computed(() => toValue(params.schema)),
+    submit,
+    isSubmitting
+  };
+}
+export function useFormSubmitController(params) {
+  const actionPending = ref(null);
+  async function submitHandler(externalSubmitHandler) {
+    const isValid = await params.validate();
+    if (!isValid) {
+      await params.focusFirstInvalid?.();
+      return { success: false };
+    }
+    try {
+      actionPending.value = "submit";
+      const beforeSubmit = getBeforeSubmit(params.getSchema());
+      const beforeResult = await beforeSubmit?.({
+        formData: params.getOutput(),
+        api: params.getApi()
+      });
+      if (isCancelled(beforeResult)) return { success: false };
+      const schemaSubmit = getSchemaSubmit(params.getSchema());
+      await schemaSubmit?.({
+        value: params.getOutput(),
+        api: params.getApi(),
+        ctx: params.getContext()
+      });
+      const result = await externalSubmitHandler?.({
+        formData: params.getOutput(),
+        api: params.getApi()
+      });
+      return normalizeSubmitResult(result);
+    } finally {
+      actionPending.value = null;
+    }
+  }
+  return {
+    actionPending: computed(() => actionPending.value),
+    submitHandler
+  };
+}
+function normalizeSubmitResult(result) {
+  if (result === false) return { success: false };
+  if (isRecord(result) && result.success === false) return { success: false };
+  if (isRecord(result) && result.success === true) return { success: true, data: result.data };
+  return { success: true };
+}
+function isCancelled(result) {
+  return result === false || isRecord(result) && result.success === false;
+}
+function getBeforeSubmit(schema) {
+  if (!isRecord(schema)) return void 0;
+  const handler = Object.getOwnPropertyDescriptor(schema, "onBeforeSubmit")?.value;
+  return typeof handler === "function" ? handler : void 0;
+}
+function getSchemaSubmit(schema) {
+  if (!isRecord(schema)) return void 0;
+  const submit = Object.getOwnPropertyDescriptor(schema, "submit")?.value;
+  return typeof submit === "function" ? submit : void 0;
+}

package/dist/runtime/form/composables/use-form-ui.d.ts

@@ -0,0 +1,12 @@
+import { type ComputedRef } from 'vue';
+import type { FormControlSize, FormDensity, FormUiConfig } from '../types/index.js';
+export declare function provideFormUi(ui: ComputedRef<FormUiConfig>): {
+    ui: ComputedRef<FormUiConfig>;
+    density: ComputedRef<FormDensity>;
+    controlSize: ComputedRef<FormControlSize>;
+};
+export declare function useFormUi(): {
+    ui: ComputedRef<FormUiConfig>;
+    density: ComputedRef<FormDensity>;
+    controlSize: ComputedRef<FormControlSize>;
+};

package/dist/runtime/form/composables/use-form-ui.js

@@ -0,0 +1,24 @@
+import { createInjectionState } from "@vueuse/core";
+import { computed } from "vue";
+const densitySizes = {
+  compact: "sm",
+  default: "md",
+  comfortable: "lg"
+};
+const [provideFormUiState, useInjectedFormUiState] = createInjectionState(
+  (ui) => {
+    const density = computed(() => ui.value.density ?? "default");
+    const controlSize = computed(
+      () => ui.value.control?.size ?? densitySizes[density.value]
+    );
+    return { ui, density, controlSize };
+  }
+);
+export function provideFormUi(ui) {
+  return provideFormUiState(ui);
+}
+export function useFormUi() {
+  const state = useInjectedFormUiState();
+  if (!state) throw new Error("useFormUi must be called inside a <NutForm> component");
+  return state;
+}

package/dist/runtime/form/composables/use-form-upload-registry.d.ts

@@ -0,0 +1,5 @@
+import type { FormUploadRuntimeState } from '../types/index.js';
+export declare function useFormUploadRegistry(): {
+    register: (path: readonly string[], state: FormUploadRuntimeState) => () => void;
+    get: (path: readonly string[]) => FormUploadRuntimeState;
+};

package/dist/runtime/form/composables/use-form-upload-registry.js

@@ -0,0 +1,15 @@
+import { shallowReactive } from "vue";
+export function useFormUploadRegistry() {
+  const states = shallowReactive({});
+  function register(path, state) {
+    const key = path.join(".");
+    states[key] = state;
+    return () => {
+      if (states[key] === state) delete states[key];
+    };
+  }
+  function get(path) {
+    return states[path.join(".")];
+  }
+  return { register, get };
+}

package/dist/runtime/form/composables/use-form-validation.d.ts

@@ -0,0 +1,22 @@
+import type { FormField, FormObject, FormRuntimeContext, FormValidationMode } from '../types/index.js';
+import type { FormFieldApiFactory } from './use-form-state.js';
+export declare function useFormValidation(params: {
+    schema: () => unknown;
+    state: FormObject;
+    context: FormRuntimeContext;
+    apiFactory: FormFieldApiFactory;
+    getValidationMode: () => FormValidationMode;
+}): {
+    errors: import("vue").ComputedRef<{
+        path: string;
+        message: string;
+    }[]>;
+    validate: () => Promise<boolean>;
+    validateFields: (fields: readonly FormField[], parentPath: readonly string[]) => Promise<boolean>;
+    getFieldError: (path: readonly string[]) => string | undefined;
+    setError: (path: readonly string[], message: string) => void;
+    clearError: (path?: readonly string[]) => void;
+    markTouched: (path: readonly string[]) => void;
+    markAllTouched: (paths: readonly string[]) => void;
+    isTouched: (path: readonly string[]) => boolean;
+};