@tulip-systems/core 0.8.2 → 0.9.0

package/dist/src/modules/data-tables/components/toolbar.d.mts

@@ -0,0 +1,22 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { HTMLAttributes } from "react";
+
+//#region src/modules/data-tables/components/toolbar.d.ts
+type TableToolbarProps = HTMLAttributes<HTMLDivElement> & {
+  children: React.ReactNode;
+};
+declare function TableToolbar({
+  children,
+  className,
+  ...props
+}: TableToolbarProps): react_jsx_runtime0.JSX.Element;
+type TableToolbarListProps = HTMLAttributes<HTMLDivElement> & {
+  children: React.ReactNode;
+};
+declare function TableToolbarList({
+  children,
+  className,
+  ...props
+}: TableToolbarListProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { TableToolbar, TableToolbarList };

package/dist/src/modules/data-tables/components/toolbar.mjs

@@ -0,0 +1,21 @@
+import { cn } from "../../../lib/utils/cn.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/modules/data-tables/components/toolbar.tsx
+function TableToolbar({ children, className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		...props,
+		className: cn("flex max-w-full justify-between gap-5 overflow-x-auto py-1", className),
+		children
+	});
+}
+function TableToolbarList({ children, className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		...props,
+		className: cn("flex flex-row gap-5", className),
+		children
+	});
+}
+
+//#endregion
+export { TableToolbar, TableToolbarList };

package/dist/src/modules/data-tables/hooks/use-context.client.d.mts

@@ -0,0 +1,47 @@
+import { CommandDef } from "../../commands/lib/builder.mjs";
+import { TableFiltersResult } from "../lib/filters/config.mjs";
+import { Selection, TableColumnDef, TableMetaInput, TableStrategy } from "../lib/types.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { Dispatch, PropsWithChildren, SetStateAction } from "react";
+import { TableOptions, VisibilityState } from "@tanstack/react-table";
+
+//#region src/modules/data-tables/hooks/use-context.client.d.ts
+type useReactTableProps<TData> = Omit<TableOptions<TData>, "getCoreRowModel"> & {
+  getCoreRowModel?: TableOptions<TData>["getCoreRowModel"];
+};
+/**
+ * Use table config
+ */
+type TableConfigContextValue<TData, TFilters extends TableFiltersResult = TableFiltersResult, TMeta extends TableMetaInput<TData> = TableMetaInput<TData>> = useReactTableProps<TData> & {
+  queryData: TData[];
+  data: TData[];
+  setData: Dispatch<SetStateAction<TData[]>>;
+  getRowId: (row: TData) => string;
+  columns: TableColumnDef<TData>[];
+  strategy: TableStrategy;
+  selection?: Selection;
+  columnVisibility?: VisibilityState;
+  commands?: CommandDef[];
+  meta?: TMeta;
+  where?: TFilters;
+};
+/**
+ * Table context hook
+ */
+declare function useTableConfigContext<TData, TFilters extends TableFiltersResult = TableFiltersResult, TMeta extends TableMetaInput<TData> = TableMetaInput<TData>>(): TableConfigContextValue<TData, TFilters, TMeta>;
+/**
+ * Table context provider
+ */
+declare function TableConfigProvider<TData, TFilters extends TableFiltersResult = TableFiltersResult, TMeta extends TableMetaInput<TData> = TableMetaInput<TData>>({
+  children,
+  config
+}: PropsWithChildren<{
+  config: CreateTableConfigInput<TData, TFilters, TMeta>;
+}>): react_jsx_runtime0.JSX.Element;
+/**
+ * Create use table config hook
+ */
+type CreateTableConfigInput<TData, TFilters extends TableFiltersResult = TableFiltersResult, TMeta extends TableMetaInput<TData> = TableMetaInput<TData>> = Omit<TableConfigContextValue<TData, TFilters, TMeta>, "data" | "setData">;
+declare const createTableConfig: <TData, TFilters extends TableFiltersResult = TableFiltersResult, TMeta extends TableMetaInput<TData> = TableMetaInput<TData>>(config: CreateTableConfigInput<TData, TFilters, TMeta>) => CreateTableConfigInput<TData, TFilters, TMeta>;
+//#endregion
+export { TableConfigContextValue, TableConfigProvider, createTableConfig, useTableConfigContext };

package/dist/src/modules/data-tables/hooks/use-context.client.mjs

@@ -0,0 +1,34 @@
+"use client";
+
+import { jsx } from "react/jsx-runtime";
+import { createContext, use, useEffect, useState } from "react";
+
+//#region src/modules/data-tables/hooks/use-context.client.tsx
+const TableConfigContext = createContext({});
+/**
+* Table context hook
+*/
+function useTableConfigContext() {
+	const context = use(TableConfigContext);
+	if (!context) throw new Error("TableConfigContext not found!");
+	return context;
+}
+/**
+* Table context provider
+*/
+function TableConfigProvider({ children, config }) {
+	const [data, setData] = useState(config.queryData);
+	useEffect(() => setData(config.queryData), [config.queryData]);
+	return /* @__PURE__ */ jsx(TableConfigContext, {
+		value: {
+			...config,
+			data,
+			setData
+		},
+		children
+	});
+}
+const createTableConfig = (config) => config;
+
+//#endregion
+export { TableConfigProvider, createTableConfig, useTableConfigContext };

package/dist/src/modules/data-tables/hooks/use-search.client.mjs

@@ -0,0 +1,39 @@
+"use client";
+
+import { tableSearchParams } from "../lib/search-params.mjs";
+import { useTableConfigContext } from "./use-context.client.mjs";
+import { startTransition } from "react";
+import { useQueryStates } from "nuqs";
+import { useDebouncedCallback } from "use-debounce";
+
+//#region src/modules/data-tables/hooks/use-search.client.ts
+/**
+* Search hook for data table search
+*/
+function useSearch() {
+	const context = useTableConfigContext();
+	const [query, setQuery] = useQueryStates(tableSearchParams, {
+		shallow: false,
+		startTransition
+	});
+	return {
+		defaultValue: query.search ?? "",
+		handleSearch: useDebouncedCallback((search) => {
+			const cursor = context.strategy.resetCursor();
+			if (!search) {
+				setQuery({
+					search: null,
+					cursor
+				});
+				return;
+			}
+			setQuery({
+				search,
+				cursor
+			});
+		}, 300)
+	};
+}
+
+//#endregion
+export { useSearch };

package/dist/src/modules/data-tables/hooks/use-selection.client.mjs

@@ -0,0 +1,44 @@
+"use client";
+
+import React from "react";
+
+//#region src/modules/data-tables/hooks/use-selection.client.ts
+/**
+* Row selection hook for tanstack/react-table
+* @param { UseSelectionProps<TData> } props
+*/
+function useSelection(props) {
+	const [rowSelectionState, setRowSelectionState] = React.useState({});
+	const [selectedData, setSelectedData] = React.useState([]);
+	const rowSelection = props.selection?.rowSelection ?? rowSelectionState;
+	const setRowSelection = props.selection?.setRowSelection ?? setRowSelectionState;
+	/**
+	* Handle row selection change
+	* @param { Updater<RowSelectionState> } updater
+	* @returns { RowSelectionState }
+	*/
+	function onRowSelectionChange(updater) {
+		const newState = typeof updater === "function" ? updater(rowSelection) : updater;
+		setRowSelection(newState);
+		const selectedIds = new Set(Object.keys(newState).filter((id) => newState[id]));
+		setSelectedData((prevData) => {
+			const prevSelectedIds = new Set(prevData.map((item) => props.getRowId(item)));
+			return [...prevData.filter((row) => {
+				const id = props.getRowId(row);
+				return selectedIds.has(id) && prevSelectedIds.has(id);
+			}), ...props.data.filter((row) => {
+				const id = props.getRowId(row);
+				return selectedIds.has(id) && !prevSelectedIds.has(id);
+			})];
+		});
+		return newState;
+	}
+	return {
+		rowSelection,
+		selectedData,
+		onRowSelectionChange
+	};
+}
+
+//#endregion
+export { useSelection };

package/dist/src/modules/data-tables/hooks/use-table.client.d.mts

@@ -0,0 +1,10 @@
+import { TableMeta as TableMeta$1 } from "../lib/types.mjs";
+import * as _tanstack_react_table0 from "@tanstack/react-table";
+
+//#region src/modules/data-tables/hooks/use-table.client.d.ts
+/**
+ * Server data table
+ */
+declare function useTable<TData, TMeta extends TableMeta$1<TData> = TableMeta$1<TData>>(): _tanstack_react_table0.Table<TData>;
+//#endregion
+export { useTable };

package/dist/src/modules/data-tables/hooks/use-table.client.mjs

@@ -0,0 +1,55 @@
+"use client";
+
+import { useTableConfigContext } from "./use-context.client.mjs";
+import { useSelection } from "./use-selection.client.mjs";
+import { useState } from "react";
+import { getCoreRowModel, useReactTable } from "@tanstack/react-table";
+
+//#region src/modules/data-tables/hooks/use-table.client.ts
+/**
+* Server data table
+*/
+function useTable() {
+	const { data, strategy, selection, columnVisibility, commands, getRowId, ...options } = useTableConfigContext();
+	const { rowSelection, selectedData, onRowSelectionChange } = useSelection({
+		data,
+		selection,
+		getRowId
+	});
+	const [columnFilters, setColumnFilters] = useState([]);
+	const [columnVisibilityState, setColumnVisibility] = useState(columnVisibility ?? {});
+	return useReactTable({
+		...options,
+		data,
+		rowCount: strategy.rowCount,
+		state: {
+			...options.state,
+			rowSelection,
+			columnFilters,
+			columnVisibility: columnVisibilityState,
+			sorting: strategy.sortingState,
+			pagination: strategy.paginationState
+		},
+		getCoreRowModel: getCoreRowModel(),
+		getRowId,
+		manualPagination: strategy.manualPagination,
+		onPaginationChange: strategy.onPaginationChange,
+		manualSorting: strategy.manualSorting,
+		onSortingChange: strategy.onSortingChange,
+		enableRowSelection: true,
+		onRowSelectionChange,
+		enableColumnFilters: true,
+		onColumnFiltersChange: setColumnFilters,
+		enableHiding: true,
+		onColumnVisibilityChange: setColumnVisibility,
+		meta: {
+			...options.meta,
+			selectedData,
+			commands,
+			strategy
+		}
+	});
+}
+
+//#endregion
+export { useTable };

package/dist/src/modules/data-tables/lib/converters/dto.d.mts

@@ -0,0 +1,50 @@
+import { TableQuerySchema } from "../validators.mjs";
+
+//#region src/modules/data-tables/lib/converters/dto.d.ts
+/**
+ * Data table query response
+ */
+type TableQueryResponse<TData extends object> = {
+  data: TData[];
+  pagination: TableQueryPaginationResponse;
+};
+type TableQueryPaginationResponse = {
+  total: number;
+  totalPages: number;
+  limit: number;
+  hasNextPage: boolean;
+  hasPreviousPage: boolean;
+  cursor: number;
+  nextCursor: number | null;
+  previousCursor: number | null;
+};
+/**
+ * Table query response input
+ */
+type TableQueryResponseProps<TData extends object> = {
+  data: TData[];
+  input: TableQuerySchema;
+  total: number;
+};
+/**
+ * Convert pagination to DB query
+ */
+declare function createTableQueryResponse<TData extends object>({
+  data,
+  input,
+  total
+}: TableQueryResponseProps<TData>): {
+  data: TData[];
+  pagination: {
+    total: number;
+    totalPages: number;
+    limit: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    cursor: number;
+    nextCursor: number | null;
+    previousCursor: number | null;
+  };
+};
+//#endregion
+export { TableQueryPaginationResponse, TableQueryResponse, createTableQueryResponse };

package/dist/src/modules/data-tables/lib/converters/dto.mjs

@@ -0,0 +1,24 @@
+//#region src/modules/data-tables/lib/converters/dto.ts
+/**
+* Convert pagination to DB query
+*/
+function createTableQueryResponse({ data, input, total }) {
+	const hasNextPage = total > (input.cursor + 1) * input.limit;
+	const hasPreviousPage = input.cursor > 0;
+	return {
+		data,
+		pagination: {
+			total,
+			totalPages: Math.ceil(total / input.limit),
+			limit: input.limit,
+			hasNextPage,
+			hasPreviousPage,
+			cursor: input.cursor,
+			nextCursor: hasNextPage ? input.cursor + 1 : null,
+			previousCursor: hasPreviousPage ? input.cursor - 1 : null
+		}
+	};
+}
+
+//#endregion
+export { createTableQueryResponse };

package/dist/src/modules/data-tables/lib/converters/filters.d.mts

@@ -0,0 +1,41 @@
+import { Database } from "../../../database/lib/service.server.mjs";
+import { TDatabaseSchema } from "../../../../../dist/modules/database/lib/types.mjs";
+import "../../../../../dist/config.mjs";
+import { SQL } from "drizzle-orm";
+
+//#region src/modules/data-tables/lib/converters/filters.d.ts
+/**
+ * Parser function for a single filter key.
+ * Returns a SQL condition or undefined when the filter is not active.
+ */
+type FilterParser<TFilters, TSchema extends TDatabaseSchema = TDatabaseSchema> = (filters: TFilters, context: {
+  db: Database<TSchema>;
+}) => SQL | undefined;
+/**
+ * Map of filter keys to parser functions.
+ * Parsers are optional so routes can define only the keys they need.
+ */
+type FilterParserConfig<TFilters extends Record<string, unknown>, TSchema extends TDatabaseSchema = TDatabaseSchema> = { [K in keyof TFilters]?: FilterParser<TFilters, TSchema> };
+/**
+ * Boolean key selection used by .pick() and .omit().
+ * Example: { search: true, status: true }
+ */
+type KeySelection<K extends PropertyKey> = Partial<Record<K, boolean>>;
+/**
+ * Creates a chainable parser builder for table query filters.
+ *
+ * Usage:
+ * - create parser once from config
+ * - bind context per request
+ * - optionally narrow keys with pick/omit
+ * - parse filters into a single `and(...)` SQL condition
+ */
+declare function createTableQueryFiltersParser<TFilters extends Record<string, unknown>, TSchema extends TDatabaseSchema = TDatabaseSchema>(config: FilterParserConfig<TFilters, TSchema>): (context: {
+  db: Database<TSchema>;
+}) => {
+  pick(keys: KeySelection<Extract<keyof TFilters, string>>): /*elided*/any;
+  omit(keys: KeySelection<Extract<keyof TFilters, string>>): /*elided*/any;
+  parse(filters: TFilters): SQL | undefined;
+};
+//#endregion
+export { createTableQueryFiltersParser };

package/dist/src/modules/data-tables/lib/converters/filters.mjs

@@ -0,0 +1,38 @@
+import { and } from "drizzle-orm";
+
+//#region src/modules/data-tables/lib/converters/filters.ts
+/**
+* Creates a chainable parser builder for table query filters.
+*
+* Usage:
+* - create parser once from config
+* - bind context per request
+* - optionally narrow keys with pick/omit
+* - parse filters into a single `and(...)` SQL condition
+*/
+function createTableQueryFiltersParser(config) {
+	const configKeys = Object.keys(config);
+	function createBuilder(context, selected) {
+		return {
+			pick(keys) {
+				const selectedKeys = Object.entries(keys).filter(([_, value]) => value).map(([key]) => key);
+				return createBuilder(context, new Set(selectedKeys));
+			},
+			omit(keys) {
+				const selectedKeys = Array.from(selected).filter((key) => !keys[key]);
+				return createBuilder(context, new Set(selectedKeys));
+			},
+			parse(filters) {
+				return and(...Array.from(selected).map((key) => {
+					const parser = config[key];
+					if (!parser) throw new Error(`No parser defined for filter key "${key}"`);
+					return parser(filters, context);
+				}));
+			}
+		};
+	}
+	return (context) => createBuilder(context, new Set(configKeys));
+}
+
+//#endregion
+export { createTableQueryFiltersParser };

package/dist/src/modules/data-tables/lib/converters/pagination.d.mts

@@ -0,0 +1,17 @@
+import { TableQuerySchema } from "../validators.mjs";
+
+//#region src/modules/data-tables/lib/converters/pagination.d.ts
+/**
+ * Convert pagination to DB query
+ * @param {ConvertPaginationToQueryParamsInput} pagination
+ * @returns {{ limit: number; offset: number; }}
+ */
+declare function parseTableQueryPagination({
+  limit,
+  cursor
+}: Pick<TableQuerySchema, "cursor" | "limit">): {
+  limit: number;
+  offset: number;
+};
+//#endregion
+export { parseTableQueryPagination };

package/dist/src/modules/data-tables/lib/converters/pagination.mjs

@@ -0,0 +1,15 @@
+//#region src/modules/data-tables/lib/converters/pagination.ts
+/**
+* Convert pagination to DB query
+* @param {ConvertPaginationToQueryParamsInput} pagination
+* @returns {{ limit: number; offset: number; }}
+*/
+function parseTableQueryPagination({ limit, cursor }) {
+	return {
+		limit,
+		offset: cursor * limit
+	};
+}
+
+//#endregion
+export { parseTableQueryPagination };

package/dist/src/modules/data-tables/lib/converters/search.d.mts

@@ -0,0 +1,16 @@
+import { TableQuerySchema } from "../validators.mjs";
+import { PgColumn } from "drizzle-orm/pg-core";
+import { SQL } from "drizzle-orm";
+
+//#region src/modules/data-tables/lib/converters/search.d.ts
+type ConvertSearchToQueryParamsFields = PgColumn[];
+/**
+ * Convert search to DB query
+ * @param {ConvertSearchToQueryParamsInput}
+ * @returns { { OR: Record<string, { contains: string, mode: "insensitive" }> } }
+ */
+declare function convertSearchToQueryParams({
+  search
+}: Pick<TableQuerySchema, "search">, fields: ConvertSearchToQueryParamsFields): SQL | undefined;
+//#endregion
+export { ConvertSearchToQueryParamsFields, convertSearchToQueryParams };

package/dist/src/modules/data-tables/lib/converters/search.mjs

@@ -0,0 +1,15 @@
+import { ilike, or, sql } from "drizzle-orm";
+
+//#region src/modules/data-tables/lib/converters/search.ts
+/**
+* Convert search to DB query
+* @param {ConvertSearchToQueryParamsInput}
+* @returns { { OR: Record<string, { contains: string, mode: "insensitive" }> } }
+*/
+function convertSearchToQueryParams({ search }, fields) {
+	if (!search) return void 0;
+	return or(...fields.map((field) => ilike(sql`${field}::text`, `%${search}%`)));
+}
+
+//#endregion
+export { convertSearchToQueryParams };

package/dist/src/modules/data-tables/lib/converters/sorting.d.mts

@@ -0,0 +1,48 @@
+import { TableQuerySchema } from "../validators.mjs";
+import { PgColumn } from "drizzle-orm/pg-core";
+import { SQL } from "drizzle-orm";
+
+//#region src/modules/data-tables/lib/converters/sorting.d.ts
+/**
+ * Creates a reusable sorting parser for table query parameters.
+ *
+ * Resolves a user's sort/order selection to Drizzle SQL expressions.
+ * Supports sorting on both own-table columns and relation columns (via joins).
+ *
+ * Returns an object with the resolved config, normalized options, and a `parse`
+ * function that converts `TableQuerySchema` input into `SQL[]` for `.orderBy(...orderBy)`.
+ *
+ * @param config - Sortable columns keyed by their URL sort parameter name.
+ *   Use `getTableColumns(table)` as a base, and spread in relation columns.
+ * @param options.fallback - Order applied when no valid sort is provided by the user.
+ * @param options.every - Order appended to every result, regardless of user sort.
+ *   Useful for deterministic tiebreakers (e.g. always sort by id as secondary).
+ *
+ * @example
+ * const runSortingConfig = {
+ *   ...getTableColumns(runs),
+ *   projectTitle: projects.title,
+ * };
+ *
+ * export const parseRunTableQuerySorting = createTableQuerySortingParser(
+ *   runSortingConfig,
+ *   { fallback: [desc(runs.scheduledAt)] },
+ * );
+ *
+ * // In handler:
+ * const orderBy = parseRunTableQuerySorting.parse(input);
+ * db.select().from(runs).orderBy(...orderBy);
+ */
+declare function createTableQuerySortingParser<TConfig extends Record<string, PgColumn>>(config: TConfig, options?: {
+  fallback?: SQL | SQL[];
+  every?: SQL | SQL[];
+}): {
+  config: TConfig;
+  options: {
+    every: SQL<unknown>[];
+    fallback: SQL<unknown>[];
+  };
+  parse: (input: Pick<TableQuerySchema, "sort" | "order">) => SQL[];
+};
+//#endregion
+export { createTableQuerySortingParser };

package/dist/src/modules/data-tables/lib/converters/sorting.mjs

@@ -0,0 +1,55 @@
+import { asc, desc } from "drizzle-orm";
+
+//#region src/modules/data-tables/lib/converters/sorting.ts
+/**
+* Creates a reusable sorting parser for table query parameters.
+*
+* Resolves a user's sort/order selection to Drizzle SQL expressions.
+* Supports sorting on both own-table columns and relation columns (via joins).
+*
+* Returns an object with the resolved config, normalized options, and a `parse`
+* function that converts `TableQuerySchema` input into `SQL[]` for `.orderBy(...orderBy)`.
+*
+* @param config - Sortable columns keyed by their URL sort parameter name.
+*   Use `getTableColumns(table)` as a base, and spread in relation columns.
+* @param options.fallback - Order applied when no valid sort is provided by the user.
+* @param options.every - Order appended to every result, regardless of user sort.
+*   Useful for deterministic tiebreakers (e.g. always sort by id as secondary).
+*
+* @example
+* const runSortingConfig = {
+*   ...getTableColumns(runs),
+*   projectTitle: projects.title,
+* };
+*
+* export const parseRunTableQuerySorting = createTableQuerySortingParser(
+*   runSortingConfig,
+*   { fallback: [desc(runs.scheduledAt)] },
+* );
+*
+* // In handler:
+* const orderBy = parseRunTableQuerySorting.parse(input);
+* db.select().from(runs).orderBy(...orderBy);
+*/
+function createTableQuerySortingParser(config, options) {
+	const every = options?.every ? Array.isArray(options.every) ? options.every : [options.every] : [];
+	const fallback = options?.fallback ? Array.isArray(options.fallback) ? options.fallback : [options.fallback] : [];
+	return {
+		config,
+		options: {
+			every,
+			fallback
+		},
+		parse: (input) => {
+			const direction = input.order === "asc" ? asc : desc;
+			if (input.sort && input.sort in config) {
+				const column = config[input.sort];
+				return [direction(column), ...every];
+			}
+			return [...fallback, ...every];
+		}
+	};
+}
+
+//#endregion
+export { createTableQuerySortingParser };

package/dist/src/modules/data-tables/lib/filters/config.d.mts

@@ -0,0 +1,13 @@
+import { ParseFilter } from "./parsers.mjs";
+import { ZodType } from "zod";
+
+//#region src/modules/data-tables/lib/filters/config.d.ts
+type TableFiltersDef = {
+  readonly [k: string]: ParseFilter<ZodType>;
+};
+type TableFiltersResult = {
+  readonly [k: string]: unknown;
+};
+declare const createTableFilters: <TDef extends TableFiltersDef>(def: TDef) => TDef;
+//#endregion
+export { TableFiltersDef, TableFiltersResult, createTableFilters };

package/dist/src/modules/data-tables/lib/filters/config.mjs

@@ -0,0 +1,5 @@
+//#region src/modules/data-tables/lib/filters/config.ts
+const createTableFilters = (def) => def;
+
+//#endregion
+export { createTableFilters };

package/dist/src/modules/data-tables/lib/filters/helpers.d.mts

@@ -0,0 +1,10 @@
+import deepmerge from "deepmerge";
+
+//#region src/modules/data-tables/lib/filters/helpers.d.ts
+declare const mergeFilters: typeof deepmerge;
+/**
+ * Converts visibility state to filter config
+ */
+declare function parseFiltersVisibility<TKey extends string>(config: TKey[], visibilityState: Partial<Record<TKey, boolean>> | undefined): Record<TKey, boolean>;
+//#endregion
+export { mergeFilters, parseFiltersVisibility };

package/dist/src/modules/data-tables/lib/filters/helpers.mjs

@@ -0,0 +1,16 @@
+import deepmerge from "deepmerge";
+
+//#region src/modules/data-tables/lib/filters/helpers.ts
+const mergeFilters = deepmerge;
+/**
+* Converts visibility state to filter config
+*/
+function parseFiltersVisibility(config, visibilityState) {
+	return config.reduce((acc, key) => {
+		acc[key] = visibilityState?.[key] === void 0 ? true : visibilityState[key] ?? false;
+		return acc;
+	}, {});
+}
+
+//#endregion
+export { mergeFilters, parseFiltersVisibility };