@povio/ui 5.0.0-rc.1 → 5.0.0-rc.3

package/dist/useTableColumnConfig-gfVame8v.js

@@ -0,0 +1,892 @@
+import { t as Table } from "./Table-BDNSuEWc.js";
+import { t as Checkbox } from "./Checkbox-BU0d702K.js";
+import { t as Typography } from "./Typography-LU4z2pR1.js";
+import { t as Spinner } from "./Spinner-BeVTUzzx.js";
+import "./i18n-CX2EjhJI.js";
+import { t as useIntersectionObserver } from "./useIntersectionObserver-DYfHnGGU.js";
+import { t as IntlUtils } from "./intl.utils-zwAFoZ0U.js";
+import { t as DateUtils } from "./date.utils-B8_QF9y6.js";
+import { t as StringUtils } from "./string.utils-BPgv6QwA.js";
+import { t as ZodUtils } from "./zod.utils-DrrPDT9v.js";
+import { t as Dialog } from "./Dialog-9manOgMA.js";
+import { Pagination } from "./components/pagination.js";
+import { t as useTranslationMemo } from "./useTranslationMemo-CrZbeyBv.js";
+import { t as UIRouter } from "./router.context-B0jTMtE0.js";
+import { t as RoutingUtils } from "./routing.utils-UTQonIhB.js";
+import { useEffect, useState } from "react";
+import { c } from "react/compiler-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useTranslation } from "react-i18next";
+import { z } from "zod";
+import i18next from "i18next";
+//#region src/components/table/ColumnConfig.tsx
+const VisibilityCell = (t0) => {
+	const $ = c(7);
+	const { original, onToggle } = t0;
+	let t1;
+	if ($[0] !== onToggle || $[1] !== original.id) {
+		t1 = () => onToggle(original.id);
+		$[0] = onToggle;
+		$[1] = original.id;
+		$[2] = t1;
+	} else t1 = $[2];
+	const t2 = original.label;
+	let t3;
+	if ($[3] !== original.visible || $[4] !== t1 || $[5] !== t2) {
+		t3 = /* @__PURE__ */ jsx(Checkbox, {
+			isSelected: original.visible,
+			onChange: t1,
+			hideLabel: true,
+			children: t2
+		});
+		$[3] = original.visible;
+		$[4] = t1;
+		$[5] = t2;
+		$[6] = t3;
+	} else t3 = $[6];
+	return t3;
+};
+const getColumns = (t, handleToggleVisibility) => [{
+	id: "name",
+	header: t(($) => $.ui.table.column, { ns: "ui" }),
+	meta: { width: "flex-1" },
+	accessorKey: "label"
+}, {
+	id: "visible",
+	header: t(($) => $.ui.table.show, { ns: "ui" }),
+	meta: { width: "w-20" },
+	cell: ({ original }) => /* @__PURE__ */ jsx(VisibilityCell, {
+		original,
+		onToggle: handleToggleVisibility
+	})
+}];
+function ColumnConfigModal(t0) {
+	const $ = c(27);
+	const { isOpen, onClose, configColumns, visibleColumns, onVisibilityChange, onOrderChange } = t0;
+	const { t } = useTranslation("ui");
+	let t1;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = [];
+		$[0] = t1;
+	} else t1 = $[0];
+	const [data, setData] = useState(t1);
+	let t2;
+	let t3;
+	if ($[1] !== configColumns || $[2] !== visibleColumns) {
+		t2 = () => {
+			setData(configColumns.map((column) => {
+				const columnId = column.id ?? column.accessorKey;
+				return {
+					id: columnId,
+					label: column.header,
+					visible: visibleColumns?.[columnId] ?? true
+				};
+			}));
+		};
+		t3 = [configColumns, visibleColumns];
+		$[1] = configColumns;
+		$[2] = visibleColumns;
+		$[3] = t2;
+		$[4] = t3;
+	} else {
+		t2 = $[3];
+		t3 = $[4];
+	}
+	useEffect(t2, t3);
+	let t4;
+	if ($[5] !== onVisibilityChange || $[6] !== visibleColumns) {
+		t4 = (columnId_0) => {
+			const newVisible = {
+				...visibleColumns,
+				[columnId_0]: !visibleColumns[columnId_0]
+			};
+			onVisibilityChange(newVisible);
+		};
+		$[5] = onVisibilityChange;
+		$[6] = visibleColumns;
+		$[7] = t4;
+	} else t4 = $[7];
+	const handleToggleVisibility = t4;
+	let t5;
+	if ($[8] !== handleToggleVisibility) {
+		t5 = (translateFn) => getColumns(translateFn, handleToggleVisibility);
+		$[8] = handleToggleVisibility;
+		$[9] = t5;
+	} else t5 = $[9];
+	const columns = useTranslationMemo(t5);
+	let t6;
+	if ($[10] !== onOrderChange) {
+		t6 = (reorderedItems) => {
+			setData(reorderedItems);
+			onOrderChange(reorderedItems.map(_temp$2));
+		};
+		$[10] = onOrderChange;
+		$[11] = t6;
+	} else t6 = $[11];
+	const handleReorder = t6;
+	if (!isOpen) return null;
+	let t7;
+	if ($[12] !== t) {
+		t7 = t(_temp2$2);
+		$[12] = t;
+		$[13] = t7;
+	} else t7 = $[13];
+	let t8;
+	if ($[14] !== t7) {
+		t8 = /* @__PURE__ */ jsx(Typography, {
+			as: "h2",
+			className: "font-bold",
+			size: "lead",
+			children: t7
+		});
+		$[14] = t7;
+		$[15] = t8;
+	} else t8 = $[15];
+	let t9;
+	if ($[16] !== columns || $[17] !== data || $[18] !== handleReorder) {
+		t9 = /* @__PURE__ */ jsx("div", {
+			className: "max-h-96 overflow-y-auto",
+			children: /* @__PURE__ */ jsx(Table, {
+				items: data,
+				columns,
+				showCellBorder: true,
+				className: "w-full",
+				enableDragDrop: true,
+				getRowId: _temp3,
+				onReorder: handleReorder
+			})
+		});
+		$[16] = columns;
+		$[17] = data;
+		$[18] = handleReorder;
+		$[19] = t9;
+	} else t9 = $[19];
+	let t10;
+	if ($[20] !== t8 || $[21] !== t9) {
+		t10 = /* @__PURE__ */ jsxs("div", {
+			className: "flex flex-col gap-2 p-4",
+			children: [t8, t9]
+		});
+		$[20] = t8;
+		$[21] = t9;
+		$[22] = t10;
+	} else t10 = $[22];
+	let t11;
+	if ($[23] !== isOpen || $[24] !== onClose || $[25] !== t10) {
+		t11 = /* @__PURE__ */ jsx(Dialog, {
+			isOpen,
+			onClose,
+			showCloseIcon: true,
+			children: t10
+		});
+		$[23] = isOpen;
+		$[24] = onClose;
+		$[25] = t10;
+		$[26] = t11;
+	} else t11 = $[26];
+	return t11;
+}
+function _temp3(row) {
+	return row.id;
+}
+function _temp2$2($) {
+	return $.ui.table.configureColumns;
+}
+function _temp$2(item) {
+	return item.id;
+}
+//#endregion
+//#region src/components/table/InfiniteTable.tsx
+const InfiniteTable = (t0) => {
+	const $ = c(20);
+	let fetchNextPage;
+	let hasNextPage;
+	let rest;
+	let t1;
+	if ($[0] !== t0) {
+		({hasNextPage, isFetchingNextPage: t1, fetchNextPage, ...rest} = t0);
+		$[0] = t0;
+		$[1] = fetchNextPage;
+		$[2] = hasNextPage;
+		$[3] = rest;
+		$[4] = t1;
+	} else {
+		fetchNextPage = $[1];
+		hasNextPage = $[2];
+		rest = $[3];
+		t1 = $[4];
+	}
+	const isFetchingNextPage = t1 === void 0 ? false : t1;
+	let t2;
+	if ($[5] !== fetchNextPage || $[6] !== hasNextPage || $[7] !== isFetchingNextPage) {
+		t2 = () => {
+			if (!isFetchingNextPage && hasNextPage) fetchNextPage();
+		};
+		$[5] = fetchNextPage;
+		$[6] = hasNextPage;
+		$[7] = isFetchingNextPage;
+		$[8] = t2;
+	} else t2 = $[8];
+	const handleLoadMore = t2;
+	let t3;
+	if ($[9] !== handleLoadMore) {
+		t3 = {
+			onIntersection: handleLoadMore,
+			rootMargin: "100px"
+		};
+		$[9] = handleLoadMore;
+		$[10] = t3;
+	} else t3 = $[10];
+	const { ref } = useIntersectionObserver(t3);
+	let t4;
+	if ($[11] !== rest) {
+		t4 = /* @__PURE__ */ jsx(Table, { ...rest });
+		$[11] = rest;
+		$[12] = t4;
+	} else t4 = $[12];
+	let t5;
+	if ($[13] !== hasNextPage || $[14] !== isFetchingNextPage || $[15] !== ref) {
+		t5 = (hasNextPage || isFetchingNextPage) && /* @__PURE__ */ jsx("div", {
+			ref,
+			className: "flex justify-center py-4",
+			children: /* @__PURE__ */ jsx(Spinner, {})
+		});
+		$[13] = hasNextPage;
+		$[14] = isFetchingNextPage;
+		$[15] = ref;
+		$[16] = t5;
+	} else t5 = $[16];
+	let t6;
+	if ($[17] !== t4 || $[18] !== t5) {
+		t6 = /* @__PURE__ */ jsxs("div", {
+			className: "flex flex-col",
+			children: [t4, t5]
+		});
+		$[17] = t4;
+		$[18] = t5;
+		$[19] = t6;
+	} else t6 = $[19];
+	return t6;
+};
+//#endregion
+//#region src/components/table/PaginatedTable.tsx
+const PaginatedTable = (t0) => {
+	const $ = c(24);
+	let items;
+	let pagination;
+	let rest;
+	let setPagination;
+	let totalItems;
+	if ($[0] !== t0) {
+		({pagination, setPagination, items, totalItems, ...rest} = t0);
+		$[0] = t0;
+		$[1] = items;
+		$[2] = pagination;
+		$[3] = rest;
+		$[4] = setPagination;
+		$[5] = totalItems;
+	} else {
+		items = $[1];
+		pagination = $[2];
+		rest = $[3];
+		setPagination = $[4];
+		totalItems = $[5];
+	}
+	let t1;
+	if ($[6] !== items) {
+		t1 = items ?? [];
+		$[6] = items;
+		$[7] = t1;
+	} else t1 = $[7];
+	let t2;
+	if ($[8] !== rest || $[9] !== t1) {
+		t2 = /* @__PURE__ */ jsx(Table, {
+			...rest,
+			items: t1
+		});
+		$[8] = rest;
+		$[9] = t1;
+		$[10] = t2;
+	} else t2 = $[10];
+	const t3 = totalItems ?? 0;
+	let t4;
+	let t5;
+	if ($[11] !== pagination || $[12] !== setPagination) {
+		t4 = (page) => setPagination({
+			...pagination,
+			pageIndex: page
+		});
+		t5 = (pageSize) => setPagination({
+			...pagination,
+			pageSize,
+			pageIndex: 1
+		});
+		$[11] = pagination;
+		$[12] = setPagination;
+		$[13] = t4;
+		$[14] = t5;
+	} else {
+		t4 = $[13];
+		t5 = $[14];
+	}
+	let t6;
+	if ($[15] !== pagination.pageIndex || $[16] !== pagination.pageSize || $[17] !== t3 || $[18] !== t4 || $[19] !== t5) {
+		t6 = /* @__PURE__ */ jsx(Pagination, {
+			page: pagination.pageIndex,
+			pageSize: pagination.pageSize,
+			totalItems: t3,
+			onPageChange: t4,
+			onPageSizeChange: t5
+		});
+		$[15] = pagination.pageIndex;
+		$[16] = pagination.pageSize;
+		$[17] = t3;
+		$[18] = t4;
+		$[19] = t5;
+		$[20] = t6;
+	} else t6 = $[20];
+	let t7;
+	if ($[21] !== t2 || $[22] !== t6) {
+		t7 = /* @__PURE__ */ jsxs("div", {
+			className: "flex flex-col gap-4",
+			children: [t2, t6]
+		});
+		$[21] = t2;
+		$[22] = t6;
+		$[23] = t7;
+	} else t7 = $[23];
+	return t7;
+};
+//#endregion
+//#region src/helpers/dynamicColumns.ts
+const DEFAULT_NAMESPACE = "dynamicColumns";
+const FORMAT_MAP = {
+	datetime: (value) => DateUtils.formatDate(new Date(value)),
+	dateRange: (value) => {
+		return `${DateUtils.formatDate(new Date(value.start))} - ${DateUtils.formatDate(new Date(value.end))}`;
+	},
+	enum: (value) => StringUtils.capitalize(value),
+	number: (value) => IntlUtils.getNumberFormatter(i18next.language).format(value),
+	string: (value) => String(value),
+	boolean: (value) => {
+		const key = `${DEFAULT_NAMESPACE}.${value ? "yes" : "no"}`;
+		if (i18next.exists(key)) return String(i18next.t(key));
+		return value ? "Yes" : "No";
+	}
+};
+const ZOD_TYPE_FORMAT_MAP = [
+	[z.ZodEnum, FORMAT_MAP.enum],
+	[z.ZodNumber, FORMAT_MAP.number],
+	[z.ZodString, FORMAT_MAP.string],
+	[z.ZodBoolean, FORMAT_MAP.boolean],
+	[z.ZodISODateTime, FORMAT_MAP.datetime]
+];
+const configValueToColumnDef = (value) => {
+	if (typeof value === "function" || typeof value === "string") return { cell: value };
+	if (typeof value === "boolean" || value === void 0) return {};
+	return value;
+};
+const convertEntriesToColumnDefs = (entries) => {
+	return entries.map(([key, value]) => [key, configValueToColumnDef(value)]);
+};
+const customConfigValueToColumnDef = (value) => {
+	if (typeof value === "string") return {
+		accessorKey: value,
+		cell: value
+	};
+	if (typeof value === "function") return { cell: value };
+	return value;
+};
+const convertCustomEntriesToColumnDefs = (entries) => {
+	return entries.map(([key, value]) => [key, customConfigValueToColumnDef(value)]);
+};
+const excludeEntries = (entries) => {
+	return entries.filter(([, value]) => value !== false && value !== void 0);
+};
+const sortColumns = (columns, orderKeys) => {
+	if (!orderKeys) return columns;
+	const wildcardIndex = orderKeys.indexOf("*");
+	if (wildcardIndex === -1) return columns.sort((columnA, columnB) => {
+		const idA = columnA.id;
+		const idB = columnB.id;
+		const orderMap = new Map(orderKeys.map((key, index) => [String(key), index]));
+		const orderA = orderMap.get(String(idA));
+		const orderB = orderMap.get(String(idB));
+		if (orderA !== void 0 && orderB !== void 0) return orderA - orderB;
+		if (orderA !== void 0 && orderB === void 0) return -1;
+		if (orderA === void 0 && orderB !== void 0) return 1;
+		return 0;
+	});
+	const beforeWildcard = orderKeys.slice(0, wildcardIndex);
+	const afterWildcard = orderKeys.slice(wildcardIndex + 1);
+	const beforeMap = new Map(beforeWildcard.map((key, index) => [String(key), index]));
+	const afterMap = new Map(afterWildcard.map((key, index) => [String(key), index]));
+	const before = [];
+	const middle = [];
+	const after = [];
+	columns.forEach((column) => {
+		const id = String(column.id);
+		if (beforeMap.has(id)) before.push(column);
+		else if (afterMap.has(id)) after.push(column);
+		else middle.push(column);
+	});
+	before.sort((a, b) => beforeMap.get(String(a.id)) - beforeMap.get(String(b.id)));
+	after.sort((a, b) => afterMap.get(String(a.id)) - afterMap.get(String(b.id)));
+	return [
+		...before,
+		...middle,
+		...after
+	];
+};
+const formatValueByType = (value, schemaType) => {
+	if (value === null || value === void 0) return null;
+	if (ZodUtils.isDateRange(schemaType)) return FORMAT_MAP.dateRange(value);
+	const unwrappedType = ZodUtils.unwrapZodType(schemaType);
+	if (unwrappedType instanceof z.ZodArray) {
+		if (!Array.isArray(value)) return null;
+		const elementType = unwrappedType.element;
+		return value.map((element) => formatValueByType(element, elementType)).join(", ");
+	}
+	const formatFunction = ZOD_TYPE_FORMAT_MAP.find(([zodType]) => unwrappedType instanceof zodType)?.[1];
+	if (formatFunction) return formatFunction(value);
+	return String(value);
+};
+const getNestedValue = (obj, path) => {
+	return path.split(".").reduce((current, key) => {
+		return current && typeof current === "object" ? current[key] : void 0;
+	}, obj);
+};
+const getKeyType = (schema, key) => {
+	const pathParts = key.split(".");
+	let currentType = schema.shape[pathParts[0]];
+	for (let i = 1; i < pathParts.length; i++) if (currentType instanceof z.ZodObject) currentType = currentType.shape[pathParts[i]];
+	else {
+		currentType = schema.shape[key];
+		break;
+	}
+	return currentType;
+};
+const getCellFunction = (schema, schemaKey, columnDef, options) => {
+	const { cell } = columnDef;
+	if (typeof cell === "function") return cell;
+	return ({ data }) => {
+		const key = typeof cell === "string" ? cell : schemaKey;
+		const value = getNestedValue(data, key);
+		const keyType = getKeyType(schema, key);
+		let finalValue = !options.disableFormatting?.includes(key) ? formatValueByType(value, keyType) : value;
+		if (options.emptyValue && !finalValue) finalValue = options.emptyValue;
+		if (options.globalWrapper) return options.globalWrapper(finalValue);
+		return finalValue;
+	};
+};
+const normalizeSortable = (sortable) => {
+	if (!sortable) return;
+	if (Array.isArray(sortable)) return sortable;
+	if (sortable instanceof z.ZodEnum) return Object.values(sortable.enum);
+};
+const getDefaultColumnHeader = (key, options) => {
+	const localeKey = `${options.namespace ?? DEFAULT_NAMESPACE}.${key}`;
+	if (i18next.exists(localeKey)) return String(i18next.t(localeKey));
+	return StringUtils.capitalize(key);
+};
+const overridePresetColumnsHeaders = (presetColumns, options) => {
+	const namespace = options.namespace ?? DEFAULT_NAMESPACE;
+	return presetColumns.map((columnDef) => {
+		const localeKey = `${namespace}.${columnDef.id}`;
+		const header = i18next.exists(localeKey) ? i18next.t(localeKey) : columnDef.header;
+		return {
+			...columnDef,
+			header: typeof header === "string" ? header : columnDef.header
+		};
+	});
+};
+const populateColumnDef = (schema, key, columnDef, options, sortableKeys) => {
+	const id = columnDef.id ?? key;
+	const enableSorting = columnDef.enableSorting ?? sortableKeys?.includes(id) ?? false;
+	const header = columnDef.header ?? getDefaultColumnHeader(key, options);
+	const cell = getCellFunction(schema, key, columnDef, options);
+	return {
+		...columnDef,
+		id,
+		accessorKey: key,
+		meta: {
+			width: "flex-1",
+			...options.globalMeta,
+			...columnDef.meta
+		},
+		header,
+		enableSorting,
+		cell
+	};
+};
+const populateCustomColumnDef = (schema, key, columnDef, options, sortableKeys) => {
+	const id = columnDef.id ?? key;
+	const accessorKey = columnDef.accessorKey ?? id;
+	const enableSorting = columnDef.enableSorting ?? sortableKeys?.includes(id) ?? false;
+	const header = columnDef.header ?? getDefaultColumnHeader(key, options);
+	const cell = getCellFunction(schema, key, columnDef, options);
+	return {
+		...columnDef,
+		id,
+		accessorKey,
+		meta: {
+			width: "flex-1",
+			...options.globalMeta,
+			...columnDef.meta
+		},
+		header,
+		enableSorting,
+		cell
+	};
+};
+const addMissingSchemaFields = (schema, existingColumns, options, sortableKeys) => {
+	const schemaFields = getAllSchemaKeys(schema);
+	const definedFields = new Set(existingColumns.map((col) => col.id));
+	const additionalColumns = schemaFields.filter((field) => !definedFields.has(field)).map((field) => {
+		return populateColumnDef(schema, field, {}, options, sortableKeys);
+	});
+	return [...existingColumns, ...additionalColumns];
+};
+const removeOverriddenPresetColumns = (presetColumns, options) => {
+	if (presetColumns.length === 0) return presetColumns;
+	const usedColumnsIds = Object.entries(options.columns ?? {}).map(([key, value]) => {
+		return value.id ?? key;
+	});
+	const usedCustomColumnsIds = Object.entries(options.customColumns ?? {}).map(([key, value]) => {
+		return value.id ?? key;
+	});
+	const usedIds = /* @__PURE__ */ new Set([...usedColumnsIds, ...usedCustomColumnsIds]);
+	return presetColumns.filter((column) => {
+		if (!column.id) return true;
+		return !usedIds.has(column.id);
+	});
+};
+const getAllSchemaKeys = (schema) => {
+	const keys = [];
+	const { shape } = schema;
+	const traverse = (obj, prefix = "") => {
+		Object.entries(obj).forEach(([key, value]) => {
+			const currentPath = prefix ? `${prefix}.${key}` : key;
+			keys.push(currentPath);
+			if (value instanceof z.ZodObject) traverse(value.shape, currentPath);
+		});
+	};
+	traverse(shape);
+	return keys;
+};
+const validateCustomColumnKeys = (schema, customColumnKeys) => {
+	const schemaKeys = getAllSchemaKeys(schema);
+	const invalidCustomColumnKeys = customColumnKeys.filter((key) => schemaKeys.includes(key));
+	if (invalidCustomColumnKeys.length > 0) throw new Error(`Invalid custom column keys: [${invalidCustomColumnKeys.join(", ")}]. Custom column keys cannot be part of the schema. Define these columns in the "columns" property instead.`);
+};
+const validateOptionKeyArray = (usedKeys, optionKeys, optionName) => {
+	if (!optionKeys) return;
+	const extraUnusedKeys = optionKeys.filter((key) => !usedKeys.has(key));
+	if (extraUnusedKeys.length > 0) throw new Error(`Found unnecessary keys in "${optionName}": [${extraUnusedKeys.join(", ")}].\n\nAll available options are: [${Array.from(usedKeys).join(", ")}].`);
+};
+const validateParams = (schema, presetColumns, options) => {
+	const { columns, customColumns, sortable, order, disableFormatting, includeAll } = options;
+	const columnKeys = Object.keys(columns ?? {});
+	const customColumnKeys = customColumns ? Object.keys(customColumns) : [];
+	const usedKeys = /* @__PURE__ */ new Set([...columnKeys, ...customColumnKeys]);
+	const presetKeys = presetColumns.map((column) => column.id).filter((id) => id !== void 0);
+	const schemaKeys = includeAll ? getAllSchemaKeys(schema) : [];
+	const allKeys = /* @__PURE__ */ new Set([
+		...presetKeys,
+		...usedKeys,
+		...schemaKeys,
+		"*"
+	]);
+	if (customColumns) validateCustomColumnKeys(schema, customColumnKeys);
+	if (Array.isArray(sortable)) validateOptionKeyArray(usedKeys, sortable, "sortable");
+	validateOptionKeyArray(allKeys, order, "order");
+	validateOptionKeyArray(usedKeys, disableFormatting, "disableFormatting");
+};
+const dynamicColumns = ({ schema, preset = [], options }) => {
+	validateParams(schema, preset, options);
+	const sortableKeys = normalizeSortable(options.sortable);
+	let entries = Object.entries(options.columns ?? {});
+	entries = excludeEntries(entries);
+	entries = convertEntriesToColumnDefs(entries);
+	const columns = entries.map(([key, value]) => {
+		return populateColumnDef(schema, key, value, options, sortableKeys);
+	});
+	let customEntries = Object.entries(options.customColumns ?? {});
+	customEntries = convertCustomEntriesToColumnDefs(customEntries);
+	const customColumns = customEntries.map(([key, value]) => {
+		return populateCustomColumnDef(schema, key, value, options, sortableKeys);
+	});
+	let presetColumns = removeOverriddenPresetColumns(preset, options);
+	if (options.overridePresetLocales) presetColumns = overridePresetColumnsHeaders(presetColumns, options);
+	const mergedColumns = [
+		...presetColumns,
+		...columns,
+		...customColumns
+	];
+	const allColumns = options.includeAll ? addMissingSchemaFields(schema, mergedColumns, options, sortableKeys) : mergedColumns;
+	return sortColumns(allColumns, options.order);
+};
+//#endregion
+//#region src/hooks/usePagination.ts
+const DEFAULT_STATE = {
+	pageIndex: 1,
+	pageSize: 20
+};
+function usePagination(defaultPagination) {
+	const $ = c(12);
+	const { replace, searchParams } = UIRouter.useUIRouter();
+	let t0;
+	if ($[0] !== defaultPagination || $[1] !== searchParams) {
+		t0 = defaultPagination ?? {
+			pageIndex: searchParams.has("page") ? Number.parseInt(searchParams.get("page") ?? "", 10) : DEFAULT_STATE.pageIndex,
+			pageSize: searchParams.has("size") ? Number.parseInt(searchParams.get("size") ?? "", 10) : DEFAULT_STATE.pageSize
+		};
+		$[0] = defaultPagination;
+		$[1] = searchParams;
+		$[2] = t0;
+	} else t0 = $[2];
+	const [pagination, setPagination] = useState(t0);
+	let t1;
+	if ($[3] !== pagination.pageIndex || $[4] !== pagination.pageSize || $[5] !== replace || $[6] !== searchParams) {
+		t1 = () => {
+			const params = new URLSearchParams(searchParams);
+			params.delete("size");
+			params.delete("page");
+			if (pagination.pageSize !== DEFAULT_STATE.pageSize) params.set("size", pagination.pageSize.toString());
+			if (pagination.pageIndex !== DEFAULT_STATE.pageIndex) params.set("page", pagination.pageIndex.toString());
+			if (params.toString() === searchParams.toString()) return;
+			replace(".", RoutingUtils.toRouterSearch(params));
+		};
+		$[3] = pagination.pageIndex;
+		$[4] = pagination.pageSize;
+		$[5] = replace;
+		$[6] = searchParams;
+		$[7] = t1;
+	} else t1 = $[7];
+	let t2;
+	if ($[8] !== pagination) {
+		t2 = [pagination];
+		$[8] = pagination;
+		$[9] = t2;
+	} else t2 = $[9];
+	useEffect(t1, t2);
+	let t3;
+	if ($[10] !== pagination) {
+		t3 = {
+			pagination,
+			setPagination,
+			pageIndex: pagination.pageIndex,
+			pageSize: pagination.pageSize
+		};
+		$[10] = pagination;
+		$[11] = t3;
+	} else t3 = $[11];
+	return t3;
+}
+//#endregion
+//#region src/hooks/useSorting.ts
+function useSorting(defaultSorting, t0) {
+	const $ = c(16);
+	const prefix = t0 === void 0 ? "" : t0;
+	const { replace, searchParams } = UIRouter.useUIRouter();
+	let t1;
+	if ($[0] !== defaultSorting || $[1] !== prefix || $[2] !== searchParams) {
+		t1 = defaultSorting ?? searchParams.get(`order${prefix && `-${prefix}`}`)?.split(",").map(_temp$1) ?? [];
+		$[0] = defaultSorting;
+		$[1] = prefix;
+		$[2] = searchParams;
+		$[3] = t1;
+	} else t1 = $[3];
+	const [sorting, setSorting] = useState(t1);
+	let t2;
+	if ($[4] !== sorting) {
+		t2 = sorting.map(_temp2$1).join(",");
+		$[4] = sorting;
+		$[5] = t2;
+	} else t2 = $[5];
+	const order = t2;
+	let t3;
+	if ($[6] !== order || $[7] !== prefix || $[8] !== replace || $[9] !== searchParams) {
+		t3 = () => {
+			const params = new URLSearchParams(searchParams);
+			const orderKey = prefix ? `order-${prefix}` : "order";
+			params.delete(orderKey);
+			if (order) params.set(orderKey, order);
+			if (params.toString() === searchParams.toString()) return;
+			replace(".", RoutingUtils.toRouterSearch(params));
+		};
+		$[6] = order;
+		$[7] = prefix;
+		$[8] = replace;
+		$[9] = searchParams;
+		$[10] = t3;
+	} else t3 = $[10];
+	let t4;
+	if ($[11] !== order) {
+		t4 = [order];
+		$[11] = order;
+		$[12] = t4;
+	} else t4 = $[12];
+	useEffect(t3, t4);
+	let t5;
+	if ($[13] !== order || $[14] !== sorting) {
+		t5 = {
+			sorting,
+			setSorting,
+			order
+		};
+		$[13] = order;
+		$[14] = sorting;
+		$[15] = t5;
+	} else t5 = $[15];
+	return t5;
+}
+function _temp2$1(field) {
+	return `${field.desc ? "-" : "+"}${field.id}`;
+}
+function _temp$1(item) {
+	if (item.startsWith("-")) return {
+		id: item.slice(1),
+		desc: true
+	};
+	if (item.startsWith("+")) return {
+		id: item.slice(1),
+		desc: false
+	};
+	return {
+		id: item,
+		desc: false
+	};
+}
+//#endregion
+//#region src/hooks/useTableColumnConfig.ts
+function sortByKeyOrder(data, orderedKeys = []) {
+	return [...data].sort((a, b) => {
+		return orderedKeys.findIndex((key) => key === (a.id ?? a.accessorKey)) - orderedKeys.findIndex((key) => key === (b.id ?? b.accessorKey));
+	});
+}
+function useTableColumnConfig(defaultColumns, t0) {
+	const $ = c(31);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const options = t1;
+	let t2;
+	if ($[2] !== defaultColumns) {
+		t2 = () => defaultColumns.reduce(_temp, {});
+		$[2] = defaultColumns;
+		$[3] = t2;
+	} else t2 = $[3];
+	const [internalVisibleColumns, setInternalVisibleColumns] = useState(t2);
+	let t3;
+	if ($[4] !== defaultColumns) {
+		t3 = () => defaultColumns.map(_temp2);
+		$[4] = defaultColumns;
+		$[5] = t3;
+	} else t3 = $[5];
+	const [internalColumnOrder, setInternalColumnOrder] = useState(t3);
+	let t4;
+	let t5;
+	if ($[6] !== options.visibleColumns) {
+		t4 = () => {
+			if (options.visibleColumns) setInternalVisibleColumns(options.visibleColumns);
+		};
+		t5 = [options.visibleColumns];
+		$[6] = options.visibleColumns;
+		$[7] = t4;
+		$[8] = t5;
+	} else {
+		t4 = $[7];
+		t5 = $[8];
+	}
+	useEffect(t4, t5);
+	let t6;
+	let t7;
+	if ($[9] !== options.columnOrder) {
+		t6 = () => {
+			if (options.columnOrder) setInternalColumnOrder(options.columnOrder);
+		};
+		t7 = [options.columnOrder];
+		$[9] = options.columnOrder;
+		$[10] = t6;
+		$[11] = t7;
+	} else {
+		t6 = $[10];
+		t7 = $[11];
+	}
+	useEffect(t6, t7);
+	let t8;
+	if ($[12] !== options) {
+		t8 = (value) => {
+			setInternalVisibleColumns(value);
+			options?.onVisibilityChange?.(value);
+		};
+		$[12] = options;
+		$[13] = t8;
+	} else t8 = $[13];
+	const handleVisibilityChange = t8;
+	let t9;
+	if ($[14] !== options) {
+		t9 = (value_0) => {
+			setInternalColumnOrder(value_0);
+			options?.onOrderChange?.(value_0);
+		};
+		$[14] = options;
+		$[15] = t9;
+	} else t9 = $[15];
+	const handleOrderChange = t9;
+	let t10;
+	if ($[16] !== defaultColumns || $[17] !== internalColumnOrder) {
+		t10 = sortByKeyOrder(defaultColumns, internalColumnOrder);
+		$[16] = defaultColumns;
+		$[17] = internalColumnOrder;
+		$[18] = t10;
+	} else t10 = $[18];
+	const configColumns = t10;
+	let t11;
+	if ($[19] !== configColumns || $[20] !== internalVisibleColumns) {
+		let t12;
+		if ($[22] !== internalVisibleColumns) {
+			t12 = (col_1) => internalVisibleColumns?.[col_1.id ?? col_1.accessorKey] ?? true;
+			$[22] = internalVisibleColumns;
+			$[23] = t12;
+		} else t12 = $[23];
+		t11 = configColumns.filter(t12);
+		$[19] = configColumns;
+		$[20] = internalVisibleColumns;
+		$[21] = t11;
+	} else t11 = $[21];
+	const columns = t11;
+	let t12;
+	if ($[24] !== columns || $[25] !== configColumns || $[26] !== handleOrderChange || $[27] !== handleVisibilityChange || $[28] !== internalColumnOrder || $[29] !== internalVisibleColumns) {
+		t12 = {
+			configColumns,
+			columns,
+			visibleColumns: internalVisibleColumns,
+			columnOrder: internalColumnOrder,
+			onVisibilityChange: handleVisibilityChange,
+			onOrderChange: handleOrderChange
+		};
+		$[24] = columns;
+		$[25] = configColumns;
+		$[26] = handleOrderChange;
+		$[27] = handleVisibilityChange;
+		$[28] = internalColumnOrder;
+		$[29] = internalVisibleColumns;
+		$[30] = t12;
+	} else t12 = $[30];
+	return t12;
+}
+function _temp2(col_0) {
+	return col_0.id ?? col_0.accessorKey;
+}
+function _temp(acc, col) {
+	const key = col.id ?? col.accessorKey;
+	acc[key] = true;
+	return acc;
+}
+//#endregion
+export { PaginatedTable as a, dynamicColumns as i, useSorting as n, InfiniteTable as o, usePagination as r, ColumnConfigModal as s, useTableColumnConfig as t };