@akinon/akifilter 1.0.4 → 1.1.0

package/dist/esm/akifilter.js

@@ -15,6 +15,7 @@ import { Akiform, FormItem, useForm, useWatch } from '@akinon/akiform';
 import { Button } from '@akinon/ui-button';
 import { Card } from '@akinon/ui-card';
 import { Checkbox } from '@akinon/ui-checkbox';
+import { Collapse } from '@akinon/ui-collapse';
 import { DatePicker } from '@akinon/ui-date-picker';
 import { Input, InputTextArea } from '@akinon/ui-input';
 import { InputNumber } from '@akinon/ui-input-number';
@@ -28,10 +29,10 @@ import { themeOverrides } from './common/theme-overrides';
 import { AppliedFilters } from './components/applied-filters';
 import { FilterToolbar } from './components/filter-toolbar';
 import { VisibilityModal } from './components/visibility-modal';
-import { DEFAULT_MODAL_PAGE_SIZE, FILTER_DEBOUNCE_DELAY } from './constants';
+import { BOOLEAN_STRING, DATE_FORMAT, DEFAULT_MODAL_PAGE_SIZE, FILTER_DEBOUNCE_DELAY } from './constants';
 import { useDebouncedValue } from './hooks/use-debounced-value';
 import { i18n } from './i18n';
-import { deriveDefaultVisibleKeys, ensureSchemaOrder, extractDefaultValues, getFieldAriaLabel, normaliseValuesBySchema } from './utils/schema';
+import { deriveDefaultVisibleKeys, ensureSchemaOrder, extractDefaultValues, flattenSchema, getFieldAriaLabel, normaliseValuesBySchema, partitionSchema } from './utils/schema';
 import { normaliseOutputValues } from './utils/values';
 const resolveClearedFieldValue = (field, defaultValue) => {
     if (defaultValue !== undefined) {
@@ -52,14 +53,18 @@ const resolveClearedFieldValue = (field, defaultValue) => {
     }
 };
 const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onValuesChange, onVisibleFieldsChange, onImportCsv, onImportXls, onClearAll, enableImportCsv, enableImportXls }) => {
-    const storageKey = React.useMemo(() => buildStorageKey(filterSchema, storageNamespace), [filterSchema, storageNamespace]);
-    const schemaDefaults = React.useMemo(() => normaliseValuesBySchema(filterSchema, extractDefaultValues(filterSchema)), [filterSchema]);
-    const externalDefaults = React.useMemo(() => normaliseValuesBySchema(filterSchema, defaultValues), [filterSchema, defaultValues]);
+    // Separate regular fields from section fields
+    const { regularFields, sectionFields } = React.useMemo(() => partitionSchema(filterSchema), [filterSchema]);
+    // Flatten schema for storage and form value operations
+    const flattenedSchema = React.useMemo(() => flattenSchema(filterSchema), [filterSchema]);
+    const storageKey = React.useMemo(() => buildStorageKey(regularFields, storageNamespace), [regularFields, storageNamespace]);
+    const schemaDefaults = React.useMemo(() => normaliseValuesBySchema(flattenedSchema, extractDefaultValues(flattenedSchema)), [flattenedSchema]);
+    const externalDefaults = React.useMemo(() => normaliseValuesBySchema(flattenedSchema, defaultValues), [flattenedSchema, defaultValues]);
     const baseDefaultValues = React.useMemo(() => (Object.assign(Object.assign({}, schemaDefaults), externalDefaults)), [schemaDefaults, externalDefaults]);
     const persistedDefaults = React.useMemo(() => {
         var _a;
-        return normaliseValuesBySchema(filterSchema, (_a = readStoredValues(filterSchema, storageKey)) !== null && _a !== void 0 ? _a : undefined);
-    }, [filterSchema, storageKey]);
+        return normaliseValuesBySchema(flattenedSchema, (_a = readStoredValues(regularFields, storageKey)) !== null && _a !== void 0 ? _a : undefined);
+    }, [flattenedSchema, regularFields, storageKey]);
     const mergedDefaultValues = React.useMemo(() => (Object.assign(Object.assign({}, baseDefaultValues), persistedDefaults)), [baseDefaultValues, persistedDefaults]);
     const formMethods = useForm({
         defaultValues: mergedDefaultValues
@@ -73,7 +78,7 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
         if (!formValues) {
             return [];
         }
-        return filterSchema.reduce((acc, field) => {
+        return flattenedSchema.reduce((acc, field) => {
             const key = String(field.key);
             const currentValue = formValues[key];
             if (currentValue === undefined || currentValue === null) {
@@ -104,14 +109,17 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
                 if (field.type === 'date') {
                     const iso = akidate.toIsoDate(currentValue);
                     if (iso) {
-                        return akidate.formatIsoDate(iso, 'YYYY-MM-DD');
+                        // Use localized format with time if showTime is enabled
+                        const hasShowTime = 'showTime' in field && field.showTime;
+                        const format = hasShowTime ? 'L LTS' : 'YYYY-MM-DD';
+                        return akidate.formatIsoDate(iso, format);
                     }
                 }
                 if (Array.isArray(currentValue)) {
                     return currentValue.map((value) => String(value)).join(', ');
                 }
                 if (typeof currentValue === 'boolean') {
-                    return currentValue ? 'true' : 'false';
+                    return currentValue ? BOOLEAN_STRING.TRUE : BOOLEAN_STRING.FALSE;
                 }
                 if (typeof currentValue === 'string' ||
                     typeof currentValue === 'number') {
@@ -119,31 +127,31 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
                 }
                 const iso = akidate.toIsoDate(currentValue);
                 if (iso) {
-                    return akidate.formatIsoDate(iso, 'YYYY-MM-DD');
+                    return akidate.formatIsoDate(iso, DATE_FORMAT);
                 }
                 return String(currentValue);
             };
             acc.push({ key, label, value: resolveValue() });
             return acc;
         }, []);
-    }, [filterSchema, formValues]);
+    }, [flattenedSchema, formValues]);
     const resolveInitialVisibleKeys = React.useCallback(() => {
-        const storedKeys = readVisibleKeys(filterSchema, storageKey);
+        const storedKeys = readVisibleKeys(regularFields, storageKey);
         if (storedKeys && storedKeys.length > 0) {
-            return ensureSchemaOrder(filterSchema, storedKeys);
+            return ensureSchemaOrder(regularFields, storedKeys);
         }
-        return deriveDefaultVisibleKeys(filterSchema);
-    }, [filterSchema, storageKey]);
+        return deriveDefaultVisibleKeys(regularFields);
+    }, [regularFields, storageKey]);
     const [visibleKeys, setVisibleKeys] = React.useState(resolveInitialVisibleKeys);
     React.useEffect(() => {
         setVisibleKeys(previous => {
-            const ordered = ensureSchemaOrder(filterSchema, previous);
+            const ordered = ensureSchemaOrder(regularFields, previous);
             if (ordered.length) {
                 return ordered;
             }
             return resolveInitialVisibleKeys();
         });
-    }, [filterSchema, resolveInitialVisibleKeys]);
+    }, [regularFields, resolveInitialVisibleKeys]);
     React.useEffect(() => {
         writeVisibleKeys(storageKey, visibleKeys);
         onVisibleFieldsChange === null || onVisibleFieldsChange === void 0 ? void 0 : onVisibleFieldsChange(visibleKeys);
@@ -151,12 +159,12 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
     React.useEffect(() => {
         formMethods.reset(mergedDefaultValues);
     }, [formMethods, mergedDefaultValues]);
-    const normalisedValues = React.useMemo(() => normaliseOutputValues(filterSchema, formValues), [filterSchema, formValues]);
+    const normalisedValues = React.useMemo(() => normaliseOutputValues(flattenedSchema, formValues), [flattenedSchema, formValues]);
     const hasInitialValuesRef = React.useRef(false);
     React.useEffect(() => {
-        const initialValues = normaliseOutputValues(filterSchema, mergedDefaultValues);
+        const initialValues = normaliseOutputValues(flattenedSchema, mergedDefaultValues);
         hasInitialValuesRef.current = Object.keys(initialValues).length > 0;
-    }, [filterSchema, mergedDefaultValues]);
+    }, [flattenedSchema, mergedDefaultValues]);
     const serialisedValues = React.useMemo(() => JSON.stringify(normalisedValues), [normalisedValues]);
     const debouncedSerialisedValues = useDebouncedValue(serialisedValues, FILTER_DEBOUNCE_DELAY);
     const lastPersistedValuesRef = React.useRef(null);
@@ -171,14 +179,25 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
         writeStoredValues(storageKey, values);
         return nextSerialised;
     }, [storageKey]);
+    // Use a ref to track the current serialised values for staleness checks
+    const currentSerialisedValuesRef = React.useRef(serialisedValues);
+    React.useEffect(() => {
+        currentSerialisedValuesRef.current = serialisedValues;
+    }, [serialisedValues]);
     React.useEffect(() => {
         if (debouncedSerialisedValues == null) {
             return;
         }
+        // Skip if we've already processed this exact debounced value
         if (hasEmittedValuesRef.current &&
             lastPersistedValuesRef.current === debouncedSerialisedValues) {
             return;
         }
+        // Skip if the debounced value is stale (doesn't match current state)
+        // This prevents old debounced values from overwriting manual updates
+        if (currentSerialisedValuesRef.current !== debouncedSerialisedValues) {
+            return;
+        }
         const parsedValues = JSON.parse(debouncedSerialisedValues);
         const isEmpty = Object.keys(parsedValues).length === 0;
         if (!hasEmittedValuesRef.current &&
@@ -197,7 +216,7 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
     }, [storageKey]);
     const handleClearAll = React.useCallback(() => {
         const clearedDefaults = Object.assign({}, baseDefaultValues);
-        filterSchema.forEach(field => {
+        flattenedSchema.forEach(field => {
             const key = String(field.key);
             const defaultValue = baseDefaultValues[key];
             const resolved = resolveClearedFieldValue(field, defaultValue);
@@ -213,13 +232,20 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
             keepTouched: false
         });
         onClearAll === null || onClearAll === void 0 ? void 0 : onClearAll();
-        const nextValues = normaliseOutputValues(filterSchema, clearedDefaults);
+        const nextValues = normaliseOutputValues(flattenedSchema, clearedDefaults);
         hasInitialValuesRef.current = Object.keys(nextValues).length > 0;
         const nextSerialised = persistValues(nextValues);
         hasEmittedValuesRef.current = true;
         lastPersistedValuesRef.current = nextSerialised !== null && nextSerialised !== void 0 ? nextSerialised : null;
         onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange(nextValues);
-    }, [baseDefaultValues, filterSchema, formMethods, onClearAll, persistValues]);
+    }, [
+        baseDefaultValues,
+        flattenedSchema,
+        formMethods,
+        onClearAll,
+        onValuesChange,
+        persistValues
+    ]);
     const handleOpenModal = React.useCallback(() => {
         setIsModalOpen(true);
         setSearchTerm('');
@@ -237,31 +263,40 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
             const nextKeys = exists
                 ? prev.filter(item => item !== key)
                 : [...prev, key];
-            return ensureSchemaOrder(filterSchema, nextKeys);
+            return ensureSchemaOrder(regularFields, nextKeys);
         });
-    }, [filterSchema]);
+    }, [regularFields]);
     const handleRemoveFilter = React.useCallback((key) => {
-        const schemaField = filterSchema.find(field => String(field.key) === key);
+        const schemaField = flattenedSchema.find(field => String(field.key) === key);
         if (!schemaField) {
             return;
         }
         const defaultValue = baseDefaultValues[String(schemaField.key)];
         const fieldPath = schemaField.key;
         const nextValue = resolveClearedFieldValue(schemaField, defaultValue);
+        // Update the form value
         formMethods.setValue(fieldPath, nextValue, {
             shouldDirty: false,
             shouldTouch: false,
             shouldValidate: false
         });
-        const nextValues = normaliseOutputValues(filterSchema, formMethods.getValues());
-        const nextSerialised = persistValues(nextValues);
+        // Compute the updated values immediately (don't wait for debounce)
+        const currentValues = formMethods.getValues() || {};
+        const updatedFormValues = Object.assign(Object.assign({}, currentValues), { [fieldPath]: nextValue });
+        const nextValues = normaliseOutputValues(flattenedSchema, updatedFormValues);
+        const nextSerialised = JSON.stringify(nextValues);
+        // Persist immediately (bypass debounce for remove action)
+        persistValues(nextValues);
+        // Update refs to mark this as the latest persisted state
+        lastPersistedValuesRef.current = nextSerialised;
+        currentSerialisedValuesRef.current = nextSerialised;
         hasEmittedValuesRef.current = true;
-        lastPersistedValuesRef.current = nextSerialised !== null && nextSerialised !== void 0 ? nextSerialised : null;
         hasInitialValuesRef.current = Object.keys(nextValues).length > 0;
+        // Emit the change to parent
         onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange(nextValues);
     }, [
         baseDefaultValues,
-        filterSchema,
+        flattenedSchema,
         formMethods,
         onValuesChange,
         persistValues
@@ -269,20 +304,20 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
     const filteredFields = React.useMemo(() => {
         const normalisedTerm = searchTerm.trim().toLowerCase();
         if (!normalisedTerm) {
-            return filterSchema;
+            return regularFields;
         }
-        return filterSchema.filter(field => {
+        return regularFields.filter(field => {
             const searchable = [field.label, field.placeholder, String(field.key)]
                 .filter(Boolean)
                 .map(value => String(value).toLowerCase());
             return searchable.some(text => text.includes(normalisedTerm));
         });
-    }, [filterSchema, searchTerm]);
+    }, [regularFields, searchTerm]);
     const paginatedFields = React.useMemo(() => {
         const start = (modalPage - 1) * modalPageSize;
         return filteredFields.slice(start, start + modalPageSize);
     }, [filteredFields, modalPage, modalPageSize]);
-    const visibleFields = React.useMemo(() => filterSchema.filter(field => visibleKeys.includes(String(field.key))), [filterSchema, visibleKeys]);
+    const visibleFields = React.useMemo(() => regularFields.filter(field => visibleKeys.includes(String(field.key))), [regularFields, visibleKeys]);
     const renderFieldComponent = (field) => {
         const ariaLabel = getFieldAriaLabel(field);
         switch (field.type) {
@@ -309,10 +344,17 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
                     });
                 }
                 return (React.createElement(Text, { type: "secondary", className: "akinon-filter__unsupported" }, i18n.t('form.unsupportedField', { field: String(field.type) })));
+            case 'section':
+                // Section fields should not be rendered inline
+                // They are rendered separately after the main grid
+                return null;
             default:
                 return (React.createElement(Text, { type: "secondary", className: "akinon-filter__unsupported" }, i18n.t('form.unsupportedField', { field: String(field.type) })));
         }
     };
+    const renderFormField = (field) => {
+        return (React.createElement(FormItem, { key: String(field.key), control: formMethods.control, name: field.key, tooltip: field.tooltip, help: field.help, labelDescription: field.labelDescription, required: Boolean(field.validation), className: "mb-0", valuePropName: field.type === 'checkbox' ? 'checked' : undefined }, renderFieldComponent(field)));
+    };
     return (React.createElement(Card, { size: "small", className: "akinon-filter shadow", "data-testid": "akifilter-root" },
         React.createElement(ConfigProvider, { theme: themeOverrides },
             React.createElement(FilterToolbar, { onOpenModal: handleOpenModal, enableImportCsv: enableImportCsv, enableImportXls: enableImportXls, onImportCsv: onImportCsv, onImportXls: onImportXls }),
@@ -320,8 +362,17 @@ const AkifilterContent = ({ filterSchema, storageNamespace, defaultValues, onVal
             React.createElement("div", { className: "akinon-filter__body" },
                 React.createElement(Akiform, { layout: "vertical", className: "akinon-filter__form" },
                     React.createElement("div", { className: "akinon-filter__form-grid", "data-testid": "akifilter-form-grid" },
-                        visibleFields.map(field => (React.createElement(FormItem, { key: String(field.key), control: formMethods.control, name: field.key, tooltip: field.tooltip, help: field.help, labelDescription: field.labelDescription, required: Boolean(field.validation), className: "mb-0", valuePropName: field.type === 'checkbox' ? 'checked' : undefined }, renderFieldComponent(field)))),
-                        visibleFields.length === 0 ? (React.createElement("div", { className: "akinon-filter__empty" }, i18n.t('form.noVisibleFields'))) : null))),
+                        visibleFields.map(renderFormField),
+                        visibleFields.length === 0 ? (React.createElement("div", { className: "akinon-filter__empty" }, i18n.t('form.noVisibleFields'))) : null),
+                    sectionFields.length > 0 && (React.createElement("div", { className: "akinon-filter__section-fields" }, sectionFields.map(section => {
+                        return (React.createElement(Collapse, { key: section.key, defaultActiveKey: section.key, ghost: true, items: [
+                                {
+                                    key: section.key,
+                                    label: section.label,
+                                    children: (React.createElement("div", { className: "akinon-filter__form-grid" }, section.fields.map(renderFormField)))
+                                }
+                            ] }));
+                    }))))),
             React.createElement(VisibilityModal, { open: isModalOpen, onClose: handleCloseModal, searchTerm: searchTerm, paginatedFields: paginatedFields, filteredCount: filteredFields.length, visibleKeys: visibleKeys, onSearchTermChange: value => {
                     setSearchTerm(value);
                     setModalPage(1);

package/dist/esm/common/storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/common/storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAqB/C,eAAO,MAAM,eAAe,GAAI,YAAY,SAAS,WAAW,EAC9D,QAAQ,cAAc,CAAC,YAAY,CAAC,EAAE,EACtC,YAAY,MAAM,KACjB,MAKF,CAAC;AAIF,eAAO,MAAM,eAAe,GAAI,YAAY,SAAS,WAAW,EAC9D,QAAQ,cAAc,CAAC,YAAY,CAAC,EAAE,EACtC,YAAY,MAAM,KACjB,MAAM,EAAE,GAAG,IAuBb,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,YAAY,MAAM,EAAE,MAAM,MAAM,EAAE,KAAG,IAQrE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,YAAY,MAAM,KAAG,IAQrD,CAAC;AAKF,eAAO,MAAM,gBAAgB,GAAI,YAAY,SAAS,WAAW,EAC/D,QAAQ,cAAc,CAAC,YAAY,CAAC,EAAE,EACtC,YAAY,MAAM,KACjB,OAAO,CAAC,YAAY,CAAC,GAAG,IA+B1B,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,YAAY,SAAS,WAAW,EAChE,YAAY,MAAM,EAClB,QAAQ,OAAO,CAAC,YAAY,CAAC,KAC5B,IAeF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,IAQtD,CAAC"}
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/common/storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAqB/C,eAAO,MAAM,eAAe,GAAI,YAAY,SAAS,WAAW,EAC9D,QAAQ,cAAc,CAAC,YAAY,CAAC,EAAE,EACtC,YAAY,MAAM,KACjB,MAKF,CAAC;AAIF,eAAO,MAAM,eAAe,GAAI,YAAY,SAAS,WAAW,EAC9D,QAAQ,cAAc,CAAC,YAAY,CAAC,EAAE,EACtC,YAAY,MAAM,KACjB,MAAM,EAAE,GAAG,IAoBb,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,YAAY,MAAM,EAAE,MAAM,MAAM,EAAE,KAAG,IAQrE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,YAAY,MAAM,KAAG,IAQrD,CAAC;AAKF,eAAO,MAAM,gBAAgB,GAAI,YAAY,SAAS,WAAW,EAC/D,QAAQ,cAAc,CAAC,YAAY,CAAC,EAAE,EACtC,YAAY,MAAM,KACjB,OAAO,CAAC,YAAY,CAAC,GAAG,IA+B1B,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,YAAY,SAAS,WAAW,EAChE,YAAY,MAAM,EAClB,QAAQ,OAAO,CAAC,YAAY,CAAC,KAC5B,IAeF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,IAQtD,CAAC"}

package/dist/esm/common/storage.js

@@ -1,3 +1,4 @@
+import { i18n } from '../i18n';
 const STORAGE_PREFIX = 'akifilter:v1';
 const VALUES_SUFFIX = ':values';
 const hashString = (value) => {
@@ -35,7 +36,7 @@ export const readVisibleKeys = (schema, storageKey) => {
         return parsed.filter(key => schemaKeys.has(String(key)));
     }
     catch (error) {
-        console.warn('Akifilter: unable to read visibility state from storage', error);
+        console.warn(i18n.t('errors.storage.readVisibility'), error);
         return null;
     }
 };
@@ -46,7 +47,7 @@ export const writeVisibleKeys = (storageKey, keys) => {
         window.localStorage.setItem(storageKey, JSON.stringify(keys));
     }
     catch (error) {
-        console.warn('Akifilter: unable to persist visibility state', error);
+        console.warn(i18n.t('errors.storage.writeVisibility'), error);
     }
 };
 export const clearVisibleKeys = (storageKey) => {
@@ -56,7 +57,7 @@ export const clearVisibleKeys = (storageKey) => {
         window.localStorage.removeItem(storageKey);
     }
     catch (error) {
-        console.warn('Akifilter: unable to clear visibility state', error);
+        console.warn(i18n.t('errors.storage.clearVisibility'), error);
     }
 };
 const buildValuesStorageKey = (storageKey) => `${storageKey}${VALUES_SUFFIX}`;
@@ -82,7 +83,7 @@ export const readStoredValues = (schema, storageKey) => {
         }, {});
     }
     catch (error) {
-        console.warn('Akifilter: unable to read values from storage', error);
+        console.warn(i18n.t('errors.storage.readValues'), error);
         return null;
     }
 };
@@ -99,7 +100,7 @@ export const writeStoredValues = (storageKey, values) => {
         window.localStorage.setItem(valuesKey, JSON.stringify(values));
     }
     catch (error) {
-        console.warn('Akifilter: unable to persist values', error);
+        console.warn(i18n.t('errors.storage.writeValues'), error);
     }
 };
 export const clearStoredValues = (storageKey) => {
@@ -109,6 +110,6 @@ export const clearStoredValues = (storageKey) => {
         window.localStorage.removeItem(buildValuesStorageKey(storageKey));
     }
     catch (error) {
-        console.warn('Akifilter: unable to clear stored values', error);
+        console.warn(i18n.t('errors.storage.clearValues'), error);
     }
 };

package/dist/esm/constants.d.ts

@@ -1,4 +1,10 @@
 export declare const DEFAULT_VISIBLE_COUNT = 8;
 export declare const DEFAULT_MODAL_PAGE_SIZE = 40;
 export declare const FILTER_DEBOUNCE_DELAY = 300;
+export declare const DATE_FORMAT = "YYYY-MM-DD";
+export declare const DATETIME_FORMAT = "YYYY-MM-DD HH:mm:ss";
+export declare const BOOLEAN_STRING: {
+    readonly TRUE: "true";
+    readonly FALSE: "false";
+};
 //# sourceMappingURL=constants.d.ts.map

package/dist/esm/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,IAAI,CAAC;AACvC,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,qBAAqB,MAAM,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,IAAI,CAAC;AACvC,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,eAAO,MAAM,WAAW,eAAe,CAAC;AACxC,eAAO,MAAM,eAAe,wBAAwB,CAAC;AAErD,eAAO,MAAM,cAAc;;;CAGjB,CAAC"}

package/dist/esm/constants.js

@@ -1,3 +1,9 @@
 export const DEFAULT_VISIBLE_COUNT = 8;
 export const DEFAULT_MODAL_PAGE_SIZE = 40;
 export const FILTER_DEBOUNCE_DELAY = 300;
+export const DATE_FORMAT = 'YYYY-MM-DD';
+export const DATETIME_FORMAT = 'YYYY-MM-DD HH:mm:ss';
+export const BOOLEAN_STRING = {
+    TRUE: 'true',
+    FALSE: 'false'
+};

package/dist/esm/i18n/translations/en.d.ts

@@ -29,6 +29,14 @@ declare const translations: {
         readonly title: "Akifilter failed to load";
         readonly description: "An unexpected error occurred while rendering the filters. Try again or refresh the page.";
         readonly retry: "Try again";
+        readonly storage: {
+            readonly readVisibility: "Akifilter: unable to read visibility state from storage";
+            readonly writeVisibility: "Akifilter: unable to persist visibility state";
+            readonly clearVisibility: "Akifilter: unable to clear visibility state";
+            readonly readValues: "Akifilter: unable to read values from storage";
+            readonly writeValues: "Akifilter: unable to persist values";
+            readonly clearValues: "Akifilter: unable to clear stored values";
+        };
     };
 };
 export default translations;

package/dist/esm/i18n/translations/en.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../src/i18n/translations/en.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCR,CAAC;AAEX,eAAe,YAAY,CAAC"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../src/i18n/translations/en.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCR,CAAC;AAEX,eAAe,YAAY,CAAC"}

package/dist/esm/i18n/translations/en.js

@@ -28,7 +28,15 @@ const translations = {
     errors: {
         title: 'Akifilter failed to load',
         description: 'An unexpected error occurred while rendering the filters. Try again or refresh the page.',
-        retry: 'Try again'
+        retry: 'Try again',
+        storage: {
+            readVisibility: 'Akifilter: unable to read visibility state from storage',
+            writeVisibility: 'Akifilter: unable to persist visibility state',
+            clearVisibility: 'Akifilter: unable to clear visibility state',
+            readValues: 'Akifilter: unable to read values from storage',
+            writeValues: 'Akifilter: unable to persist values',
+            clearValues: 'Akifilter: unable to clear stored values'
+        }
     }
 };
 export default translations;

package/dist/esm/i18n/translations/tr.d.ts

@@ -29,6 +29,14 @@ declare const translations: {
         readonly title: "Akifilter yüklenemedi";
         readonly description: "Filtreler render edilirken beklenmeyen bir hata oluştu. Lütfen tekrar deneyin veya sayfayı yenileyin.";
         readonly retry: "Tekrar dene";
+        readonly storage: {
+            readonly readVisibility: "Akifilter: görünürlük durumu depodan okunamadı";
+            readonly writeVisibility: "Akifilter: görünürlük durumu kalıcı hale getirilemedi";
+            readonly clearVisibility: "Akifilter: görünürlük durumu temizlenemedi";
+            readonly readValues: "Akifilter: değerler depodan okunamadı";
+            readonly writeValues: "Akifilter: değerler kalıcı hale getirilemedi";
+            readonly clearValues: "Akifilter: kayıtlı değerler temizlenemedi";
+        };
     };
 };
 export default translations;

package/dist/esm/i18n/translations/tr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../src/i18n/translations/tr.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCR,CAAC;AAEX,eAAe,YAAY,CAAC"}
+{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../src/i18n/translations/tr.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCR,CAAC;AAEX,eAAe,YAAY,CAAC"}

package/dist/esm/i18n/translations/tr.js

@@ -28,7 +28,15 @@ const translations = {
     errors: {
         title: 'Akifilter yüklenemedi',
         description: 'Filtreler render edilirken beklenmeyen bir hata oluştu. Lütfen tekrar deneyin veya sayfayı yenileyin.',
-        retry: 'Tekrar dene'
+        retry: 'Tekrar dene',
+        storage: {
+            readVisibility: 'Akifilter: görünürlük durumu depodan okunamadı',
+            writeVisibility: 'Akifilter: görünürlük durumu kalıcı hale getirilemedi',
+            clearVisibility: 'Akifilter: görünürlük durumu temizlenemedi',
+            readValues: 'Akifilter: değerler depodan okunamadı',
+            writeValues: 'Akifilter: değerler kalıcı hale getirilemedi',
+            clearValues: 'Akifilter: kayıtlı değerler temizlenemedi'
+        }
     }
 };
 export default translations;

package/dist/esm/styles.css

@@ -51,6 +51,15 @@
   top: 1px;
 }
 
+.akinon-filter__common-filters {
+  margin-top: 2rem;
+}
+
+.akinon-filter__common-filters-title {
+  color: var(--color-gray-500);
+  margin-bottom: 1rem;
+}
+
 .akinon-filter__form-grid {
   display: grid;
   grid-template-columns: repeat(4, minmax(0, 1fr));
@@ -65,6 +74,27 @@
   width: 100%;
 }
 
+.akinon-filter__section-fields {
+  margin-top: 2rem;
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.akinon-filter__section-fields .akinon-collapse-header {
+  padding-bottom: 0 !important;
+}
+
+.akinon-filter__section-fields .akinon-collapse-header-text {
+  color: var(--color-gray-500);
+}
+
+.akinon-filter__section-fields .akinon-collapse-expand-icon .akinon-collapse-arrow {
+  font-size: 1rem !important;
+  color: var(--color-gray-500) !important;
+}
+
+
 @media (max-width: 1024px) {
   .akinon-filter__form-grid {
     grid-template-columns: repeat(2, minmax(0, 1fr));

package/dist/esm/utils/schema.d.ts

@@ -1,5 +1,19 @@
 import type { FieldValues } from '@akinon/akiform';
 import type { AkifilterField, AkifilterSchema } from '../types';
+/**
+ * Flattens schema by extracting all nested fields from section fields.
+ * This is used for storage operations and form value management.
+ */
+export declare const flattenSchema: <TFieldValues extends FieldValues = FieldValues>(schema: AkifilterSchema<TFieldValues>) => AkifilterSchema<TFieldValues>;
+/**
+ * Separates section fields from regular fields.
+ */
+export declare const partitionSchema: <TFieldValues extends FieldValues = FieldValues>(schema: AkifilterSchema<TFieldValues>) => {
+    regularFields: AkifilterSchema<TFieldValues>;
+    sectionFields: Array<AkifilterField<TFieldValues> & {
+        fields: AkifilterSchema<TFieldValues>;
+    }>;
+};
 export declare const getDisplayLabel: <TFieldValues extends FieldValues = FieldValues>(field: AkifilterField<TFieldValues>) => string;
 export declare const getFieldAriaLabel: <TFieldValues extends FieldValues = FieldValues>(field: AkifilterField<TFieldValues>) => string;
 export declare const ensureSchemaOrder: <TFieldValues extends FieldValues = FieldValues>(schema: AkifilterSchema<TFieldValues>, keys: string[]) => string[];

package/dist/esm/utils/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/utils/schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhE,eAAO,MAAM,eAAe,GAAI,YAAY,SAAS,WAAW,GAAG,WAAW,EAC5E,OAAO,cAAc,CAAC,YAAY,CAAC,KAClC,MAEF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,OAAO,cAAc,CAAC,YAAY,CAAC,KAClC,MAEF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,QAAQ,eAAe,CAAC,YAAY,CAAC,EACrC,MAAM,MAAM,EAAE,KACb,MAAM,EAGR,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,QAAQ,eAAe,CAAC,YAAY,CAAC,KACpC,MAAM,EAUR,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,QAAQ,eAAe,CAAC,YAAY,CAAC,KACpC,OAAO,CAAC,YAAY,CAQtB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,QAAQ,eAAe,CAAC,YAAY,CAAC,EACrC,SAAS,OAAO,CAAC,YAAY,CAAC,KAC7B,OAAO,CAAC,YAAY,CA+BtB,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/utils/schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,YAAY,SAAS,WAAW,GAAG,WAAW,EAC1E,QAAQ,eAAe,CAAC,YAAY,CAAC,KACpC,eAAe,CAAC,YAAY,CAW9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,YAAY,SAAS,WAAW,GAAG,WAAW,EAC5E,QAAQ,eAAe,CAAC,YAAY,CAAC,KACpC;IACD,aAAa,EAAE,eAAe,CAAC,YAAY,CAAC,CAAC;IAC7C,aAAa,EAAE,KAAK,CAClB,cAAc,CAAC,YAAY,CAAC,GAAG;QAC7B,MAAM,EAAE,eAAe,CAAC,YAAY,CAAC,CAAC;KACvC,CACF,CAAC;CAwBH,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,YAAY,SAAS,WAAW,GAAG,WAAW,EAC5E,OAAO,cAAc,CAAC,YAAY,CAAC,KAClC,MAEF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,OAAO,cAAc,CAAC,YAAY,CAAC,KAClC,MAEF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,QAAQ,eAAe,CAAC,YAAY,CAAC,EACrC,MAAM,MAAM,EAAE,KACb,MAAM,EAGR,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,QAAQ,eAAe,CAAC,YAAY,CAAC,KACpC,MAAM,EAUR,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,QAAQ,eAAe,CAAC,YAAY,CAAC,KACpC,OAAO,CAAC,YAAY,CAQtB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,QAAQ,eAAe,CAAC,YAAY,CAAC,EACrC,SAAS,OAAO,CAAC,YAAY,CAAC,KAC7B,OAAO,CAAC,YAAY,CA+BtB,CAAC"}

package/dist/esm/utils/schema.js

@@ -1,5 +1,37 @@
 import { akidate } from '@akinon/akidate';
 import { DEFAULT_VISIBLE_COUNT } from '../constants';
+/**
+ * Flattens schema by extracting all nested fields from section fields.
+ * This is used for storage operations and form value management.
+ */
+export const flattenSchema = (schema) => {
+    return schema.reduce((acc, field) => {
+        if (field.type === 'section' && 'fields' in field) {
+            // Recursively flatten nested section fields
+            return [
+                ...acc,
+                ...flattenSchema(field.fields)
+            ];
+        }
+        return [...acc, field];
+    }, []);
+};
+/**
+ * Separates section fields from regular fields.
+ */
+export const partitionSchema = (schema) => {
+    const regularFields = [];
+    const sectionFields = [];
+    schema.forEach(field => {
+        if (field.type === 'section') {
+            sectionFields.push(field);
+        }
+        else {
+            regularFields.push(field);
+        }
+    });
+    return { regularFields, sectionFields };
+};
 export const getDisplayLabel = (field) => {
     return field.label || field.placeholder || String(field.key);
 };

package/dist/esm/utils/values.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../../src/utils/values.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhE,eAAO,MAAM,kBAAkB,GAC7B,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,OAAO,cAAc,CAAC,YAAY,CAAC,GAAG,SAAS,EAC/C,OAAO,OAAO,KACb,OAkBF,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,QAAQ,eAAe,CAAC,YAAY,CAAC,EACrC,SAAS,OAAO,CAAC,YAAY,CAAC,GAAG,WAAW,KAC3C,OAAO,CAAC,YAAY,CA8BtB,CAAC"}
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../../src/utils/values.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhE,eAAO,MAAM,kBAAkB,GAC7B,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,OAAO,cAAc,CAAC,YAAY,CAAC,GAAG,SAAS,EAC/C,OAAO,OAAO,KACb,OAkBF,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,YAAY,SAAS,WAAW,GAAG,WAAW,EAE9C,QAAQ,eAAe,CAAC,YAAY,CAAC,EACrC,SAAS,OAAO,CAAC,YAAY,CAAC,GAAG,WAAW,KAC3C,OAAO,CAAC,YAAY,CAkCtB,CAAC"}

package/dist/esm/utils/values.js

@@ -1,4 +1,5 @@
 import { akidate } from '@akinon/akidate';
+import { DATE_FORMAT, DATETIME_FORMAT } from '../constants';
 export const shouldPersistValue = (field, value) => {
     if (value === undefined || value === null) {
         return false;
@@ -30,7 +31,10 @@ export const normaliseOutputValues = (schema, values) => {
             if (!normalised) {
                 return acc;
             }
-            normalisedValue = akidate.formatIsoDate(normalised, 'YYYY-MM-DD');
+            // Format with time if showTime is enabled, otherwise date only
+            const hasShowTime = 'showTime' in field && field.showTime;
+            const format = hasShowTime ? DATETIME_FORMAT : DATE_FORMAT;
+            normalisedValue = akidate.formatIsoDate(normalised, format);
         }
         acc[key] =
             normalisedValue;