@neovici/cosmoz-omnitable 14.14.3 → 14.15.1

package/dist/lib/use-omnitable.d.ts

@@ -0,0 +1,37 @@
+export function useOmnitable(host: any): {
+    header: {
+        allSelected: any;
+        onAllCheckboxChange: (event: any) => void;
+        data: any;
+        settingsConfig: any;
+        filters: any;
+        groupOnColumn: any;
+        sortAndGroup: any;
+    };
+    list: {
+        processedItems: any;
+        dataIsValid: any;
+        filterIsTooStrict: any;
+        loading: any;
+        compareItemsFn: any;
+        displayEmptyGroups: any;
+        error: any;
+        renderItem: (item: any, index: any, { selected, expanded, toggleCollapse }: {
+            selected: any;
+            expanded: any;
+            toggleCollapse: any;
+        }) => import("lit-html").TemplateResult<1>;
+        renderGroup: (item: any, index: any, { selected, folded, toggleFold }: {
+            selected: any;
+            folded: any;
+            toggleFold: any;
+        }) => import("lit-html").TemplateResult<1>;
+    };
+    footer: {
+        csvFilename: any;
+        xlsxFilename: any;
+        xlsxSheetname: any;
+        topPlacement: any;
+    };
+};
+//# sourceMappingURL=use-omnitable.d.ts.map

package/dist/lib/use-omnitable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-omnitable.d.ts","sourceRoot":"","sources":["../../src/lib/use-omnitable.js"],"names":[],"mappings":"AAUO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwFN"}

package/dist/lib/use-omnitable.js

@@ -0,0 +1,74 @@
+import { useState } from '@pionjs/pion';
+import { useSettings } from './settings';
+import { useFastLayout } from './use-fast-layout';
+import { useFooter } from './use-footer';
+import { useHeader } from './use-header';
+import { useList } from './use-list';
+import { useProcessedItems } from './use-processed-items';
+import { usePublicInterface } from './use-public-interface';
+import { useSortAndGroupOptions } from './use-sort-and-group-options';
+export const useOmnitable = (host) => {
+    const { hashParam, settingsId, data, resizeSpeedFactor, noLocal, noLocalSort = noLocal, noLocalFilter = noLocal, error, rowPartFn, } = host, settingS = useSettings({ settingsId, host }), { settings, setSettings, columns, resetRef } = settingS, sortAndGroupOptions = useSortAndGroupOptions(columns, hashParam, settings, setSettings, resetRef), 
+    // TODO: drop filterFunctions
+    { processedItems, visibleData, filters, setFilterState, filterFunctions } = useProcessedItems({
+        data,
+        columns,
+        hashParam,
+        sortAndGroupOptions,
+        noLocalSort,
+        noLocalFilter,
+    }), { isMini, collapsedColumns, miniColumns } = useFastLayout({
+        host,
+        columns,
+        settings,
+        setSettings,
+        resizeSpeedFactor,
+        sortAndGroupOptions,
+    }), dataIsValid = data && Array.isArray(data) && data.length > 0, [selectedItems, setSelectedItems] = useState([]);
+    usePublicInterface({
+        host,
+        visibleData,
+        sortedFilteredGroupedItems: processedItems,
+        columns,
+        filters,
+        setFilterState,
+        selectedItems,
+        isMini,
+        ...sortAndGroupOptions,
+    });
+    return {
+        header: useHeader({
+            host,
+            selectedItems,
+            sortAndGroupOptions,
+            dataIsValid,
+            data,
+            columns,
+            filters,
+            collapsedColumns,
+            settings,
+            filterFunctions,
+            settingS,
+            setFilterState,
+            hideSelectAll: host.hideSelectAll === true,
+        }),
+        list: useList({
+            host,
+            error,
+            dataIsValid,
+            processedItems,
+            setSelectedItems,
+            columns,
+            collapsedColumns,
+            miniColumns,
+            sortAndGroupOptions,
+            rowPartFn,
+        }),
+        footer: useFooter({
+            host,
+            selectedItems,
+            columns,
+        }),
+    };
+};
+//# sourceMappingURL=use-omnitable.js.map

package/dist/lib/use-processed-items.d.ts

@@ -0,0 +1,17 @@
+export function useProcessedItems({ data, columns, hashParam, sortAndGroupOptions, noLocalSort, noLocalFilter, }: {
+    data: any;
+    columns: any;
+    hashParam: any;
+    sortAndGroupOptions: any;
+    noLocalSort: any;
+    noLocalFilter: any;
+}): {
+    processedItems: any;
+    visibleData: any[];
+    filters: any;
+    filterFunctions: {
+        [k: string]: any;
+    };
+    setFilterState: (name: any, state: any) => any;
+};
+//# sourceMappingURL=use-processed-items.d.ts.map

package/dist/lib/use-processed-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-processed-items.d.ts","sourceRoot":"","sources":["../../src/lib/use-processed-items.js"],"names":[],"mappings":"AA+BO;;;;;;;;;;;;;;;EA8NN"}

package/dist/lib/use-processed-items.js

@@ -0,0 +1,151 @@
+import { useCallback, useEffect, useMemo } from '@pionjs/pion';
+import { invoke } from '@neovici/cosmoz-utils/function';
+import { genericSorter } from './generic-sorter';
+import { columnSymbol } from './use-dom-columns';
+import { useHashState } from './use-hash-state';
+import { indexSymbol } from './utils';
+const sortBy = (valueFn, descending) => (a, b) => genericSorter(valueFn(a), valueFn(b)) * (descending ? -1 : 1), kebab = (input) => input.replace(/([a-z0-9])([A-Z])/gu, '$1-$2').toLowerCase(), notifyChanges = (column, changes) => {
+    if (!column || !changes) {
+        return;
+    }
+    Object.entries(changes).forEach(([key, value]) => {
+        column[columnSymbol].__ownChange = true;
+        column[columnSymbol][key] = value;
+        column[columnSymbol].__ownChange = false;
+        column[columnSymbol].dispatchEvent(new CustomEvent(`${kebab(key)}-changed`, {
+            bubbles: true,
+            detail: { value },
+        }));
+    });
+}, assignIndex = (item, index) => Object.assign(item, { [indexSymbol]: index }), unparsed = Symbol('unparsed');
+export const useProcessedItems = ({ data, columns, hashParam, sortAndGroupOptions, noLocalSort, noLocalFilter, }) => {
+    const { groupOnColumn, groupOnDescending, sortOnColumn, descending } = sortAndGroupOptions, write = useCallback(([filter, value]) => {
+        const column = columns.find(({ name }) => name === filter);
+        if (column == null) {
+            return [filter, undefined];
+        }
+        return [
+            filter,
+            value.filter && column.serializeFilter(column, value.filter),
+        ];
+    }, [columns]), read = useCallback(([filter, value]) => {
+        const column = columns.find(({ name }) => name === filter);
+        if (column == null) {
+            return [filter, { [unparsed]: value }];
+        }
+        const state = { filter: column.deserializeFilter(column, value) };
+        notifyChanges(column, state);
+        return [filter, state];
+    }, [columns]), [filters, setFilters] = useHashState({}, hashParam, {
+        multi: true,
+        suffix: '-filter--',
+        write,
+        read,
+    }), 
+    // TODO: drop extra info from state
+    setFilterState = useCallback((name, state) => setFilters((filters) => {
+        const newState = invoke(state, filters[name]);
+        notifyChanges(columns.find((c) => c.name === name), newState);
+        return { ...filters, [name]: { ...filters[name], ...newState } };
+    }), [columns, setFilters]), filterValues = useMemo(() => Object.values(filters).map((f) => f.filter), [filters]), filterFunctions = useMemo(() => {
+        return Object.fromEntries(columns
+            .map((col) => [
+            col.name,
+            !col.noLocalFilter &&
+                col.getFilterFn(col, filters[col.name]?.filter),
+        ])
+            .filter(([, fn]) => !!fn));
+    }, [columns, ...filterValues]), filteredItems = useMemo(() => {
+        if (!Array.isArray(data) || data.length === 0) {
+            return [];
+        }
+        if (Object.entries(filterFunctions).length === 0 || noLocalFilter) {
+            return data.slice();
+        }
+        return data.filter((item) => Object.values(filterFunctions).every((filterFn) => filterFn(item)));
+    }, [data, filterFunctions, noLocalFilter]), 
+    // todo: extract function
+    processedItems = useMemo(() => {
+        if (!noLocalSort &&
+            !groupOnColumn &&
+            sortOnColumn != null &&
+            sortOnColumn.sortOn != null) {
+            return filteredItems
+                .slice()
+                .sort(sortBy((a) => sortOnColumn.getComparableValue({ ...sortOnColumn, valuePath: sortOnColumn.sortOn }, a), descending));
+        }
+        if (groupOnColumn != null && groupOnColumn.groupOn != null) {
+            const groupedResults = filteredItems.reduce((acc, item) => {
+                const gval = groupOnColumn.getComparableValue({ ...groupOnColumn, valuePath: groupOnColumn.groupOn }, item);
+                if (gval === undefined) {
+                    return acc;
+                }
+                let group = acc.find((g) => g.id === gval);
+                if (!group) {
+                    group = { id: gval, name: gval, items: [item] };
+                    return [...acc, group];
+                }
+                group.items.push(item);
+                return acc;
+            }, []);
+            groupedResults.sort(sortBy((a) => groupOnColumn.getComparableValue({ ...groupOnColumn, valuePath: groupOnColumn.groupOn }, a.items[0]), groupOnDescending));
+            if (!sortOnColumn || noLocalSort) {
+                return groupedResults;
+            }
+            return groupedResults
+                .filter((group) => Array.isArray(group.items))
+                .map((group) => {
+                group.items.sort(sortBy((a) => sortOnColumn.getComparableValue({ ...sortOnColumn, valuePath: sortOnColumn.sortOn }, a), descending));
+                return group;
+            });
+        }
+        return filteredItems;
+    }, [
+        filteredItems,
+        groupOnColumn,
+        groupOnDescending,
+        sortOnColumn,
+        descending,
+        noLocalSort,
+    ]), visibleData = useMemo(() => {
+        let index = 0, groupIndex = 0;
+        const result = [];
+        processedItems.forEach((item) => {
+            if (Array.isArray(item.items)) {
+                assignIndex(item, groupIndex++);
+                item.items.forEach((groupItem) => {
+                    assignIndex(groupItem, index++);
+                    result.push(groupItem);
+                });
+                return;
+            }
+            assignIndex(item, index++);
+            return result.push(item);
+        }, []);
+        return result;
+    }, [processedItems]);
+    // parse un-parsed filter values
+    // filters can be left un-parsed if a column was not defined when the URL is read
+    useEffect(() => {
+        setFilters((filters) => {
+            const hasUnparsedFilters = Object.values(filters).some((value) => value[unparsed] != null);
+            if (!hasUnparsedFilters) {
+                return filters;
+            }
+            return Object.fromEntries(Object.entries(filters).map(([name, value]) => {
+                if (value[unparsed] == null) {
+                    return [name, value];
+                }
+                return read([name, value[unparsed]]);
+            }));
+        });
+    }, [read]);
+    return {
+        processedItems,
+        visibleData,
+        filters,
+        filterFunctions,
+        setFilterState,
+    };
+};
+//# sourceMappingURL=use-processed-items.js.map

package/dist/lib/use-public-interface.d.ts

@@ -0,0 +1,7 @@
+export function usePublicInterface({ host, visibleData, filters, ...api }: {
+    [x: string]: any;
+    host: any;
+    visibleData: any;
+    filters: any;
+}): void;
+//# sourceMappingURL=use-public-interface.d.ts.map

package/dist/lib/use-public-interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-public-interface.d.ts","sourceRoot":"","sources":["../../src/lib/use-public-interface.js"],"names":[],"mappings":"AAoEO;;;;;SAsCN"}

package/dist/lib/use-public-interface.js

@@ -0,0 +1,82 @@
+import { useImperativeApi } from '@neovici/cosmoz-utils/hooks/use-imperative-api';
+import { useEffect, useMemo } from '@pionjs/pion';
+import { useNotifyProperty } from '@neovici/cosmoz-utils/hooks/use-notify-property';
+const mkNapi = (host) => {
+    const /**
+         * Helper method to remove an item from `data`.
+         * @param	 {Object} item Item to remove
+         * @return {Object} item removed
+         */ removeItem = (item) => {
+        const index = host.data.indexOf(item);
+        if (index < 0) {
+            return null;
+        }
+        const removed = host.data.splice(index, 1);
+        host.data = host.data.slice();
+        if (Array.isArray(removed) && removed.length > 0) {
+            return removed[0];
+        }
+    }, replaceItemAtIndex = (index, newItem) => {
+        host.data.splice(index, 1, newItem);
+        host.data = host.data.slice();
+    };
+    return {
+        removeItem,
+        removeItems(items) {
+            const removedItems = [];
+            for (let i = items.length - 1; i >= 0; i -= 1) {
+                const removed = host.removeItem(items[i]);
+                if (removed != null) {
+                    removedItems.push(removed);
+                }
+            }
+            return removedItems;
+        },
+        replaceItemAtIndex,
+        replaceItem(oldItem, newItem) {
+            const itemIndex = host.data.indexOf(oldItem);
+            if (itemIndex > -1) {
+                return replaceItemAtIndex(itemIndex, newItem);
+            }
+        },
+        selectItem(item) {
+            host.shadowRoot.querySelector('#groupedList').select(item);
+        },
+        selectAll() {
+            host.shadowRoot.querySelector('#groupedList').selectAll();
+        },
+        deselectAll() {
+            host.shadowRoot.querySelector('#groupedList').deselectAll();
+        },
+        deselectItem(item) {
+            host.shadowRoot.querySelector('#groupedList').deselect(item);
+        },
+        isItemSelected(item) {
+            return host.shadowRoot.querySelector('#groupedList').isItemSelected(item);
+        },
+    };
+};
+export const usePublicInterface = ({ host, visibleData, filters, ...api }) => {
+    const { setFilterState } = api, napi = useMemo(() => mkNapi(host), []);
+    useImperativeApi(api, Object.values(api));
+    useImperativeApi(napi, Object.values(napi));
+    useEffect(() => {
+        const handler = (ev) => setFilterState(ev.detail.name, (state) => ({
+            ...state,
+            ...ev.detail.state,
+        }));
+        host.addEventListener('legacy-filter-changed', handler);
+        return () => host.removeEventListener('legacy-filter-changed', handler);
+    }, []);
+    useNotifyProperty('visibleData', visibleData);
+    useNotifyProperty('sortedFilteredGroupedItems', api.sortedFilteredGroupedItems);
+    useNotifyProperty('selectedItems', api.selectedItems);
+    useNotifyProperty('sortOn', api.sortOn);
+    useNotifyProperty('descending', api.descending);
+    useNotifyProperty('isMini', api.isMini);
+    const filterValues = useMemo(() => Object.fromEntries(Object.entries(filters)
+        .filter(([, { filter }]) => filter !== undefined)
+        .map(([key, { filter }]) => [key, filter])), [filters]);
+    useNotifyProperty('filters', filterValues, Object.values(filterValues));
+};
+//# sourceMappingURL=use-public-interface.js.map

package/dist/lib/use-resizable-columns.d.ts

@@ -0,0 +1,7 @@
+export function useResizableColumns({ host, canvasWidth, layout, setSettings, }: {
+    host: any;
+    canvasWidth: any;
+    layout: any;
+    setSettings: any;
+}): void;
+//# sourceMappingURL=use-resizable-columns.d.ts.map

package/dist/lib/use-resizable-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-resizable-columns.d.ts","sourceRoot":"","sources":["../../src/lib/use-resizable-columns.js"],"names":[],"mappings":"AAEO;;;;;SA4DN"}

package/dist/lib/use-resizable-columns.js

@@ -0,0 +1,38 @@
+import { useEffect, useRef } from '@pionjs/pion';
+export const useResizableColumns = ({ host, canvasWidth, layout, setSettings, }) => {
+    const onColumnResizeRef = useRef();
+    onColumnResizeRef.current = (ev) => setSettings((settings) => {
+        const config = settings.columns, { detail: { newWidth, column }, } = ev, columnIndex = config.findIndex((c) => c.name === column.name), newConfig = [], maxPriority = config.reduce((p, c) => Math.max(p, c.priority), -Infinity);
+        for (let i = 0; i < layout.length; i++) {
+            newConfig[i] = { ...config[i] };
+            // for visible columns to the left of the resized column
+            if (i < columnIndex && layout[i]) {
+                // save the current width
+                newConfig[i].width = layout[i];
+                // make them fixed width
+                newConfig[i].flex = 0;
+                // keep them visible
+                newConfig[i].priority = maxPriority;
+            }
+            // update the width of the resized column
+            if (i === columnIndex) {
+                const maxNewSize = layout.reduce((acc, cur, i) => {
+                    if (i < columnIndex) {
+                        return cur ? acc - cur : acc;
+                    }
+                    return acc;
+                }, canvasWidth);
+                newConfig[i].width = Math.min(maxNewSize, Math.max(newWidth, config[i].minWidth));
+                newConfig[i].flex = 0;
+                newConfig[i].priority = maxPriority;
+            }
+        }
+        return { ...settings, columns: newConfig };
+    });
+    useEffect(() => {
+        const handler = (ev) => onColumnResizeRef.current(ev);
+        host.addEventListener('column-resize', handler);
+        return () => host.removeEventListener('column-resize', handler);
+    }, []);
+};
+//# sourceMappingURL=use-resizable-columns.js.map

package/dist/lib/use-sort-and-group-options.d.ts

@@ -0,0 +1,26 @@
+export function useSortAndGroupOptions(columns: any, hashParam: any, settings: any, setSettings: any, resetRef: any): {
+    sortAndGroup: {
+        groupOn: any;
+        setGroupOn: (value: any) => void;
+        groupOnDescending: any;
+        setGroupOnDescending: (value: any) => void;
+        sortOn: any;
+        setSortOn: (value: any) => void;
+        descending: any;
+        setDescending: (value: any) => void;
+        columns: any;
+    };
+    groupOnColumn: any;
+    sortOnColumn: any;
+    groupOn: any;
+    setGroupOn: (value: any) => void;
+    groupOnDescending: any;
+    setGroupOnDescending: (value: any) => void;
+    sortOn: any;
+    setSortOn: (value: any) => void;
+    descending: any;
+    setDescending: (value: any) => void;
+    columns: any;
+};
+export const SortAndGroupContext: import("@pionjs/pion/lib/create-context").Context<any>;
+//# sourceMappingURL=use-sort-and-group-options.d.ts.map

package/dist/lib/use-sort-and-group-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sort-and-group-options.d.ts","sourceRoot":"","sources":["../../src/lib/use-sort-and-group-options.js"],"names":[],"mappings":"AAqBO;;;;;;;;;;;;;;;;;;;;;;;EAiE+B;AAArC,yFAAqC"}

package/dist/lib/use-sort-and-group-options.js

@@ -0,0 +1,36 @@
+import { useMemo, createContext, component, useContext, useCallback, useEffect, } from '@pionjs/pion';
+import { useHashState } from './use-hash-state';
+const parseBool = (bool) => [true, 'true', 1, 'yes', 'on'].includes(bool), boolParam = (p) => p === '' || (p == null ? undefined : parseBool(p)), useSettingsState = (setter, name, setSettings) => useCallback((value) => {
+    setter(value);
+    setSettings((s) => ({ ...s, [name]: value }));
+}, [setter, name, setSettings]);
+export const useSortAndGroupOptions = (columns, hashParam, settings, setSettings, resetRef) => {
+    const [sortOn, setSortOn] = useHashState(settings.sortOn, hashParam, {
+        suffix: '-sortOn',
+    }), [descending, setDescending] = useHashState(boolParam(settings.descending), hashParam, { suffix: '-descending', read: boolParam }), [groupOn, setGroupOn] = useHashState(settings.groupOn, hashParam, {
+        suffix: '-groupOn',
+    }), [groupOnDescending, setGroupOnDescending] = useHashState(boolParam(settings.groupOnDescending), hashParam, { suffix: '-groupOnDescending', read: boolParam }), sortOnColumn = useMemo(() => columns.find((column) => column.name === sortOn), [columns, sortOn]), groupOnColumn = useMemo(() => columns.find((column) => column.name === groupOn), [columns, groupOn]), sortAndGroup_ = {
+        groupOn,
+        setGroupOn: useSettingsState(setGroupOn, 'groupOn', setSettings),
+        groupOnDescending,
+        setGroupOnDescending: useSettingsState(setGroupOnDescending, 'groupOnDescending', setSettings),
+        sortOn,
+        setSortOn: useSettingsState(setSortOn, 'sortOn', setSettings),
+        descending,
+        setDescending: useSettingsState(setDescending, 'descending', setSettings),
+        columns,
+    }, sortAndGroup = useMemo(() => sortAndGroup_, Object.values(sortAndGroup_)), setSG = useCallback((c) => {
+        setSortOn(c.sortOn);
+        setGroupOn(c.groupOn);
+        setDescending(c.descending);
+        setGroupOnDescending(c.groupOnDescending);
+    }, []);
+    // eslint-disable-next-line no-void
+    useEffect(() => void (resetRef.current = setSG), []);
+    return { ...sortAndGroup, sortAndGroup, groupOnColumn, sortOnColumn };
+}, SortAndGroupContext = createContext();
+customElements.define('sort-and-group-provider', SortAndGroupContext.Provider);
+customElements.define('sort-and-group-consumer', component(({ render }) => render(useContext(SortAndGroupContext)), {
+    useShadowDOM: false,
+}));
+//# sourceMappingURL=use-sort-and-group-options.js.map

package/dist/lib/use-track-size.d.ts

@@ -0,0 +1,2 @@
+export function useTrackSize(host: any, setCanvasWidth: any): void;
+//# sourceMappingURL=use-track-size.d.ts.map

package/dist/lib/use-track-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-track-size.d.ts","sourceRoot":"","sources":["../../src/lib/use-track-size.js"],"names":[],"mappings":"AAEO,mEAoBA"}

package/dist/lib/use-track-size.js

@@ -0,0 +1,15 @@
+import { useEffect } from '@pionjs/pion';
+export const useTrackSize = (host, setCanvasWidth) => useEffect(() => {
+    const onResize = ([entry]) => {
+        if (entry.contentRect?.width === 0) {
+            return;
+        }
+        requestAnimationFrame(() => setCanvasWidth(entry.contentRect?.width -
+            20 /* scrollbar width */ -
+            44 /* checkbox width */ -
+            24 /* expand button width */));
+    }, observer = new ResizeObserver(onResize);
+    observer.observe(host);
+    return () => observer.unobserve(host);
+}, []);
+//# sourceMappingURL=use-track-size.js.map

package/dist/lib/use-tween-array.d.ts

@@ -0,0 +1,3 @@
+export function isCloseEnough(a?: number, b?: number): boolean;
+export function useTweenArray(target: any, speedFactor?: number, callback?: any): void;
+//# sourceMappingURL=use-tween-array.d.ts.map

package/dist/lib/use-tween-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-tween-array.d.ts","sourceRoot":"","sources":["../../src/lib/use-tween-array.js"],"names":[],"mappings":"AAoCO,+DAuBL;AAvBK,uFAuBL"}

package/dist/lib/use-tween-array.js

@@ -0,0 +1,50 @@
+import { useCallback, useEffect, useMemo } from '@pionjs/pion';
+import { useMeta } from '@neovici/cosmoz-utils/hooks/use-meta';
+import { noop } from '@neovici/cosmoz-utils/function';
+const useAnimationLoop = (animate, trigger) => {
+    const animationLoop = useMemo(() => {
+        let running = false, af;
+        const animationLoop = () => {
+            if (!running)
+                return;
+            af = requestAnimationFrame(animationLoop);
+            const stop = animate();
+            if (stop)
+                running = false;
+        };
+        return {
+            start: () => {
+                running = true;
+                cancelAnimationFrame(af);
+                af = requestAnimationFrame(animationLoop);
+            },
+            stop: () => {
+                running = false;
+                cancelAnimationFrame(af);
+            },
+        };
+    }, []);
+    useEffect(() => {
+        animationLoop.start();
+    }, trigger);
+    useEffect(() => () => animationLoop.stop(), []);
+};
+export const isCloseEnough = (a = 0, b = 0) => Math.abs(a - b) < 0.1, useTweenArray = (target, speedFactor = 1.9, callback = noop) => {
+    const state = useMeta({ target }), 
+    // [tween, setTween] = useState(target),
+    animate = useCallback(() => {
+        if (!state.tween)
+            state.tween = state.target;
+        if (state.target.every((t, idx) => state.tween[idx] === t)) {
+            callback(state.tween);
+            return true;
+        }
+        state.tween = state.target.map((t, idx) => isCloseEnough(state.tween[idx], t)
+            ? t
+            : (state.tween[idx] ?? 0) +
+                ((t ?? 0) - (state.tween[idx] ?? 0)) / speedFactor || 0);
+        callback(state.tween);
+    }, []);
+    useAnimationLoop(animate, [target]);
+};
+//# sourceMappingURL=use-tween-array.js.map

package/dist/lib/utils-amount.d.ts

@@ -0,0 +1,26 @@
+export function toAmount(rates: {} | undefined, value: any, limit: any, limitFunc: any): any;
+export function getComparableValue({ valuePath, rates }: {
+    valuePath: any;
+    rates: any;
+}, item: any): any;
+export function applySingleFilter(column: any, filter: any): (item: any) => boolean;
+export const formatters: {};
+export function getFormatter(currency: any, locale: any): any;
+export function renderValue(rates: any, value: any, locale: any): any;
+export function getString({ valuePath, rates, locale }: {
+    valuePath: any;
+    rates: any;
+    locale: any;
+}, item: any): any;
+export function toHashString(value: any): any;
+export function fromHashString(value: any): {
+    amount: any;
+    currency: any;
+} | null | undefined;
+export function getCurrency({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+export function getInputString({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+//# sourceMappingURL=utils-amount.d.ts.map

package/dist/lib/utils-amount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-amount.d.ts","sourceRoot":"","sources":["../../src/lib/utils-amount.js"],"names":[],"mappings":"AAGO,6FA+HgE;AA/HhE;;;mBA+HgE;AA/HhE,8DAiEmC,SAAI,aA8DyB;AAlDtE,4BAAe;AA7ET,8DA+HgE;AA/HhE,sEA+HgE;AA/HhE;;;;mBA+HgE;AA/HhE,8CA+HgE;AA/HhE;;;qBA+HgE;AA/HhE;;mBA+HgE;AA/HhE;;mBA+HgE"}