nuxt-ui-tools 0.1.2 → 1.0.0

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

@@ -1,13 +1,17 @@
-import { computed, inject, provide, ref, watch } from "vue";
+import { computed, inject, nextTick, provide, ref, watch } from "vue";
+import { useUiToolsLocale } from "../../i18n/use-locale.js";
 import { createPublicFormApi } from "../utils/api.js";
 import { resolveFieldDependencies } from "../utils/dependencies.js";
 import { resolveFormLayoutConfig } from "../utils/layout.js";
-import { isRecord, pathSegments } from "../utils/path.js";
 import {
-  childParentPath,
-  collectFormFieldPaths,
-  collectFormFieldsPaths,
-  fieldPath,
+  getPathValue,
+  isRecord,
+  pathSegments,
+  relativePathSegments,
+  setPathValue
+} from "../utils/path.js";
+import { isFunction, isObject, isPromise, isUndefined, stringArray } from "../utils/predicate.js";
+import {
   getSchemaFields,
   getSchemaLayout,
   getSchemaSteps,
@@ -18,16 +22,19 @@ import { getSchemaContext, useFormContextResources } from "./use-form-context-re
 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 { useFormSubmission } from "./use-form-submission.js";
 import { useFormUploadRegistry } from "./use-form-upload-registry.js";
 import { useFormValidation } from "./use-form-validation.js";
+export { childParentPath, fieldPath } from "../utils/state.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.");
+  if (!runtime) {
+    throw new Error("Form runtime is not provided.");
+  }
   return runtime;
 }
 export function useFormRuntime(params) {
@@ -36,41 +43,88 @@ export function useFormRuntime(params) {
   const uploadRegistry = useFormUploadRegistry();
   const currentStepIndex = ref(0);
   const navigationActionPending = ref(null);
+  const effects = createEffectLifecycle();
+  const { t } = useUiToolsLocale();
   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)
+  function createFormNamespace(path, read) {
+    const parentPath = path.slice(0, -1);
+    function resolve(target) {
+      return resolveRelativeFieldPath(parentPath, target);
+    }
+    return {
+      clearError: (target) => runtime.clearError(target ? resolve(target) : void 0),
+      focus: (target) => runtime.focusField(resolve(target)),
+      get: (target) => read.getValue(resolve(target)),
+      initial: (target) => read.getInitialValue(resolve(target)),
+      nextStep: () => runtime.nextStep(),
+      output: () => runtime.output.value,
+      previousStep: () => runtime.previousStep(),
+      reset: () => runtime.reset(),
+      set: (target, value) => read.setValue(resolve(target), value),
+      setError: (target, message, options) => runtime.setError(resolve(target), message, options),
+      state: () => read.state(),
+      submit: () => runtime.submit(),
+      validate: () => runtime.validate()
+    };
+  }
+  function createApiFactory(read) {
+    return (path, field) => createFieldApi({
+      clearExternalError: () => validation.clearError(path),
+      ctx: context,
+      field,
+      focusField: () => focus.focusField(path),
+      form: createFormNamespace(path, read),
+      getInitialValue: read.getInitialValue,
+      getValue: read.getValue,
+      optionRegistry,
+      path,
+      pendingField: () => validation.isPending(path),
+      resetValue: state.resetValue,
+      setExternalError: (message, options) => validation.setError(path, message, options),
+      setValue: read.setValue,
+      state: read.state(),
+      uploadRegistry,
+      validateField: () => field ? validation.validateFields([field], path.slice(0, -1)) : Promise.resolve(true)
+    });
+  }
+  const apiFactory = createApiFactory({
+    getInitialValue: (target) => state.getInitialValue(target),
+    getValue: (target) => state.getValue(target),
+    setValue: (target, value) => state.setValue(target, value),
+    state: () => state.state
   });
   const state = useFormState({
-    schema: params.schema,
-    input: params.input,
+    apiFactory,
+    bootstrapApiFactory: (draft, initial) => createApiFactory({
+      getInitialValue: (target) => getPathValue(initial, target),
+      getValue: (target) => getPathValue(draft, target),
+      setValue: (target, value) => setPathValueOf(draft, target, value),
+      state: () => draft
+    }),
     context,
-    apiFactory
+    ignoreDirtyPaths: () => getSchemaIgnoredDirtyPaths(params.schema.value),
+    input: params.input,
+    schema: params.schema
   });
   const validation = useFormValidation({
-    schema: () => params.schema.value,
-    state: state.state,
-    context,
     apiFactory,
-    getValidationMode: () => params.validationMode?.value ?? true
+    context,
+    getDateMaxMessage: (max) => t("form.validation.dateMax", { max }),
+    getDateMinMessage: (min) => t("form.validation.dateMin", { min }),
+    getRequiredMessage: () => t("form.validation.required"),
+    getUniqueMessage: () => t("form.fields.array.unique"),
+    getValidationMode: () => params.validationMode?.value ?? true,
+    schema: () => params.schema.value,
+    state: state.state
   });
   const focus = useFormFocus({
-    getErrors: () => validation.errors.value
+    getErrors: () => validation.validationErrors.value
   });
   async function validate(options) {
     const valid = await validation.validate();
-    if (!valid && options?.focus) await focus.focusFirstInvalid();
+    if (!valid && options?.focus) {
+      await focus.focusFirstInvalid();
+    }
     return valid;
   }
   async function validateCurrentStep(options) {
@@ -78,35 +132,52 @@ export function useFormRuntime(params) {
       currentFields.value,
       currentStepRoot.value ? [currentStepRoot.value] : []
     );
-    if (!valid && options?.focus) await focus.focusFirstInvalid();
+    if (!valid && options?.focus) {
+      await focus.focusFirstInvalid();
+    }
     return valid;
   }
-  const submit = useFormSubmitController({
-    validate: () => {
-      validation.markAllTouched(collectFormFieldPaths(params.schema.value));
-      return validate();
-    },
+  const submit = useFormSubmission({
+    beforeNext: () => isStepped.value ? runBeforeNext() : Promise.resolve(true),
     focusFirstInvalid: focus.focusFirstInvalid,
-    getOutput: () => state.output.value,
     getApi: () => createPublicFormApi(runtime),
+    getContext: () => context,
+    getOutput: () => state.output.value,
     getSchema: () => params.schema.value,
-    getContext: () => context
+    validate
   });
-  let hasInitializedInput = typeof params.input?.value !== "undefined";
+  let hasInitializedInput = !isUndefined(params.input?.value);
   state.initialize(params.input?.value);
-  if (params.input)
+  let pendingInput;
+  if (params.input) {
     watch(
       params.input,
       (input) => {
-        if (!hasInitializedInput && typeof input !== "undefined") {
+        if (!hasInitializedInput && !isUndefined(input)) {
           hasInitializedInput = true;
           state.initialize(input);
           return;
         }
-        state.syncInput(input, params.syncInput?.value ?? false);
+        const paths = params.syncInput?.value ?? false;
+        if (isSyncEnabled(paths)) {
+          pendingInput = void 0;
+          state.syncInput(input, paths);
+          return;
+        }
+        pendingInput = input;
       },
       { deep: true }
     );
+  }
+  if (params.syncInput) {
+    watch(params.syncInput, (paths) => {
+      if (!isSyncEnabled(paths) || isUndefined(pendingInput)) {
+        return;
+      }
+      state.syncInput(pendingInput, paths);
+      pendingInput = void 0;
+    });
+  }
   watch(params.schema, (schema) => {
     currentStepIndex.value = 0;
     validation.clearError();
@@ -114,16 +185,22 @@ export function useFormRuntime(params) {
     state.initialize(params.input?.value);
   });
   const currentFields = computed(() => {
-    if (!isSteppedSchema(params.schema.value)) return getSchemaFields(params.schema.value);
+    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;
+    if (!isSteppedSchema(params.schema.value)) {
+      return;
+    }
     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);
+    if (!isSteppedSchema(params.schema.value)) {
+      return resolveFormLayoutConfig(schemaLayout);
+    }
     return resolveFormLayoutConfig(
       schemaLayout,
       getSchemaSteps(params.schema.value)[currentStepIndex.value]?.layout
@@ -131,10 +208,10 @@ export function useFormRuntime(params) {
   });
   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,
+      key: step.key ?? String(index + 1),
+      label: isFunction(step.title) ? String(step.title()) : String(step.title ?? step.key ?? `Step ${index + 1}`),
       root: step.root
     }))
   );
@@ -147,12 +224,11 @@ export function useFormRuntime(params) {
   const actionPending = computed(() => navigationActionPending.value ?? submit.actionPending.value);
   async function runBeforeNext() {
     const handler = getSchemaLifecycleHandler(params.schema.value, "onBeforeNext");
-    if (!handler) return true;
+    if (!handler) {
+      return true;
+    }
     try {
-      const result = await withNavigationPending(
-        "next",
-        () => handler(createStepLifecycleParams(currentStepIndex.value))
-      );
+      const result = await handler(createStepLifecycleParams(currentStepIndex.value));
       return result !== false;
     } catch {
       return false;
@@ -160,12 +236,11 @@ export function useFormRuntime(params) {
   }
   async function runBeforePrevious() {
     const handler = getSchemaLifecycleHandler(params.schema.value, "onBeforePrevious");
-    if (!handler) return true;
+    if (!handler) {
+      return true;
+    }
     try {
-      await withNavigationPending(
-        "previous",
-        () => handler(createStepLifecycleParams(currentStepIndex.value))
-      );
+      await handler(createStepLifecycleParams(currentStepIndex.value));
       return true;
     } catch {
       return false;
@@ -206,178 +281,300 @@ export function useFormRuntime(params) {
   }
   function createStepLifecycleParams(stepIndex) {
     return {
-      step: getSchemaSteps(params.schema.value)[stepIndex],
-      stepIndex,
+      api: createPublicFormApi(runtime),
       formData: state.output.value,
+      step: getSchemaSteps(params.schema.value)[stepIndex],
       stepData: state.output.value,
-      api: createPublicFormApi(runtime)
+      stepIndex
     };
   }
   const runtime = {
-    schema: params.schema,
-    state: state.state,
-    output: state.output,
-    dirtyPaths: state.dirtyPaths,
-    isDirty: state.isDirty,
-    errors: validation.errors,
-    context,
     actionPending,
-    currentStepIndex,
+    canGoNext,
+    canGoPrevious,
+    clearError: (path) => validation.clearError(path ? pathSegments(path) : void 0),
+    clearErrors: () => validation.clearError(),
+    context,
     currentFields,
-    currentStepRoot,
     currentLayout,
     currentStep,
-    steps,
-    isStepped,
-    isFirstStep,
-    isLastStep,
-    canGoPrevious,
-    canGoNext,
-    getValue: state.getValue,
-    setValue: state.setValue,
+    currentStepIndex,
+    currentStepRoot,
+    dirtyPaths: state.dirtyPaths,
+    errors: validation.errors,
+    focusField: focus.focusField,
+    focusFirstInvalid: focus.focusFirstInvalid,
+    focusRequest: focus.request,
     getFieldApi: apiFactory,
     getFieldCallbackParams: (path, field) => fieldCallbackParams({
-      field,
-      state: state.state,
-      ctx: context,
       api: apiFactory(path, field),
-      parentPath: path.slice(0, -1)
+      ctx: context,
+      field,
+      parentPath: path.slice(0, -1),
+      state: state.state
     }),
-    registerFieldOptions: optionRegistry.register,
-    registerFieldUpload: uploadRegistry.register,
-    refreshFieldOptions: optionRegistry.refreshMany,
     getFieldError: validation.getFieldError,
-    markFieldTouched: validation.markTouched,
+    getInitialValue: state.getInitialValue,
+    getValue: state.getValue,
+    goToStep: async (index) => {
+      if (actionPending.value) {
+        return false;
+      }
+      const nextIndex = Math.min(Math.max(index, 0), steps.value.length - 1);
+      if (nextIndex === currentStepIndex.value) {
+        return true;
+      }
+      if (nextIndex > currentStepIndex.value) {
+        const valid = await withNavigationPending("next", () => validateCurrentStep());
+        if (!valid) {
+          await focus.focusFirstInvalid();
+          return false;
+        }
+        return withNavigationPending("next", async () => {
+          const canProceed = await runBeforeNext();
+          if (!canProceed) {
+            return false;
+          }
+          commitStepChange(nextIndex);
+          return true;
+        });
+      }
+      commitStepChange(nextIndex);
+      return true;
+    },
+    isDirty: state.isDirty,
     isFieldTouched: validation.isTouched,
+    isFirstStep,
+    isLastStep,
+    isStepped,
+    markFieldTouched: validation.markTouched,
+    nextStep: async () => {
+      if (actionPending.value) {
+        return false;
+      }
+      const valid = await withNavigationPending("next", () => validateCurrentStep());
+      if (!valid) {
+        await focus.focusFirstInvalid();
+        return false;
+      }
+      return withNavigationPending("next", async () => {
+        const canProceed = await runBeforeNext();
+        if (!canProceed) {
+          return false;
+        }
+        const nextIndex = resolveNextStepIndex();
+        if (nextIndex === null) {
+          return false;
+        }
+        commitStepChange(nextIndex);
+        return true;
+      });
+    },
+    output: state.output,
+    previousStep: async () => {
+      if (actionPending.value) {
+        return false;
+      }
+      const handler = getSchemaLifecycleHandler(params.schema.value, "onBeforePrevious");
+      if (!handler) {
+        const previousIndex = resolvePreviousStepIndex();
+        if (previousIndex === null) {
+          return false;
+        }
+        commitStepChange(previousIndex);
+        return true;
+      }
+      return withNavigationPending("previous", async () => {
+        const canProceed = await runBeforePrevious();
+        if (!canProceed) {
+          return false;
+        }
+        const previousIndex = resolvePreviousStepIndex();
+        if (previousIndex === null) {
+          return false;
+        }
+        commitStepChange(previousIndex);
+        return true;
+      });
+    },
+    refreshFieldOptions: optionRegistry.refreshMany,
+    registerFieldElement: focus.registerField,
+    registerFieldOptions: optionRegistry.register,
+    registerFieldUpload: uploadRegistry.register,
+    reset: async () => {
+      if (navigationActionPending.value === "reset") {
+        await effects.settle();
+        return;
+      }
+      navigationActionPending.value = "reset";
+      try {
+        validation.clearError();
+        state.reset();
+        await settleEffectRounds();
+        state.rebaseline();
+      } finally {
+        navigationActionPending.value = null;
+      }
+    },
+    schema: params.schema,
+    setError: (path, message, options) => validation.setError(pathSegments(path), message, options),
+    setValue: state.setValue,
+    settleEffects: settleEffectRounds,
     shouldRender: (field, path) => shouldRenderField(
       field,
       fieldCallbackParams({
-        field,
-        state: state.state,
-        ctx: context,
         api: apiFactory(path, field),
-        parentPath: path.slice(0, -1)
+        ctx: context,
+        field,
+        parentPath: path.slice(0, -1),
+        state: state.state
       })
     ),
-    validate,
-    validateCurrentStep,
-    setError: (path, message) => validation.setError(pathSegments(path), message),
-    clearError: (path) => validation.clearError(path ? pathSegments(path) : void 0),
-    focusRequest: focus.request,
-    registerFieldElement: focus.registerField,
-    focusField: focus.focusField,
-    focusFirstInvalid: focus.focusFirstInvalid,
-    clearErrors: () => validation.clearError(),
-    submitHandler: submit.submitHandler,
+    state: state.state,
+    steps,
     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;
+    submitHandler: submit.submitHandler,
+    trackEffect: effects.track,
+    validate,
+    validateCurrentStep
+  };
+  async function settleEffectRounds() {
+    for (let round = 0; round < MAX_EFFECT_ROUNDS; round += 1) {
+      await nextTick();
+      if (!effects.size()) {
+        return;
       }
-      currentStepIndex.value = nextIndex;
-      return true;
+      await effects.settle();
     }
-  };
+  }
+  function commitStepChange(index) {
+    validation.clearValidationState();
+    currentStepIndex.value = index;
+  }
   return runtime;
 }
+const MAX_EFFECT_ROUNDS = 25;
+function isSyncEnabled(paths) {
+  return paths === true || Array.isArray(paths) && paths.length > 0;
+}
+function createEffectLifecycle() {
+  const pending = /* @__PURE__ */ new Set();
+  function track(effect) {
+    if (!isPromise(effect)) {
+      return;
+    }
+    const tracked = effect;
+    pending.add(tracked);
+    void untrack(tracked);
+  }
+  async function untrack(tracked) {
+    try {
+      await tracked;
+    } catch {
+      pending.delete(tracked);
+      return;
+    }
+    pending.delete(tracked);
+  }
+  async function settle() {
+    while (pending.size) {
+      await Promise.allSettled(pending);
+    }
+  }
+  return { settle, size: () => pending.size, track };
+}
+function resolveRelativeFieldPath(parentPath, target) {
+  if (target === "$root") {
+    return [];
+  }
+  if (target.startsWith("$parent")) {
+    return relativePathSegments(parentPath, target);
+  }
+  return pathSegments(target);
+}
+function setPathValueOf(target, path, value) {
+  setPathValue(target, path, value);
+}
+function getSchemaIgnoredDirtyPaths(schema) {
+  if (!isRecord(schema) || !isRecord(schema.controls)) {
+    return [];
+  }
+  return stringArray(schema.controls.ignoreDirtyPaths);
+}
 function createFieldApi(params) {
   function contextResource(key) {
     const resource = params.ctx[key];
-    if (!resource) throw new Error(`Unknown form context resource: ${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();
+        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);
+      },
+      set: (key, value) => {
+        contextResource(key).value = value;
+      },
+      update: (key, updater) => {
+        updateContextResourceValue(contextResource(key), updater);
       }
     },
+    focus: params.focusField,
+    form: params.form,
+    options: {
+      activate: () => params.optionRegistry.get(params.path).activate(),
+      add: (option) => params.optionRegistry.get(params.path).add(option),
+      create: (label) => params.optionRegistry.get(params.path).create(label),
+      creating: () => params.optionRegistry.get(params.path).creating.value,
+      error: () => params.optionRegistry.get(params.path).error.value,
+      fetching: () => params.optionRegistry.get(params.path).fetching.value,
+      get: () => params.optionRegistry.get(params.path).items.value,
+      hasMore: () => params.optionRegistry.get(params.path).hasMore.value,
+      loadMore: () => params.optionRegistry.get(params.path).loadMore(),
+      loading: () => params.optionRegistry.get(params.path).loading.value,
+      pending: () => params.optionRegistry.get(params.path).pending.value,
+      refresh: () => params.optionRegistry.get(params.path).refresh(),
+      refreshable: () => params.optionRegistry.get(params.path).refreshable.value,
+      remote: () => params.optionRegistry.get(params.path).remote.value,
+      retry: () => params.optionRegistry.get(params.path).retry(),
+      search: () => params.optionRegistry.get(params.path).search.value,
+      selected: () => params.optionRegistry.get(params.path).selectedItems.value,
+      setSearch: (term) => params.optionRegistry.get(params.path).setSearch(term)
+    },
+    upload: {
+      cancel: async () => await params.uploadRegistry.get(params.path)?.cancel(),
+      remove: async (value) => await params.uploadRegistry.get(params.path)?.remove(value),
+      retry: async () => await params.uploadRegistry.get(params.path)?.retry(),
+      start: async () => await params.uploadRegistry.get(params.path)?.start()
+    },
     validation: {
-      validate: params.validateField,
+      clearError: params.clearExternalError,
+      pending: params.pendingField,
       setError: params.setExternalError,
-      clearError: params.clearExternalError
+      validate: params.validateField
     },
-    focus: params.focusField
+    value: {
+      get: () => params.getValue(params.path),
+      initial: () => params.getInitialValue(params.path),
+      reset: () => params.resetValue(params.path),
+      set: (value) => params.setValue(params.path, value)
+    }
   };
   return api;
 }
@@ -385,9 +582,11 @@ function updateContextResourceValue(resource, updater) {
   resource.value = updater(resource.value);
 }
 function patchContextResourceValue(resource, patch) {
-  if (!isContextValueResource(resource)) return;
+  if (!isContextValueResource(resource)) {
+    return;
+  }
   const current = resource.value;
-  const patchValue = typeof patch === "function" ? patch(current) : patch;
+  const patchValue = isFunction(patch) ? patch(current) : patch;
   if (isRecord(current) && isRecord(patchValue)) {
     resource.value = { ...current, ...patchValue };
     return;
@@ -395,21 +594,22 @@ function patchContextResourceValue(resource, patch) {
   resource.value = patchValue;
 }
 function isContextValueResource(value) {
-  return typeof value === "object" && value !== null && "value" in value;
+  return isObject(value) && value !== null && "value" in value;
 }
 function isRefreshableResource(value) {
-  return typeof value === "object" && value !== null && "refresh" in value && typeof value.refresh === "function";
+  return isObject(value) && value !== null && "refresh" in value && isFunction(value.refresh);
 }
 function getSchemaLifecycleHandler(schema, key) {
-  if (!isRecord(schema)) return void 0;
+  if (!isRecord(schema)) {
+    return;
+  }
   const handler = Object.getOwnPropertyDescriptor(schema, key)?.value;
-  return typeof handler === "function" ? handler : void 0;
+  return isFunction(handler) ? handler : void 0;
 }
 function fieldCallbackParams(params) {
   return {
+    api: params.api,
     ctx: params.ctx,
-    deps: resolveFieldDependencies(params),
-    api: params.api
+    deps: resolveFieldDependencies(params)
   };
 }
-export { childParentPath, fieldPath };