@dragonmastery/zinia-forms-core 0.3.13 → 0.3.16

package/dist/index.d.ts

@@ -1170,6 +1170,14 @@ interface DeleteModalProps<FormType = any> {
 interface DataTableProps<FormType> {
     class?: string;
     name?: string;
+    /**
+     * Height behavior for the table container
+     * - 'auto' (default): Table expands to fill available space with a minimum height to prevent squishing
+     * - 'fixed': Uses fixed height (850px, max 90vh) - original behavior
+     * - number: Fixed pixel height (e.g., 600)
+     * - string: Custom CSS height value (e.g., '50vh', '600px')
+     */
+    height?: 'auto' | 'fixed' | number | string;
 }
 
 /**
@@ -1279,6 +1287,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 +1462,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 +1477,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;
@@ -1933,9 +2056,10 @@ interface ColumnDefinition<TData, TField extends keyof TData> {
     textWrap?: 'truncate' | 'wrap';
     format?: (value: TData[TField], row: TData) => string;
     render?: (value: TData[TField], row: TData) => any;
-    filterType?: 'text' | 'select' | 'number' | 'boolean';
+    filterType?: 'text' | 'select' | 'number' | 'boolean' | 'combobox';
     filterOptions?: FilterOptionItem[];
     filterOptionsLoader?: () => Promise<FilterOptionItem[]>;
+    filterAllowCreate?: boolean;
     sortLabels?: {
         asc: string;
         desc: string;
@@ -2056,6 +2180,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 +2348,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) & {