@johly/bits-ui 2.18.1

package/dist/bits/dropdown-menu/exports.d.ts

@@ -0,0 +1,21 @@
+export { default as Root } from "../menu/components/menu.svelte";
+export { default as Sub } from "../menu/components/menu-sub.svelte";
+export { default as Item } from "../menu/components/menu-item.svelte";
+export { default as Group } from "../menu/components/menu-group.svelte";
+export { default as GroupHeading } from "../menu/components/menu-group-heading.svelte";
+export { default as Arrow } from "../menu/components/menu-arrow.svelte";
+export { default as Content } from "./components/dropdown-menu-content.svelte";
+export { default as ContentStatic } from "./components/dropdown-menu-content-static.svelte";
+export { default as Trigger } from "../menu/components/menu-trigger.svelte";
+export { default as RadioItem } from "../menu/components/menu-radio-item.svelte";
+export { default as Separator } from "../menu/components/menu-separator.svelte";
+export { default as RadioGroup } from "../menu/components/menu-radio-group.svelte";
+export { default as SubContent } from "../menu/components/menu-sub-content.svelte";
+export { default as SubContentStatic } from "../menu/components/menu-sub-content-static.svelte";
+export { default as SubTrigger } from "../menu/components/menu-sub-trigger.svelte";
+export { default as CheckboxItem } from "../menu/components/menu-checkbox-item.svelte";
+export { default as Portal } from "../utilities/portal/portal.svelte";
+export { default as CheckboxGroup } from "../menu/components/menu-checkbox-group.svelte";
+export { DataEmpty, DataInput, DataList, DataSurface, } from "../menu-data/exports.js";
+export type { DropdownMenuArrowProps as ArrowProps, DropdownMenuCheckboxItemProps as CheckboxItemProps, DropdownMenuContentProps as ContentProps, DropdownMenuContentStaticProps as ContentStaticProps, DropdownMenuGroupProps as GroupProps, DropdownMenuItemProps as ItemProps, DropdownMenuGroupHeadingProps as GroupHeadingProps, DropdownMenuRootProps as RootProps, DropdownMenuRadioGroupProps as RadioGroupProps, DropdownMenuRadioItemProps as RadioItemProps, DropdownMenuSeparatorProps as SeparatorProps, DropdownMenuSubContentProps as SubContentProps, DropdownMenuSubContentStaticProps as SubContentStaticProps, DropdownMenuSubProps as SubProps, DropdownMenuSubTriggerProps as SubTriggerProps, DropdownMenuTriggerProps as TriggerProps, DropdownMenuPortalProps as PortalProps, DropdownMenuCheckboxGroupProps as CheckboxGroupProps, } from "./types.js";
+export type { CheckboxItemDef, DataEmptyProps, DataInputProps, DataListChildrenSnippetProps, DataListProps, DataSurfaceProps, DeepSearchConfig, DeepSearchProp, DisplayGroupNode, DisplayNode, DisplayRadioGroupNode, DisplayRowNode, GroupDef, GroupRenderContext, ItemDef, NodeDef, RadioGroupDef, RowRenderContext, SeparatorDef, SubmenuDef, } from "../menu-data/exports.js";

package/dist/bits/dropdown-menu/exports.js

@@ -0,0 +1,19 @@
+export { default as Root } from "../menu/components/menu.svelte";
+export { default as Sub } from "../menu/components/menu-sub.svelte";
+export { default as Item } from "../menu/components/menu-item.svelte";
+export { default as Group } from "../menu/components/menu-group.svelte";
+export { default as GroupHeading } from "../menu/components/menu-group-heading.svelte";
+export { default as Arrow } from "../menu/components/menu-arrow.svelte";
+export { default as Content } from "./components/dropdown-menu-content.svelte";
+export { default as ContentStatic } from "./components/dropdown-menu-content-static.svelte";
+export { default as Trigger } from "../menu/components/menu-trigger.svelte";
+export { default as RadioItem } from "../menu/components/menu-radio-item.svelte";
+export { default as Separator } from "../menu/components/menu-separator.svelte";
+export { default as RadioGroup } from "../menu/components/menu-radio-group.svelte";
+export { default as SubContent } from "../menu/components/menu-sub-content.svelte";
+export { default as SubContentStatic } from "../menu/components/menu-sub-content-static.svelte";
+export { default as SubTrigger } from "../menu/components/menu-sub-trigger.svelte";
+export { default as CheckboxItem } from "../menu/components/menu-checkbox-item.svelte";
+export { default as Portal } from "../utilities/portal/portal.svelte";
+export { default as CheckboxGroup } from "../menu/components/menu-checkbox-group.svelte";
+export { DataEmpty, DataInput, DataList, DataSurface, } from "../menu-data/exports.js";

package/dist/bits/dropdown-menu/index.d.ts

@@ -0,0 +1 @@
+export * as DropdownMenu from "./exports.js";

package/dist/bits/dropdown-menu/index.js

@@ -0,0 +1 @@
+export * as DropdownMenu from "./exports.js";

package/dist/bits/dropdown-menu/types.d.ts

@@ -0,0 +1,2 @@
+export type { MenuArrowProps as DropdownMenuArrowProps, MenuCheckboxItemProps as DropdownMenuCheckboxItemProps, MenuContentProps as DropdownMenuContentProps, MenuContentStaticProps as DropdownMenuContentStaticProps, MenuGroupProps as DropdownMenuGroupProps, MenuItemProps as DropdownMenuItemProps, MenuGroupHeadingProps as DropdownMenuGroupHeadingProps, MenuRootProps as DropdownMenuRootProps, MenuRadioGroupProps as DropdownMenuRadioGroupProps, MenuRadioItemProps as DropdownMenuRadioItemProps, MenuSeparatorProps as DropdownMenuSeparatorProps, MenuSubContentProps as DropdownMenuSubContentProps, MenuSubContentStaticProps as DropdownMenuSubContentStaticProps, MenuSubProps as DropdownMenuSubProps, MenuSubTriggerProps as DropdownMenuSubTriggerProps, MenuTriggerProps as DropdownMenuTriggerProps, MenuPortalProps as DropdownMenuPortalProps, MenuCheckboxGroupProps as DropdownMenuCheckboxGroupProps, } from "../menu/types.js";
+export type { MenuRootPropsWithoutHTML as DropdownMenuRootPropsWithoutHTML, MenuArrowPropsWithoutHTML as DropdownMenuArrowPropsWithoutHTML, MenuCheckboxItemPropsWithoutHTML as DropdownMenuCheckboxItemPropsWithoutHTML, MenuContentPropsWithoutHTML as DropdownMenuContentPropsWithoutHTML, MenuContentStaticPropsWithoutHTML as DropdownMenuContentStaticPropsWithoutHTML, MenuGroupPropsWithoutHTML as DropdownMenuGroupPropsWithoutHTML, MenuItemPropsWithoutHTML as DropdownMenuItemPropsWithoutHTML, MenuGroupHeadingPropsWithoutHTML as DropdownMenuGroupHeadingPropsWithoutHTML, MenuRadioGroupPropsWithoutHTML as DropdownMenuRadioGroupPropsWithoutHTML, MenuRadioItemPropsWithoutHTML as DropdownMenuRadioItemPropsWithoutHTML, MenuSeparatorPropsWithoutHTML as DropdownMenuSeparatorPropsWithoutHTML, MenuSubPropsWithoutHTML as DropdownMenuSubPropsWithoutHTML, MenuSubTriggerPropsWithoutHTML as DropdownMenuSubTriggerPropsWithoutHTML, MenuSubContentPropsWithoutHTML as DropdownMenuSubContentPropsWithoutHTML, MenuSubContentStaticPropsWithoutHTML as DropdownMenuSubContentStaticPropsWithoutHTML, MenuTriggerPropsWithoutHTML as DropdownMenuTriggerPropsWithoutHTML, MenuPortalPropsWithoutHTML as DropdownMenuPortalPropsWithoutHTML, MenuCheckboxGroupPropsWithoutHTML as DropdownMenuCheckboxGroupPropsWithoutHTML, } from "../menu/types.js";

package/dist/bits/dropdown-menu/types.js

@@ -0,0 +1 @@
+export {};

package/dist/bits/filter/array.d.ts

@@ -0,0 +1,13 @@
+export declare function intersection<T>(a: T[], b: T[]): T[];
+export declare function uniq<T>(arr: T[]): T[];
+export declare function take<T>(a: T[], n: number): T[];
+export declare function flatten<T>(a: T[][]): T[];
+export declare function addUniq<T>(arr: T[], values: T[]): T[];
+export declare function removeUniq<T>(arr: T[], values: T[]): T[];
+export declare function isAnyOf<T>(value: T, values: T[]): boolean;
+export declare function max(values: readonly number[]): number;
+export declare function max(values: readonly bigint[]): bigint;
+export declare function min(values: readonly number[]): number;
+export declare function min(values: readonly bigint[]): bigint;
+export declare function minMax(values: readonly number[]): [number, number];
+export declare function minMax(values: readonly bigint[]): [bigint, bigint];

package/dist/bits/filter/array.js

@@ -0,0 +1,233 @@
+import { getValidNumber } from "./helpers.js";
+export function intersection(a, b) {
+    return a.filter((x) => b.includes(x));
+}
+function deepHash(value, cache = new WeakMap()) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    const type = typeof value;
+    if (type === "number" || type === "boolean" || type === "string" || type === "bigint") {
+        return `${type}:${value.toString()}`;
+    }
+    if (type === "function") {
+        return `function:${value.toString()}`;
+    }
+    if (type === "object") {
+        if (cache.has(value))
+            return cache.get(value);
+        let hash;
+        if (Array.isArray(value)) {
+            hash = `array:[${value.map((v) => deepHash(v, cache)).join(",")}]`;
+        }
+        else if (value instanceof Date) {
+            hash = `date:${value.getTime()}`;
+        }
+        else {
+            const keys = Object.keys(value).sort();
+            const props = keys.map((k) => `${k}:${deepHash(value[k], cache)}`).join(",");
+            hash = `object:{${props}}`;
+        }
+        cache.set(value, hash);
+        return hash;
+    }
+    return `${type}:${value.toString()}`;
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+    if (typeof a !== typeof b)
+        return false;
+    if (a === null || b === null || a === undefined || b === undefined)
+        return false;
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((value, index) => deepEqual(value, b[index]));
+    }
+    if (typeof a === "object") {
+        if (typeof b !== "object")
+            return false;
+        const aKeys = Object.keys(a).sort();
+        const bKeys = Object.keys(b).sort();
+        if (aKeys.length !== bKeys.length)
+            return false;
+        for (let i = 0; i < aKeys.length; i++) {
+            const aKey = aKeys[i];
+            const bKey = bKeys[i];
+            if (aKey !== bKey || !deepEqual(a[aKey], b[bKey]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+export function uniq(arr) {
+    const seen = new Map();
+    const result = [];
+    for (const item of arr) {
+        const hash = deepHash(item);
+        const itemsWithHash = seen.get(hash);
+        if (!itemsWithHash) {
+            seen.set(hash, [item]);
+            result.push(item);
+            continue;
+        }
+        if (!itemsWithHash.some((existing) => deepEqual(existing, item))) {
+            itemsWithHash.push(item);
+            result.push(item);
+        }
+    }
+    return result;
+}
+export function take(a, n) {
+    return a.slice(0, n);
+}
+export function flatten(a) {
+    return a.flat();
+}
+export function addUniq(arr, values) {
+    return uniq([...arr, ...values]);
+}
+export function removeUniq(arr, values) {
+    return arr.filter((v) => !values.includes(v));
+}
+export function isAnyOf(value, values) {
+    return values.includes(value);
+}
+function getValidBigInt(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (typeof value !== "bigint")
+        return undefined;
+    return value;
+}
+export function max(values) {
+    let found = false;
+    let isNumberArray = false;
+    for (const value of values) {
+        if (getValidNumber(value) !== undefined) {
+            isNumberArray = true;
+            break;
+        }
+        if (getValidBigInt(value) !== undefined)
+            break;
+    }
+    if (isNumberArray) {
+        let m = Number.NEGATIVE_INFINITY;
+        for (const value of values) {
+            const v = getValidNumber(value);
+            if (v !== undefined) {
+                if (v > m)
+                    m = v;
+                found = true;
+            }
+        }
+        return found ? m : Number.NEGATIVE_INFINITY;
+    }
+    let m = Number.NEGATIVE_INFINITY;
+    for (const value of values) {
+        const v = getValidBigInt(value);
+        if (v !== undefined) {
+            if (!found) {
+                m = v;
+                found = true;
+            }
+            else if (typeof m === "bigint" && v > m) {
+                m = v;
+            }
+        }
+    }
+    return found ? m : Number.NEGATIVE_INFINITY;
+}
+export function min(values) {
+    let found = false;
+    let isNumberArray = false;
+    for (const value of values) {
+        if (getValidNumber(value) !== undefined) {
+            isNumberArray = true;
+            break;
+        }
+        if (getValidBigInt(value) !== undefined)
+            break;
+    }
+    if (isNumberArray) {
+        let m = Number.POSITIVE_INFINITY;
+        for (const value of values) {
+            const v = getValidNumber(value);
+            if (v !== undefined) {
+                if (v < m)
+                    m = v;
+                found = true;
+            }
+        }
+        return found ? m : Number.POSITIVE_INFINITY;
+    }
+    let m = Number.POSITIVE_INFINITY;
+    for (const value of values) {
+        const v = getValidBigInt(value);
+        if (v !== undefined) {
+            if (!found) {
+                m = v;
+                found = true;
+            }
+            else if (typeof m === "bigint" && v < m) {
+                m = v;
+            }
+        }
+    }
+    return found ? m : Number.POSITIVE_INFINITY;
+}
+export function minMax(values) {
+    let found = false;
+    let isNumberArray = false;
+    for (const value of values) {
+        if (getValidNumber(value) !== undefined) {
+            isNumberArray = true;
+            break;
+        }
+        if (getValidBigInt(value) !== undefined)
+            break;
+    }
+    if (isNumberArray) {
+        let minVal = Number.POSITIVE_INFINITY;
+        let maxVal = Number.NEGATIVE_INFINITY;
+        for (const value of values) {
+            const v = getValidNumber(value);
+            if (v !== undefined) {
+                if (v < minVal)
+                    minVal = v;
+                if (v > maxVal)
+                    maxVal = v;
+                found = true;
+            }
+        }
+        return found
+            ? [minVal, maxVal]
+            : [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];
+    }
+    let minVal = Number.POSITIVE_INFINITY;
+    let maxVal = Number.NEGATIVE_INFINITY;
+    for (const value of values) {
+        const v = getValidBigInt(value);
+        if (v !== undefined) {
+            if (!found) {
+                minVal = v;
+                maxVal = v;
+                found = true;
+            }
+            else {
+                if (typeof minVal === "bigint" && v < minVal)
+                    minVal = v;
+                if (typeof maxVal === "bigint" && v > maxVal)
+                    maxVal = v;
+            }
+        }
+    }
+    return found
+        ? [minVal, maxVal]
+        : [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];
+}

package/dist/bits/filter/columns.d.ts

@@ -0,0 +1,37 @@
+import type { Column, ColumnConfig, ColumnDataType, ColumnMeta, ColumnOption, FilterStrategy, OrderDirection, TAccessorFn, TBuiltInOrderFnName, TCustomOrderFn, TOrderFnArg, TTransformOptionsFn, TTransformValueToOptionFn } from "./types.js";
+export declare class ColumnConfigBuilder<TData, TType extends ColumnDataType = any, TVal = unknown, TId extends string = string> {
+    private config;
+    constructor(type: TType);
+    private clone;
+    id<TNewId extends string>(value: TNewId): ColumnConfigBuilder<TData, TType, TVal, TNewId>;
+    accessor<TNewVal>(accessor: TAccessorFn<TData, TNewVal>): ColumnConfigBuilder<TData, TType, TNewVal, TId>;
+    displayName(value: string): ColumnConfigBuilder<TData, TType, TVal, TId>;
+    icon(value: ColumnOption["icon"]): ColumnConfigBuilder<TData, TType, TVal, TId>;
+    hidden(value: boolean): ColumnConfigBuilder<TData, TType, TVal, TId>;
+    min(value: TType extends "number" ? number : TType extends "bigint" ? bigint : never): this;
+    max(value: TType extends "number" ? number : TType extends "bigint" ? bigint : never): this;
+    options(value: ColumnOption[]): this;
+    transformValueToOptionFn(fn: TTransformValueToOptionFn<TVal>): this;
+    transformOptionsFn(fn: TTransformOptionsFn): this;
+    orderFn(name: TBuiltInOrderFnName, direction: OrderDirection): this;
+    orderFn(customFn: TCustomOrderFn): this;
+    orderFn(...args: TOrderFnArg[]): this;
+    toggledStateName(value: string): ColumnConfigBuilder<TData, TType extends "boolean" ? TType : never, TVal, TId>;
+    meta(value: ColumnMeta): ColumnConfigBuilder<TData, TType, TVal, TId>;
+    private validateType;
+    build(): ColumnConfig<TData, TType, TVal, TId>;
+    private validateRequiredFields;
+}
+interface FluentColumnConfigHelper<TData> {
+    text: () => ColumnConfigBuilder<TData, "text", string>;
+    number: () => ColumnConfigBuilder<TData, "number", number>;
+    bigint: () => ColumnConfigBuilder<TData, "bigint", bigint>;
+    date: () => ColumnConfigBuilder<TData, "date", Date>;
+    boolean: () => ColumnConfigBuilder<TData, "boolean", boolean>;
+    option: () => ColumnConfigBuilder<TData, "option", string>;
+    multiOption: () => ColumnConfigBuilder<TData, "multiOption", string[]>;
+}
+export declare function createColumnConfigHelper<TData>(): FluentColumnConfigHelper<TData>;
+export declare function createColumns<TData>(data: TData[], columnConfigs: ReadonlyArray<ColumnConfig<TData, any, any, any>>, strategy: FilterStrategy): Column<TData>[];
+export declare function createColumn<TData>(columnConfig: ColumnConfig<TData, any, any, any>, data: TData[], strategy: FilterStrategy): Column<TData>;
+export {};

package/dist/bits/filter/columns.js

@@ -0,0 +1,329 @@
+import { isAnyOf, minMax, uniq } from "./array.js";
+import { isColumnOptionArray } from "./helpers.js";
+import { memo } from "./memo.js";
+import { applyOrderFns, isBuiltInOrderFnName, isBuiltInOrderFnTuple, isCustomOrderFn, isOrderDirection, orderFns, } from "./order-fns.js";
+export class ColumnConfigBuilder {
+    config;
+    constructor(type) {
+        this.config = { type };
+    }
+    clone() {
+        const newInstance = new ColumnConfigBuilder(this.config.type);
+        newInstance.config = { ...this.config };
+        return newInstance;
+    }
+    id(value) {
+        const newInstance = this.clone();
+        newInstance.config.id = value;
+        return newInstance;
+    }
+    accessor(accessor) {
+        const newInstance = this.clone();
+        newInstance.config.accessor = accessor;
+        return newInstance;
+    }
+    displayName(value) {
+        const newInstance = this.clone();
+        newInstance.config.displayName = value;
+        return newInstance;
+    }
+    icon(value) {
+        const newInstance = this.clone();
+        newInstance.config.icon = value;
+        return newInstance;
+    }
+    hidden(value) {
+        const newInstance = this.clone();
+        newInstance.config.hidden = value;
+        return newInstance;
+    }
+    min(value) {
+        this.validateType(["number", "bigint"], "min()");
+        this.config.min = value;
+        return this;
+    }
+    max(value) {
+        this.validateType(["number", "bigint"], "max()");
+        this.config.max = value;
+        return this;
+    }
+    options(value) {
+        this.validateType(["option", "multiOption"], "options()");
+        this.config.options = value;
+        return this;
+    }
+    transformValueToOptionFn(fn) {
+        this.validateType(["option", "multiOption"], "transformValueToOptionFn()");
+        this.config.transformValueToOptionFn = fn;
+        return this;
+    }
+    transformOptionsFn(fn) {
+        this.validateType(["option", "multiOption"], "transformOptionsFn()");
+        this.config.transformOptionsFn = fn;
+        return this;
+    }
+    orderFn(...args) {
+        this.validateType(["option", "multiOption"], "orderFn()");
+        const orderFnsToApply = [];
+        if (args.length === 2 && isBuiltInOrderFnName(args[0]) && isOrderDirection(args[1])) {
+            const [name, direction] = args;
+            orderFnsToApply.push((a, b) => orderFns[name](a, b, direction));
+        }
+        else if (args.length === 1 && isCustomOrderFn(args[0])) {
+            orderFnsToApply.push(args[0]);
+        }
+        else {
+            for (const arg of args) {
+                if (isBuiltInOrderFnTuple(arg)) {
+                    const [name, direction] = arg;
+                    orderFnsToApply.push((a, b) => orderFns[name](a, b, direction));
+                }
+                else if (isCustomOrderFn(arg)) {
+                    orderFnsToApply.push(arg);
+                }
+                else {
+                    throw new Error(`Invalid argument: ${JSON.stringify(arg)}. Expected built-in function tuple or custom function.`);
+                }
+            }
+        }
+        this.config.orderFn = orderFnsToApply;
+        return this;
+    }
+    toggledStateName(value) {
+        if (this.config.type !== "boolean") {
+            throw new Error("toggledStateName() is only applicable to boolean columns");
+        }
+        const newInstance = this.clone();
+        newInstance.config.toggledStateName = value;
+        return newInstance;
+    }
+    meta(value) {
+        const newInstance = this.clone();
+        newInstance.config.meta = value;
+        return newInstance;
+    }
+    validateType(expectedTypes, methodName) {
+        const types = Array.isArray(expectedTypes) ? expectedTypes : [expectedTypes];
+        if (!isAnyOf(this.config.type, types)) {
+            throw new Error(`[Column config builder] ${methodName} is only applicable to ${types.join(" or ")} columns`);
+        }
+    }
+    build() {
+        this.validateRequiredFields();
+        return this.config;
+    }
+    validateRequiredFields() {
+        if (!this.config.id)
+            throw new Error("id is required");
+        if (!this.config.accessor)
+            throw new Error("accessor is required");
+        if (!this.config.displayName)
+            throw new Error("displayName is required");
+    }
+}
+export function createColumnConfigHelper() {
+    return {
+        text: () => new ColumnConfigBuilder("text"),
+        number: () => new ColumnConfigBuilder("number"),
+        bigint: () => new ColumnConfigBuilder("bigint"),
+        date: () => new ColumnConfigBuilder("date"),
+        boolean: () => new ColumnConfigBuilder("boolean"),
+        option: () => new ColumnConfigBuilder("option"),
+        multiOption: () => new ColumnConfigBuilder("multiOption"),
+    };
+}
+class ColumnDataService {
+    data;
+    strategy;
+    constructor(data, strategy) {
+        this.data = data;
+        this.strategy = strategy;
+    }
+    computeBaseOptions(column) {
+        if (!isAnyOf(column.type, ["option", "multiOption"]))
+            return [];
+        if (this.strategy === "server" && !column.options) {
+            throw new Error("column options are required for server-side filtering");
+        }
+        if (column.options)
+            return column.options;
+        const filtered = this.data
+            .flatMap(column.accessor)
+            .filter((v) => v !== undefined && v !== null);
+        const uniqueValues = uniq(filtered);
+        const columnOptions = column.transformValueToOptionFn
+            ? uniqueValues.map((m) => column.transformValueToOptionFn(m))
+            : [];
+        if (isColumnOptionArray(columnOptions))
+            return columnOptions;
+        throw new Error(`[filter] [${column.id}] Either provide static options, a transformValueToOptionFn, or ensure the column data conforms to ColumnOption type`);
+    }
+    computeOrderedOptions(column) {
+        const baseOptions = this.computeBaseOptions(column);
+        const values = this.getValues(column);
+        const facetedData = this.computeFacetedUniqueValues(column, values);
+        const optionsWithCounts = baseOptions.map((option) => ({
+            ...option,
+            count: facetedData?.get(option.value) || 0,
+        }));
+        if (column.orderFn)
+            return applyOrderFns(column.orderFn, optionsWithCounts);
+        return optionsWithCounts;
+    }
+    computeTransformedOptions(column) {
+        const orderedOptions = this.computeOrderedOptions(column);
+        if (!column.transformOptionsFn)
+            return orderedOptions;
+        return column.transformOptionsFn(orderedOptions);
+    }
+    getValues(column) {
+        const memoizedAccessor = memo(() => [this.data], (deps) => (deps[0] ?? [])
+            .flatMap(column.accessor)
+            .filter((v) => v !== undefined && v !== null), { key: `accessor-${column.id}` });
+        const raw = memoizedAccessor();
+        if (!isAnyOf(column.type, ["option", "multiOption"]))
+            return raw;
+        if (column.options) {
+            return raw
+                .flatMap((v) => (Array.isArray(v) ? v : [v]))
+                .map((v) => column.options?.find((o) => o.value === v)?.value)
+                .filter((v) => v !== undefined && v !== null);
+        }
+        if (column.transformValueToOptionFn) {
+            return raw
+                .flatMap((v) => (Array.isArray(v) ? v : [v]))
+                .map((v) => column.transformValueToOptionFn(v).value)
+                .filter((v) => v !== undefined && v !== null);
+        }
+        if (isColumnOptionArray(raw))
+            return raw;
+        throw new Error(`[filter] [${column.id}] Either provide static options, a transformValueToOptionFn, or ensure the column data conforms to ColumnOption type`);
+    }
+    computeFacetedUniqueValues(column, values) {
+        if (!isAnyOf(column.type, ["option", "multiOption"]))
+            return new Map();
+        if (this.strategy === "server")
+            return column.facetedOptions;
+        const acc = new Map();
+        if (isColumnOptionArray(values)) {
+            for (const option of values) {
+                acc.set(option.value, (acc.get(option.value) ?? 0) + 1);
+            }
+        }
+        else {
+            for (const option of values) {
+                acc.set(option, (acc.get(option) ?? 0) + 1);
+            }
+        }
+        return acc;
+    }
+    computeFacetedMinMaxValues(column) {
+        if (!isAnyOf(column.type, ["number", "bigint"]))
+            return undefined;
+        if (column.min !== undefined && column.max !== undefined) {
+            return [column.min, column.max];
+        }
+        if (this.strategy === "server")
+            return undefined;
+        const rawValues = this.data
+            .flatMap((row) => column.accessor(row))
+            .filter((v) => (typeof v === "number" && !Number.isNaN(v)) || typeof v === "bigint");
+        if (rawValues.length === 0) {
+            return (column.type === "bigint" ? [0n, 0n] : [0, 0]);
+        }
+        if (column.type === "number") {
+            const numberValues = rawValues.filter((v) => typeof v === "number");
+            return minMax(numberValues);
+        }
+        const bigintValues = rawValues.filter((v) => typeof v === "bigint");
+        return minMax(bigintValues);
+    }
+}
+export function createColumns(data, columnConfigs, strategy) {
+    return columnConfigs.map((columnConfig) => createColumn(columnConfig, data, strategy));
+}
+export function createColumn(columnConfig, data, strategy) {
+    const dataService = new ColumnDataService(data, strategy);
+    const getValues = createMemoizedValues(columnConfig, dataService);
+    const getUniqueValues = createMemoizedUniqueValues(columnConfig, dataService, getValues);
+    const getMinMaxValues = createMemoizedMinMaxValues(columnConfig, dataService);
+    const getOptions = createMemoizedOptions(columnConfig, dataService, getValues);
+    const column = {
+        ...columnConfig,
+        getOptions,
+        getValues,
+        getFacetedUniqueValues: getUniqueValues,
+        getFacetedMinMaxValues: getMinMaxValues,
+        prefetchOptions: async () => { },
+        prefetchValues: async () => { },
+        prefetchFacetedUniqueValues: async () => { },
+        prefetchFacetedMinMaxValues: async () => { },
+        _prefetchedOptionsCache: null,
+        _prefetchedValuesCache: null,
+        _prefetchedFacetedUniqueValuesCache: null,
+        _prefetchedFacetedMinMaxValuesCache: null,
+    };
+    if (strategy === "client") {
+        setupPrefetchMethods(column, {
+            getOptions,
+            getValues,
+            getUniqueValues,
+            getMinMaxValues,
+        });
+    }
+    return column;
+}
+function createMemoizedOptions(columnConfig, dataService, getValues) {
+    return memo(() => [
+        dataService,
+        columnConfig.options,
+        columnConfig.transformValueToOptionFn,
+        columnConfig.transformOptionsFn,
+        columnConfig.orderFn,
+        getValues(),
+    ], () => dataService.computeTransformedOptions(columnConfig), { key: `final-options-${columnConfig.id}` });
+}
+function createMemoizedValues(columnConfig, dataService) {
+    return memo(() => [dataService], ([service]) => service.getValues(columnConfig), { key: `values-${columnConfig.id}` });
+}
+function createMemoizedUniqueValues(columnConfig, dataService, getValues) {
+    return memo(() => [getValues(), dataService], ([values, service]) => service.computeFacetedUniqueValues(columnConfig, values), { key: `faceted-${columnConfig.id}` });
+}
+function createMemoizedMinMaxValues(columnConfig, dataService) {
+    return memo(() => [dataService], ([service]) => service.computeFacetedMinMaxValues(columnConfig), { key: `minmax-${columnConfig.id}` });
+}
+function setupPrefetchMethods(column, methods) {
+    const { getOptions, getValues, getUniqueValues, getMinMaxValues } = methods;
+    column.prefetchOptions = async () => {
+        if (column._prefetchedOptionsCache)
+            return;
+        await new Promise((resolve) => setTimeout(() => {
+            column._prefetchedOptionsCache = getOptions();
+            resolve(undefined);
+        }, 0));
+    };
+    column.prefetchValues = async () => {
+        if (column._prefetchedValuesCache)
+            return;
+        await new Promise((resolve) => setTimeout(() => {
+            column._prefetchedValuesCache = getValues();
+            resolve(undefined);
+        }, 0));
+    };
+    column.prefetchFacetedUniqueValues = async () => {
+        if (column._prefetchedFacetedUniqueValuesCache)
+            return;
+        await new Promise((resolve) => setTimeout(() => {
+            column._prefetchedFacetedUniqueValuesCache = getUniqueValues() ?? null;
+            resolve(undefined);
+        }, 0));
+    };
+    column.prefetchFacetedMinMaxValues = async () => {
+        if (column._prefetchedFacetedMinMaxValuesCache)
+            return;
+        await new Promise((resolve) => setTimeout(() => {
+            column._prefetchedFacetedMinMaxValuesCache = getMinMaxValues() ?? null;
+            resolve(undefined);
+        }, 0));
+    };
+}