nuxt-ui-tools 0.1.2 → 1.0.0

package/dist/runtime/form/fields/upload/types.d.ts

@@ -1,19 +1,29 @@
+import type { FormValue } from '../../types/index.js';
 import type { FormFieldCallbackParams } from '../../types/callbacks.js';
 import type { FormStatefulFieldBase } from '../../types/field-base.js';
-import type { NullableValue } from '../../types/field-output-utils.js';
-import type { FormObject } from '../../types/utils.js';
-export interface FormUploadCallbackParams<TContext = {}, TDeps = {}> extends FormFieldCallbackParams<TContext, TDeps> {
+import type { FieldProps, NullableValue } from '../../types/field-output-utils.js';
+import type { FormObject, FormText } from '../../types/utils.js';
+export interface FormUploadCallbackParams<TContext = NonNullable<unknown>, TDeps = NonNullable<unknown>> extends FormFieldCallbackParams<TContext, TDeps> {
     files: readonly File[];
+    onProgress: (percent: number) => void;
 }
-export type FormUploadHandler<TContext = {}, TDeps = {}> = (params: FormUploadCallbackParams<TContext, TDeps>) => Promise<string | FormObject | readonly string[] | readonly FormObject[] | null>;
-export interface FormUploadDeleteParams<TContext = {}, TDeps = {}> extends FormFieldCallbackParams<TContext, TDeps> {
-    value: unknown;
+export type FormUploadHandler<TContext = NonNullable<unknown>, TDeps = NonNullable<unknown>> = (params: FormUploadCallbackParams<TContext, TDeps>) => Promise<string | FormObject | readonly string[] | readonly FormObject[] | null>;
+export interface FormUploadDeleteParams<TContext = NonNullable<unknown>, TDeps = NonNullable<unknown>> extends FormFieldCallbackParams<TContext, TDeps> {
+    value: FormValue;
 }
-export interface FormUploadField<TContext = {}, TDeps = {}> extends FormStatefulFieldBase<'upload', string | FormObject | readonly string[] | readonly FormObject[] | null, TContext, TDeps> {
-    output: 'url' | 'object';
+export interface FormUploadProps {
     multiple?: boolean;
     accept?: string;
     autoUpload?: boolean;
+    dropzoneLabel?: FormText;
+    dropzoneDescription?: FormText;
+    icon?: string | false;
+    variant?: 'area' | 'button';
+    layout?: 'list' | 'grid';
+    preview?: boolean;
+}
+export interface FormUploadField<TContext = NonNullable<unknown>, TDeps = NonNullable<unknown>> extends FormStatefulFieldBase<'upload', string | FormObject | readonly string[] | readonly FormObject[] | null, TContext, TDeps, FormUploadProps> {
+    output: 'url' | 'object';
     upload: {
         handler: FormUploadHandler<TContext, TDeps>;
         onDelete?: (params: FormUploadDeleteParams<TContext, TDeps>) => Promise<void> | void;
@@ -21,8 +31,8 @@ export interface FormUploadField<TContext = {}, TDeps = {}> extends FormStateful
 }
 export type UploadFieldOutput<TField> = TField extends {
     output: 'object';
-} ? TField extends {
+} ? FieldProps<TField> extends {
     multiple: true;
-} ? readonly FormObject[] | NullableValue : FormObject | NullableValue : TField extends {
+} ? readonly FormObject[] | NullableValue : FormObject | NullableValue : FieldProps<TField> extends {
     multiple: true;
 } ? readonly string[] | NullableValue : string | NullableValue;

package/dist/runtime/form/fields/year/config.d.ts

@@ -1,14 +1,14 @@
 export declare const yearFieldKind: {
-    readonly type: "year";
+    readonly layout: {
+        readonly item: true;
+    };
     readonly state: "stateful";
+    readonly transform: true;
+    readonly type: "year";
     readonly ui: {
-        readonly label: true;
         readonly description: true;
         readonly hint: true;
-    };
-    readonly layout: {
-        readonly item: true;
+        readonly label: true;
     };
     readonly validation: true;
-    readonly transform: true;
 };

package/dist/runtime/form/fields/year/config.js

@@ -1,9 +1,9 @@
 import { defineFormFieldKind } from "../../utils/field-kind.js";
 export const yearFieldKind = defineFormFieldKind({
-  type: "year",
-  state: "stateful",
-  ui: { label: true, description: true, hint: true },
   layout: { item: true },
-  validation: true,
-  transform: true
+  state: "stateful",
+  transform: true,
+  type: "year",
+  ui: { description: true, hint: true, label: true },
+  validation: true
 });

package/dist/runtime/form/index.d.ts

@@ -3,7 +3,6 @@ export { useForm } from './composables/use-form.js';
 export { useFormUi } from './composables/use-form-ui.js';
 export { provideFormApi, useFormApi } from './composables/use-form-api.js';
 export type { FormController, UseFormParams } from './types/index.js';
-export { useFormSubmit } from './composables/use-form-submit.js';
 export { createFormFieldInstance, fieldKindHas, getFormFieldKind, isRegisteredFormFieldType, } from './utils/field-instance.js';
 export type { FormFieldCapability, FormFieldInstance, FormFieldKind, FormFieldState, } from './utils/field-instance.js';
 export { defineFormFieldKind } from './utils/field-kind.js';

package/dist/runtime/form/index.js

@@ -2,7 +2,6 @@ export { defineFormField, defineFormFields, defineFormSchema } from "./schema/in
 export { useForm } from "./composables/use-form.js";
 export { useFormUi } from "./composables/use-form-ui.js";
 export { provideFormApi, useFormApi } from "./composables/use-form-api.js";
-export { useFormSubmit } from "./composables/use-form-submit.js";
 export {
   createFormFieldInstance,
   fieldKindHas,

package/dist/runtime/form/schema/index.d.ts

@@ -1,27 +1,27 @@
-import type { GenericObject } from '../../shared/types/utils.js';
-import type { FormAction, FormApi, FormContextData, FormContextDefinition, FormField, FormLayoutConfig, FormMaybePromise, FormSubmitHandler, FormStep, FormStepLifecycleParams, FormText } from '../types/index.js';
+import type { FormValue, FormAction, FormObject, FormApi, FormContextData, FormContextDefinition, FormField, FormLayoutConfig, FormMaybePromise, FormSubmitHandler, FormStep, FormStepLifecycleParams, FormUiConfig } from '../types/index.js';
 type FormSchemaSubmit<TContext extends FormContextDefinition | undefined> = (params: {
-    value: unknown;
+    value: FormValue;
     api: FormApi;
     ctx: FormContextData<TContext>;
 }) => Promise<void> | void;
 interface FormSchemaBase<TContext extends FormContextDefinition | undefined> {
     formKey?: string;
-    title?: FormText;
+    header?: import('../types').FormHeaderConfig;
     context: TContext;
     layout?: FormLayoutConfig;
+    ui?: FormUiConfig;
     showStepper?: boolean;
     controls?: import('../types').FormControlsConfig;
     modal?: import('../types').FormModalConfig;
     drawer?: import('../types').FormDrawerConfig;
     fullscreen?: import('../types').FormFullscreenConfig;
     actions?: readonly FormAction[];
-    onBeforeSubmit?: FormSubmitHandler<unknown, never>;
+    onBeforeSubmit?: FormSubmitHandler<FormValue, never>;
     submit?: FormSchemaSubmit<TContext>;
-    onBeforeNext?: (params: FormStepLifecycleParams<unknown>) => FormMaybePromise<boolean | void>;
-    onBeforePrevious?: (params: FormStepLifecycleParams<unknown>) => FormMaybePromise<void>;
-    skipStep?: (params: FormStepLifecycleParams<unknown>) => boolean;
-    onStepSkipped?: (params: Omit<FormStepLifecycleParams<unknown>, 'stepData'>) => void;
+    onBeforeNext?: (params: FormStepLifecycleParams<FormObject>) => FormMaybePromise<boolean | void>;
+    onBeforePrevious?: (params: FormStepLifecycleParams<FormObject>) => FormMaybePromise<void>;
+    skipStep?: (params: FormStepLifecycleParams<FormObject>) => boolean;
+    onStepSkipped?: (params: Omit<FormStepLifecycleParams<FormObject>, 'stepData'>) => void;
 }
 interface FormSchemaWithContextFields<TContext extends FormContextDefinition, TFields extends readonly FormField<FormContextData<NoInfer<TContext>>>[]> extends FormSchemaBase<TContext> {
     fields: TFields;
@@ -67,12 +67,12 @@ interface FormSchemaWithoutContextSteps<TSteps extends readonly FormStep<FormCon
 export declare function defineFormSchema<const TSchema>(schema: TSchema extends {
     readonly context?: undefined;
     readonly fields?: never;
-    readonly steps: readonly unknown[];
+    readonly steps: readonly FormValue[];
 } ? TSchema : never): TSchema;
-export declare function defineFormSchema<const TContext extends FormContextDefinition, const TFields extends readonly FormField<FormContextData<NoInfer<TContext>>>[], const TSchema extends GenericObject>(schema: TSchema & FormSchemaWithContextFields<TContext, TFields>): TSchema;
-export declare function defineFormSchema<const TContext extends FormContextDefinition, const TSteps extends readonly FormStep<FormContextData<NoInfer<TContext>>>[], const TSchema extends GenericObject>(schema: TSchema & FormSchemaWithContextSteps<TContext, TSteps>): TSchema & FormSchemaWithContextSteps<TContext, TSteps>;
-export declare function defineFormSchema<const TFields extends readonly FormField<FormContextData<undefined>>[], const TSchema extends GenericObject>(schema: TSchema & FormSchemaWithoutContextFields<TFields>): TSchema;
-export declare function defineFormSchema<const TSteps extends readonly FormStep<FormContextData<undefined>>[], const TSchema extends GenericObject>(schema: TSchema & FormSchemaWithoutContextSteps<TSteps>): TSchema & FormSchemaWithoutContextSteps<TSteps>;
+export declare function defineFormSchema<const TContext extends FormContextDefinition, const TFields extends readonly FormField<FormContextData<NoInfer<TContext>>>[]>(schema: FormSchemaWithContextFields<TContext, TFields>): FormSchemaWithContextFields<TContext, TFields>;
+export declare function defineFormSchema<const TContext extends FormContextDefinition, const TSteps extends readonly FormStep<FormContextData<NoInfer<TContext>>>[]>(schema: FormSchemaWithContextSteps<TContext, TSteps>): FormSchemaWithContextSteps<TContext, TSteps>;
+export declare function defineFormSchema<const TFields extends readonly FormField<FormContextData<undefined>>[]>(schema: FormSchemaWithoutContextFields<TFields>): FormSchemaWithoutContextFields<TFields>;
+export declare function defineFormSchema<const TSteps extends readonly FormStep<FormContextData<undefined>>[]>(schema: FormSchemaWithoutContextSteps<TSteps>): FormSchemaWithoutContextSteps<TSteps>;
 /**
  * Defines one field while preserving literal inference.
  */

package/dist/runtime/form/types/actions.d.ts

@@ -1,9 +1,9 @@
 import type { FormApi } from './api.js';
 import type { FormText } from './utils.js';
 export type FormActionKey = 'reset' | 'cancel' | 'submit' | 'previous' | 'next';
-export type FormActionSlot = 'left' | 'right' | (string & {});
-export type FormActionWidth = 'fit' | 'fill' | (string & {});
-export type FormActionType = 'primary' | (string & {});
+export type FormActionSlot = 'left' | 'right' | (string & NonNullable<unknown>);
+export type FormActionWidth = 'fit' | 'fill' | (string & NonNullable<unknown>);
+export type FormActionType = 'primary' | (string & NonNullable<unknown>);
 export type FormActionColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
 export type FormActionVariant = 'solid' | 'outline' | 'soft' | 'subtle' | 'ghost' | 'link';
 export type FormActionSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

package/dist/runtime/form/types/api.d.ts

@@ -1,5 +1,5 @@
-import type { ComputedRef } from 'vue';
 import type { NestedPaths } from '../../shared/types/utils.js';
+import type { FormValue } from './/index.js';
 import type { FormContextData } from './context.js';
 import type { FormMaybePromise, FormObject } from './utils.js';
 import type { FormValidationOptions } from './validation.js';
@@ -10,26 +10,64 @@ export type FormRefreshableContextKey<TContext> = {
 }[keyof TContext] & string;
 export type FormContextResourceValue<TResource> = TResource extends {
     value: infer TValue;
-} ? TValue : unknown;
+} ? TValue : FormValue;
 export type FormPatchableContextKey<TContext> = {
-    [TKey in keyof TContext]: NonNullable<FormContextResourceValue<TContext[TKey]>> extends readonly unknown[] ? never : NonNullable<FormContextResourceValue<TContext[TKey]>> extends object ? TKey : never;
+    [TKey in keyof TContext]: NonNullable<FormContextResourceValue<TContext[TKey]>> extends readonly FormValue[] ? never : NonNullable<FormContextResourceValue<TContext[TKey]>> extends object ? TKey : never;
 }[keyof TContext] & string;
 export type FormContextPatchValue<TContext, TKey extends keyof TContext> = Partial<NonNullable<FormContextResourceValue<TContext[TKey]>>>;
+export interface FormErrorOptions {
+    /** Blocks submit and step navigation while the error is present. Defaults to `false`. */
+    blocking?: boolean;
+}
 /**
  * Public value namespace exposed to a mounted field.
  */
-export interface FormFieldValueApi<TValue = unknown> {
+export interface FormFieldValueApi<TValue = FormValue> {
     /** Reads the current internal field value. */
     get: () => TValue;
     /** Updates the current internal field value. */
     set: (value: TValue) => void;
+    /** Reads the baseline value captured when the form was initialized or last reset. */
+    initial: () => TValue;
     /** Resets the current internal field value to its configured default. */
     reset: () => void;
 }
+/**
+ * Form-wide operations exposed to a mounted field. Paths are absolute, or relative with
+ * `$parent` / `$parent:N` / `$root`, resolved against the owning field's scope.
+ */
+export interface FormFieldFormApi {
+    /** Reads an internal form value. */
+    get: (path: string) => FormValue;
+    /** Writes an internal form value. */
+    set: (path: string, value: FormValue) => void;
+    /** Reads a baseline value captured when the form was initialized or last reset. */
+    initial: (path: string) => FormValue;
+    /** Reads the whole internal form state. */
+    state: () => FormObject;
+    /** Reads the current submitted output. */
+    output: () => FormObject;
+    /** Focuses a mounted field. */
+    focus: (path: string) => Promise<boolean>;
+    /** Sets an external error on a field. */
+    setError: (path: string, message: string, options?: FormErrorOptions) => void;
+    /** Clears one external field error, or every form error when no path is provided. */
+    clearError: (path?: string) => void;
+    /** Runs whole-form validation. */
+    validate: () => Promise<boolean>;
+    /** Resets the form and waits for dependency effects triggered by the reset. */
+    reset: () => Promise<void>;
+    /** Submits the form through the configured submit lifecycle. */
+    submit: () => Promise<boolean>;
+    /** Advances to the next step on stepped forms. */
+    nextStep: () => Promise<boolean>;
+    /** Returns to the previous step on stepped forms. */
+    previousStep: () => Promise<boolean>;
+}
 /**
  * Public option namespace exposed to option-based fields.
  */
-export interface FormFieldOptionsApi<TOption = unknown> {
+export interface FormFieldOptionsApi<TOption = FormValue> {
     /** Returns the current resolved options. */
     get: () => readonly TOption[];
     /** Adds a local option to the mounted field without calling the async create handler. */
@@ -45,16 +83,32 @@ export interface FormFieldOptionsApi<TOption = unknown> {
     /** True when the option field configured a refresh affordance. */
     refreshable: () => boolean;
     /** Returns the latest option-source error, if any. */
-    error: () => unknown | null;
+    error: () => FormValue | null;
     /** Refreshes the option source when it is async or query-backed. */
     refresh: () => Promise<void>;
     /** Creates a new option when the field configured an option creation handler. */
     create: (label: string) => Promise<TOption | null>;
+    /** Returns hydrated options for the current selection, including values outside loaded pages. */
+    selected: () => readonly TOption[];
+    /** True when the field loads options remotely. */
+    remote: () => boolean;
+    /** Current remote search term. */
+    search: () => string;
+    /** Sets the remote search term. Ignored for local option sources. */
+    setSearch: (term: string) => void;
+    /** Starts remote loading, for example when the menu opens. */
+    activate: () => void;
+    /** True when another remote page can be loaded. */
+    hasMore: () => boolean;
+    /** Loads the next remote page. */
+    loadMore: () => Promise<void>;
+    /** Retries the last failed remote request. */
+    retry: () => Promise<void>;
 }
 /**
  * Public upload namespace exposed to upload fields.
  */
-export interface FormFieldUploadApi<TValue = unknown> {
+export interface FormFieldUploadApi<TValue = FormValue> {
     /** Starts or restarts upload work for the current selected file value. */
     start: () => Promise<void>;
     /** Cancels upload work when the current upload source supports cancellation. */
@@ -70,8 +124,10 @@ export interface FormFieldUploadApi<TValue = unknown> {
 export interface FormFieldValidationApi {
     /** Runs validation for the current field. */
     validate: () => Promise<boolean>;
-    /** Sets an external field error. */
-    setError: (message: string) => void;
+    /** True while an asynchronous Regle rule for this field is running. */
+    pending: () => boolean;
+    /** Sets an external field error. Non-blocking unless `blocking: true`. */
+    setError: (message: string, options?: FormErrorOptions) => void;
     /** Clears external field errors. */
     clearError: () => void;
 }
@@ -95,9 +151,11 @@ export interface FormFieldContextApi<TContext = FormContextData> {
 /**
  * Public field API available from field callbacks.
  */
-export interface FormFieldApi<TValue = unknown, TOption = unknown, TContext = FormContextData> {
+export interface FormFieldApi<TValue = FormValue, TOption = FormValue, TContext = FormContextData> {
     /** Field-local value operations. */
     value: FormFieldValueApi<TValue>;
+    /** Form-wide value, error, focus, and lifecycle operations. */
+    form: FormFieldFormApi;
     /** Form-scoped context operations. */
     context: FormFieldContextApi<TContext>;
     /** Option operations. Present for all fields at type level only where the field supports options. */
@@ -115,24 +173,26 @@ export interface FormFieldApi<TValue = unknown, TOption = unknown, TContext = Fo
 export type FormFieldPath<TOutput = FormObject> = TOutput extends FormObject ? FormObject extends TOutput ? string : NestedPaths<TOutput> : string;
 export interface FormApi<TOutput = FormObject> {
     /** Reads an internal form value by raw path. */
-    get: (path: string) => unknown;
+    get: (path: string) => FormValue;
     /** Writes an internal form value by raw path. */
-    set: (path: string, value: unknown) => void;
+    set: (path: string, value: FormValue) => void;
+    /** Reads a baseline value by raw path. */
+    initial: (path: string) => FormValue;
     /** Runs form validation. */
     validate: (options?: FormValidationOptions) => Promise<boolean>;
-    /** Sets an external error on a submitted output field. */
-    setError: (path: FormFieldPath<TOutput>, message: string) => void;
+    /** Sets an external error on a submitted output field. Non-blocking unless `blocking: true`. */
+    setError: (path: FormFieldPath<TOutput>, message: string, options?: FormErrorOptions) => void;
     /** Clears one external field error, or every form error when no path is provided. */
     clearError: (path?: FormFieldPath<TOutput>) => void;
     /** Focuses a mounted field by raw path. */
     focus: (path: FormFieldPath<TOutput> | readonly string[]) => Promise<boolean>;
     /** Submits the form through the configured submit lifecycle. */
     submit: () => Promise<void>;
-    /** Resets the form to configured defaults. */
-    reset: () => void;
+    /** Resets the form and waits for dependency effects triggered by the reset. */
+    reset: () => Promise<void>;
 }
-export type FormSubmitAction = 'next' | 'previous' | 'submit';
-export type FormSubmitResult<TSubmitData = unknown> = boolean | void | {
+export type FormSubmitAction = 'next' | 'previous' | 'submit' | 'reset';
+export type FormSubmitResult<TSubmitData = FormValue> = boolean | void | {
     success: false;
 } | {
     success: true;
@@ -144,12 +204,8 @@ export interface FormSubmitHandlerParams<TOutput = FormObject> {
     /** Namespaced form API for state, validation, submit, and reset operations. */
     api: FormApi<TOutput>;
 }
-export type FormSubmitHandler<TOutput = FormObject, TSubmitData = unknown> = (params: FormSubmitHandlerParams<TOutput>) => FormMaybePromise<FormSubmitResult<TSubmitData>>;
-export interface FormSubmitHandlerResult<TSubmitData = unknown> {
+export type FormSubmitHandler<TOutput = FormObject, TSubmitData = FormValue> = (params: FormSubmitHandlerParams<TOutput>) => FormMaybePromise<FormSubmitResult<TSubmitData>>;
+export interface FormSubmitHandlerResult<TSubmitData = FormValue> {
     success: boolean;
     data?: TSubmitData;
 }
-export interface FormSubmitTarget<TOutput = FormObject, TSubmitData = unknown> {
-    actionPending: ComputedRef<FormSubmitAction | null>;
-    submitHandler: (submitHandler?: FormSubmitHandler<TOutput, TSubmitData>) => Promise<FormSubmitHandlerResult<TSubmitData>>;
-}

package/dist/runtime/form/types/callbacks.d.ts

@@ -1,8 +1,9 @@
+import type { FormValue } from './/index.js';
 import type { FormFieldApi } from './api.js';
 /**
  * Parameters passed to field-level callbacks.
  */
-export interface FormFieldCallbackParams<TContext = {}, TDeps = {}, TValue = unknown, TOption = unknown> {
+export interface FormFieldCallbackParams<TContext = NonNullable<unknown>, TDeps = NonNullable<unknown>, TValue = FormValue, TOption = FormValue> {
     /** Fully typed form-scoped context declared on the schema. */
     ctx: TContext;
     /** Values read from the field's dependency list. */
@@ -13,4 +14,4 @@ export interface FormFieldCallbackParams<TContext = {}, TDeps = {}, TValue = unk
 /**
  * Function receiving field callback parameters.
  */
-export type FormFieldCallback<TResult, TContext = {}, TDeps = {}, TValue = unknown, TOption = unknown> = (params: FormFieldCallbackParams<TContext, TDeps, TValue, TOption>) => TResult;
+export type FormFieldCallback<TResult, TContext = NonNullable<unknown>, TDeps = NonNullable<unknown>, TValue = FormValue, TOption = FormValue> = (params: FormFieldCallbackParams<TContext, TDeps, TValue, TOption>) => TResult;

package/dist/runtime/form/types/context.d.ts

@@ -1,10 +1,11 @@
-import type { DataTag, QueryKey } from '@tanstack/vue-query';
-import type { GenericObject } from '../../shared/types/utils.js';
+import type { QueryKey } from '@tanstack/vue-query';
+import type { FormValue } from './/index.js';
 import type { FormAsyncResource, FormContextResource, FormSyncResource } from './utils.js';
+export { type DataTag, type QueryKey } from '@tanstack/vue-query';
 /**
  * Query options accepted by form context and option sources.
  */
-export interface FormQueryOptions<_TValue = unknown> {
+export interface FormQueryOptions<_TValue = FormValue> {
     queryKey: QueryKey;
 }
 /**
@@ -13,19 +14,21 @@ export interface FormQueryOptions<_TValue = unknown> {
  * Sources do not receive other context values. This keeps the context graph easy to infer and
  * matches the intended form-scoped data model.
  */
-export type FormContextSource<TValue = unknown> = TValue | Promise<TValue> | FormQueryOptions<TValue> | (() => TValue | Promise<TValue> | FormQueryOptions<TValue>);
+export type FormContextSource<TValue = FormValue> = TValue | Promise<TValue> | FormQueryOptions<TValue> | (() => TValue | Promise<TValue> | FormQueryOptions<TValue>);
 /**
  * Object of named context sources declared by a form schema.
  */
-export type FormContextDefinition = GenericObject;
+export type FormContextDefinition = object;
+type FormContextFallback = {
+    [key: string]: FormValue;
+};
 type ResolveContextSource<TSource> = TSource extends () => infer TResult ? FormContextResource<TResult> : FormContextResource<TSource>;
 /**
  * Fully typed context object exposed to field callbacks as `ctx`.
  */
-export type FormContextData<TContext extends FormContextDefinition | undefined = FormContextDefinition> = TContext extends FormContextDefinition ? {
+export type FormContextData<TContext extends FormContextDefinition | undefined = FormContextFallback> = TContext extends FormContextDefinition ? {
     [TKey in keyof TContext]: ResolveContextSource<TContext[TKey]>;
-} : {};
+} : NonNullable<unknown>;
 export type FormRuntimeContext = {
-    [key: string]: FormSyncResource<unknown> | FormAsyncResource<unknown>;
+    [key: string]: FormSyncResource<FormValue> | FormAsyncResource<FormValue>;
 };
-export type { DataTag, QueryKey };

package/dist/runtime/form/types/controller.d.ts

@@ -1,5 +1,6 @@
 import type { ComputedRef, MaybeRefOrGetter } from 'vue';
-import type { FormSubmitAction, FormSubmitHandler, FormSubmitHandlerResult, FormSubmitTarget } from './api.js';
+import type { FormValue } from './/index.js';
+import type { FormSubmitAction, FormSubmitHandler, FormSubmitHandlerResult } from './api.js';
 import type { ExtractFormInternalValue, ExtractFormOutput } from './output.js';
 import type { FormRuntime, FormRuntimeStep } from './runtime.js';
 import type { ExtractFormContext } from './schema.js';
@@ -20,7 +21,7 @@ import type { FormValidationError, FormValidationMode, FormValidationOptions } f
  * })
  * ```
  */
-export interface UseFormParams<TSchema, TSubmitData = unknown> {
+export interface UseFormParams<TSchema, TSubmitData = FormValue> {
     /** Schema owned by this form controller and passed to `<NutForm :form="form" />`. */
     schema: MaybeRefOrGetter<TSchema>;
     /** Optional initial internal state. Dotted field keys are still normalized by the runtime. */
@@ -37,11 +38,11 @@ export interface UseFormParams<TSchema, TSubmitData = unknown> {
  * Vue runtime boundary.
  */
 export interface RuntimeUseFormParams {
-    schema: MaybeRefOrGetter<unknown>;
+    schema: MaybeRefOrGetter<FormValue>;
     input?: MaybeRefOrGetter<FormObject | undefined>;
     syncInput?: MaybeRefOrGetter<boolean | readonly string[]>;
     validate?: MaybeRefOrGetter<FormValidationMode>;
-    onSubmit?: FormSubmitHandler<FormObject, unknown>;
+    onSubmit?: FormSubmitHandler<FormObject, FormValue>;
 }
 export interface FormControllerState<TInternal = FormObject, TOutput = FormObject> {
     /** Current internal form state before output transforms and omitted submit fields. */
@@ -49,11 +50,11 @@ export interface FormControllerState<TInternal = FormObject, TOutput = FormObjec
     /** Current submitted output after transforms, step roots, and omissions. */
     output: ComputedRef<TOutput>;
     /** Reads an internal form value by raw path. Dotted paths address nested state. */
-    get: (path: string) => unknown;
+    get: (path: string) => FormValue;
     /** Writes an internal form value by raw path. Dotted paths create nested state. */
-    set: (path: string, value: unknown) => void;
+    set: (path: string, value: FormValue) => void;
     /** Resets internal state to schema defaults and configured input. */
-    reset: () => void;
+    reset: () => Promise<void>;
 }
 export interface FormControllerMeta {
     /** True once a rendered `<NutForm>` is mounted and bound to this controller. */
@@ -81,7 +82,7 @@ export interface FormControllerValidation {
     /** Clears all current validation and external errors. */
     clear: () => void;
 }
-export interface FormControllerSubmission<TOutput = FormObject, TSubmitData = unknown> {
+export interface FormControllerSubmission<TOutput = FormObject, TSubmitData = FormValue> {
     /** Current pending submit/navigation action. */
     actionPending: ComputedRef<FormSubmitAction | null>;
     /** True while the form submit lifecycle is pending. */
@@ -123,7 +124,7 @@ export interface FormControllerNavigation {
  */
 export interface FormRendererController {
     /** Schema bound to the controller. */
-    schema: ComputedRef<unknown>;
+    schema: ComputedRef<FormValue>;
     /** Initial input state bound to the controller. */
     input: ComputedRef<FormObject | undefined>;
     /** External input synchronization policy bound to the controller. */
@@ -133,7 +134,7 @@ export interface FormRendererController {
     /** Runs the controller's default submit lifecycle. */
     submit: () => Promise<boolean>;
     /** Runs the controller's default submit lifecycle and returns the normalized result. */
-    submitHandler: () => Promise<FormSubmitHandlerResult<unknown>>;
+    submitHandler: () => Promise<FormSubmitHandlerResult<FormValue>>;
     /** Binds a mounted runtime instance to the controller. */
     bind: (runtime: FormRuntime) => void;
     /** Unbinds a mounted runtime instance from the controller. */
@@ -146,7 +147,7 @@ export interface FormRendererController {
  * state inspection, autosave flows, custom action bars, wizard navigation, and explicit
  * submit handling.
  */
-export interface FormController<TSchema = FormObject, TSubmitData = unknown> extends FormSubmitTarget<ExtractFormOutput<TSchema>, TSubmitData>, FormRendererController {
+export interface FormController<TSchema = FormObject, TSubmitData = FormValue> extends FormRendererController {
     /** Schema bound to this controller. */
     schema: ComputedRef<TSchema>;
     /** Initial input state bound to this controller. */
@@ -186,7 +187,7 @@ export interface FormController<TSchema = FormObject, TSubmitData = unknown> ext
     /** Ergonomic alias for `form.submission.submitHandler`. */
     submitHandler: (submitHandler?: FormSubmitHandler<ExtractFormOutput<TSchema>, TSubmitData>) => Promise<FormSubmitHandlerResult<TSubmitData>>;
     /** Ergonomic alias for `form.state.reset`. */
-    reset: () => void;
+    reset: () => Promise<void>;
     /** Ergonomic alias for `form.navigation.next`. */
     nextStep: () => Promise<boolean>;
     /** Ergonomic alias for `form.navigation.previous`. */

package/dist/runtime/form/types/dependencies.d.ts

@@ -1,10 +1,11 @@
 import type { DeepPrettify, PathToObject, UnionToIntersection } from '../../shared/types/utils.js';
+import type { FormValue } from './/index.js';
 import type { FormObject } from './utils.js';
 type DependencySource<TDependency> = TDependency extends readonly [infer TSource, infer _TTarget] ? TSource extends string ? TSource : never : TDependency extends string ? TDependency : never;
 type DependencyTarget<TDependency> = TDependency extends readonly [infer _TSource, infer TTarget] ? TTarget extends string ? TTarget : never : TDependency extends string ? TDependency : never;
-type PathValue<TSource, TPath extends string> = TPath extends '$root' ? TSource : TPath extends `$parent${string}` ? unknown : TPath extends `${infer THead}.${infer TTail}` ? THead extends keyof TSource ? PathValue<TSource[THead], TTail> : unknown : TPath extends keyof TSource ? TSource[TPath] : unknown;
-type DependencyObject<TDependency, TState> = DependencyTarget<TDependency> extends infer TTarget ? TTarget extends string ? PathToObject<TTarget, PathValue<TState, DependencySource<TDependency>>> : {} : {};
-type DependenciesValue<TDependencies, TState> = TDependencies extends readonly unknown[] ? UnionToIntersection<DependencyObject<TDependencies[number], TState>> : {};
+type PathValue<TSource, TPath extends string> = TPath extends '$root' ? TSource : TPath extends `$parent${string}` ? FormValue : TPath extends `${infer THead}.${infer TTail}` ? THead extends keyof TSource ? PathValue<TSource[THead], TTail> : FormValue : TPath extends keyof TSource ? TSource[TPath] : FormValue;
+type DependencyObject<TDependency, TState> = DependencyTarget<TDependency> extends infer TTarget ? TTarget extends string ? PathToObject<TTarget, PathValue<TState, DependencySource<TDependency>>> : NonNullable<unknown> : NonNullable<unknown>;
+type DependenciesValue<TDependencies, TState> = TDependencies extends readonly FormValue[] ? UnionToIntersection<DependencyObject<TDependencies[number], TState>> : NonNullable<unknown>;
 /**
  * Extracts the `deps` object made available to callbacks for a single field.
  *
@@ -23,5 +24,5 @@ type DependenciesValue<TDependencies, TState> = TDependencies extends readonly u
  */
 export type ExtractFormFieldDependencies<TField, TState = FormObject> = TField extends {
     readonly dependencies: infer TDependencies;
-} ? DeepPrettify<DependenciesValue<TDependencies, TState>> : {};
+} ? DeepPrettify<DependenciesValue<TDependencies, TState>> : NonNullable<unknown>;
 export {};