@dragonmastery/zinia-forms-core 0.3.13 → 0.3.15

package/dist/index.d.ts

@@ -1279,6 +1279,118 @@ interface StyleCreators {
     }, {}>;
 }
 
+/**
+ * Form state management hook
+ * Provides reactive form state with proper reactivity handling
+ */
+
+/**
+ * Form state interface
+ */
+interface FormState<T, CalcType = any, ExtraDataType = any> {
+    data: T;
+    calculatedValues: CalcType;
+    touched: Record<string, boolean>;
+    dirty: Record<string, boolean>;
+    errors: Record<string, string>;
+    focused: Record<string, boolean>;
+    displayText: Record<string, string>;
+    selectedIndex: Record<string, number>;
+    collapsedFields: Record<string, {
+        isFieldCollapsed: boolean;
+        collapsedItems: number[];
+        defaultCollapsedInitialized: boolean;
+    }>;
+    undoHistory: Record<string, {
+        type: 'add' | 'remove' | 'swap';
+        previousState: any;
+        currentState: any;
+        timestamp: number;
+    }[]>;
+    redoHistory: Record<string, {
+        type: 'add' | 'remove' | 'swap';
+        previousState: any;
+        currentState: any;
+        timestamp: number;
+    }[]>;
+    pendingOperations: Record<string, {
+        type: 'add' | 'remove' | 'swap';
+        index?: number;
+        indexA?: number;
+        indexB?: number;
+        item?: any;
+        previousState: any;
+        currentState: any;
+        timestamp: number;
+        timeoutId?: number;
+    }[]>;
+    arrayItemIds: Record<string, string[]>;
+    isSubmitting: boolean;
+    hasAttemptedSubmit: boolean;
+    submitAttemptsCount: number;
+    submitError: string | null;
+    isReady: boolean;
+    isLoading: boolean;
+    loadError: string | null;
+    extraData: ExtraDataType;
+    fetchedOptions: Record<string, any[]>;
+    loadingOptions: Record<string, boolean>;
+    asyncCascadingParents: Record<string, string>;
+    loadingAutoPopulate: Record<string, boolean>;
+    populatingFields: Record<string, boolean>;
+}
+
+/**
+ * Type definitions for async cascading selection and auto-population
+ */
+
+/**
+ * Helper type to get the value type of a field path
+ */
+type FieldValue<FormType, P extends Path<FormType>> = P extends keyof FormType ? FormType[P] : P extends `${infer K}.${infer Rest}` ? K extends keyof FormType ? FormType[K] extends Record<string, any> ? FieldValue<FormType[K], Rest & Path<FormType[K]>> : never : never : never;
+/**
+ * Configuration for async cascading selection (parent → child options fetching via API)
+ */
+interface AsyncCascadingSelectConfig<FormType, ParentField extends Path<FormType> = Path<FormType>, ChildField extends Path<FormType> = Path<FormType>> {
+    /** Parent field that triggers child options fetch */
+    parentField: ParentField;
+    /** Child field that will be populated with fetched options */
+    childField: ChildField;
+    /** Async function to fetch child options based on parent value */
+    fetchOptionsFn: (parentValue: FieldValue<FormType, ParentField>) => Promise<Array<SelectOption>>;
+    /** Whether to clear child field when parent changes (default: true) */
+    clearOnParentChange?: boolean;
+}
+/**
+ * Type for the async cascading selects configuration object
+ * Uses a mapped type to preserve field path type safety
+ */
+type AsyncCascadingSelectsConfig<FormType> = {
+    [K in string]: AsyncCascadingSelectConfig<FormType, Path<FormType>, Path<FormType>>;
+};
+/**
+ * Configuration for auto-population (select/combobox → other fields)
+ */
+interface AutoPopulateConfig<FormType, TData = any, SourceField extends Path<FormType> = Path<FormType>> {
+    /**
+     * Optional async function to fetch data when option is selected.
+     * If provided, this will be called instead of using option.data.
+     * Receives the selected option value and returns the data object.
+     */
+    fetchDataFn?: (selectedValue: FieldValue<FormType, SourceField>) => Promise<TData>;
+    /** Mapping of form fields to data properties for auto-population */
+    fields: {
+        [TargetField in Path<FormType>]?: string | ((data: TData) => FieldValue<FormType, TargetField>);
+    };
+}
+/**
+ * Type for the auto-populate configuration object
+ * Key is the select/combobox field name, value is the auto-populate config
+ */
+type AutoPopulateConfigs<FormType> = Partial<{
+    [SourceField in Path<FormType>]: AutoPopulateConfig<FormType, any>;
+}>;
+
 /**
  * Options for merging server data with local changes
  */
@@ -1342,6 +1454,8 @@ declare function useForm<T extends z.ZodObject<any>, CalcType = (values: z.infer
         [K in keyof ExtraDataType]?: () => Promise<ExtraDataType[K]>;
     };
     fetchData?: () => Promise<z.infer<typeof schema>>;
+    asyncCascadingSelects?: AsyncCascadingSelectsConfig<z.infer<T>>;
+    autoPopulate?: AutoPopulateConfigs<z.infer<T>>;
     calculationFn?: (values: z.infer<T>, extraData?: ExtraDataType) => CalcType;
     debug?: {
         all?: boolean;
@@ -1355,6 +1469,7 @@ declare function useForm<T extends z.ZodObject<any>, CalcType = (values: z.infer
     form: {
         storeName: string;
         values: z.TypeOf<T>;
+        state: FormState<z.TypeOf<T>, CalcType, ExtraDataType>;
         readonly calculatedValues: CalcType;
         readonly extraData: ExtraDataType;
         readonly isValid: boolean;
@@ -2056,6 +2171,9 @@ declare function useDataTable<TSchema extends z.ZodObject<any>>(schema: TSchema,
             sortDrawerOpen: vue.Ref<boolean, boolean>;
             openSortDrawer: () => boolean;
             closeSortDrawer: () => boolean;
+            filterDrawerOpen: vue.Ref<boolean, boolean>;
+            openFilterDrawer: () => boolean;
+            closeFilterDrawer: () => boolean;
         };
         fieldsMetadata: Record<string, FieldMetadata>;
         columns: (z.TypeOf<TSchema> extends infer T ? { [K in keyof T]?: ColumnDefinition<z.TypeOf<TSchema>, K> | undefined; } : never) & {
@@ -2221,6 +2339,9 @@ declare function useCursorDataTable<TSchema extends z.ZodObject<any>>(schema: TS
             sortDrawerOpen: vue.Ref<boolean, boolean>;
             openSortDrawer: () => boolean;
             closeSortDrawer: () => boolean;
+            filterDrawerOpen: vue.Ref<boolean, boolean>;
+            openFilterDrawer: () => boolean;
+            closeFilterDrawer: () => boolean;
         };
         fieldsMetadata: Record<string, FieldMetadata>;
         columns: (z.TypeOf<TSchema> extends infer T ? { [K in keyof T]?: ColumnDefinition<z.TypeOf<TSchema>, K> | undefined; } : never) & {