@payfit/unity-components 3.1.14 → 3.1.16

package/dist/esm/components/filter-toolbar/FilterToolbar.d.ts

@@ -1,111 +0,0 @@
-import { FilterToolbarProps } from './FilterToolbar.types.js';
-/**
- * Tailwind variants for the FilterToolbar component styling.
- * Defines layout slots for the toolbar container, filters area, and action buttons.
- * @internal
- */
-export declare const filterToolbar: import('tailwind-variants').TVReturnType<{
-    [key: string]: {
-        [key: string]: import('tailwind-variants').ClassValue | {
-            base?: import('tailwind-variants').ClassValue;
-            actions?: import('tailwind-variants').ClassValue;
-            filters?: import('tailwind-variants').ClassValue;
-        };
-    };
-} | {
-    [x: string]: {
-        [x: string]: import('tailwind-variants').ClassValue | {
-            base?: import('tailwind-variants').ClassValue;
-            actions?: import('tailwind-variants').ClassValue;
-            filters?: import('tailwind-variants').ClassValue;
-        };
-    };
-} | {}, {
-    base: string[];
-    filters: string[];
-    actions: string[];
-}, undefined, {
-    [key: string]: {
-        [key: string]: import('tailwind-variants').ClassValue | {
-            base?: import('tailwind-variants').ClassValue;
-            actions?: import('tailwind-variants').ClassValue;
-            filters?: import('tailwind-variants').ClassValue;
-        };
-    };
-} | {}, {
-    base: string[];
-    filters: string[];
-    actions: string[];
-}, import('tailwind-variants').TVReturnTypeLike<unknown, {
-    base: string[];
-    filters: string[];
-    actions: string[];
-}>>;
-/**
- * The FilterToolbar component manages a dynamic collection of filters in a toolbar layout, enabling users to build complex filtering UIs.
- * The FilterToolbar provides a data-driven approach to filter management where filters can be added, configured,
- * and removed on demand. Each filter maintains its own state while the toolbar orchestrates the overall filtering experience.
- * @param {FilterToolbarProps} props - Configuration for the filter toolbar including filter definitions and event handlers
- * @example
- * ```tsx
- * import { FilterToolbar } from '@payfit/unity-components'
- * import { useState } from 'react'
- *
- * function Example() {
- *   const [filters, setFilters] = useState([])
- *
- *   const filterDefs = [
- *     {
- *       id: 'status',
- *       label: 'Status',
- *       renderControl: (value, onChange) => (
- *         <Select value={value} onChange={onChange}>
- *           <Option value="active">Active</Option>
- *           <Option value="inactive">Inactive</Option>
- *         </Select>
- *       ),
- *       renderLabel: (value) => value
- *     },
- *     {
- *       id: 'department',
- *       label: 'Department',
- *       renderControl: (value, onChange) => (
- *         <Select value={value} onChange={onChange}>
- *           <Option value="engineering">Engineering</Option>
- *           <Option value="sales">Sales</Option>
- *         </Select>
- *       ),
- *       renderLabel: (value) => value
- *     }
- *   ]
- *
- *   return (
- *     <FilterToolbar
- *       filterDefs={filterDefs}
- *       onChange={(appliedFilters) => {
- *         setFilters(appliedFilters)
- *       }}
- *     />
- *   )
- * }
- * ```
- * @remarks
- * - The toolbar manages filter state internally, providing serializable filter values through the `onChange` callback
- * - Filters can be prepopulated using the `initialValue` prop with an array of `AppliedFilter` objects
- * - Each filter definition must include a unique `id`, `label`, and `renderControl` function to render the filter UI
- * - The `renderLabel` function customizes how selected values appear in the filter button
- * - Newly added filters automatically open their popover to guide users through configuration
- * - Filters supplied through `initialValue` do not open automatically; their popover opens only after user interaction
- * - All filters can be cleared at once using the "Clear filters" button
- * - The component is uncontrolled by default but notifies parent components of state changes via callbacks
- * @see {@link FilterToolbarProps} for all available props
- * @see {@link FilterDef} for filter definition structure
- * @see Source code in {@link https://github.com/PayFit/hr-apps/tree/master/libs/shared/unity/components/src/components/filter-toolbar GitHub}
- * @see Design specs {@link https://www.figma.com/design/poaMyU7abAgL9VRhx4ygyy/Unity-DS-%3E-Components-Library?node-id=8976-10418 Figma}
- * @see Design docs in {@link https://www.payfit.design/24f360409/p/998c5f-filter Payfit.design}
- * @see Developer docs in {@link https://unity-components.payfit.io/?path=/docs/data-filtertoolbar--docs unity-components.payfit.io}
- */
-declare const FilterToolbar: import('react').ForwardRefExoticComponent<FilterToolbarProps & import('react').RefAttributes<HTMLDivElement>>;
-export { FilterToolbar };
-export * from './utils/filter-adapters.js';
-export type * from './FilterToolbar.types.js';

package/dist/esm/components/filter-toolbar/FilterToolbar.js

@@ -1,124 +0,0 @@
-import { Button as e } from "../button/Button.js";
-import { Filter as t } from "../filter/Filter.js";
-import { useFilterToolbarState as n } from "./hooks/use-filter-toolbar-state.js";
-import { AddFilter as r } from "./parts/AddFilter.js";
-import { FilterAdapters as i } from "./utils/filter-adapters.js";
-import { forwardRef as a, useMemo as o, useState as s } from "react";
-import { uyTv as c } from "@payfit/unity-themes";
-import { jsx as l, jsxs as u } from "react/jsx-runtime";
-import { Group as d } from "react-aria-components/Group";
-import { Toolbar as f } from "react-aria-components/Toolbar";
-import { FormattedMessage as p, useIntl as m } from "react-intl";
-import { useId as h } from "react-aria/useId";
-//#region src/components/filter-toolbar/FilterToolbar.tsx
-var g = c({ slots: {
-	base: ["uy:flex uy:gap-100 uy:flex-wrap uy:items-center"],
-	filters: ["uy:list-none uy:contents"],
-	actions: ["uy:contents"]
-} }), _ = a(({ filterDefs: i, initialValue: a, onChange: c, onClearFiltersPress: _, onAddFilterPress: v, ...y }, b) => {
-	let x = m(), S = h(), [C, w] = s(/* @__PURE__ */ new Set()), { appliedFilters: T, availableFilterDefs: E, filterValues: D, status: O, addFilter: k, clearFilters: A, removeFilter: j, setFilterValue: M } = n({
-		filterDefs: i,
-		initialValue: a,
-		onChange: c
-	}), N = o(() => new Map(i.map((e) => [e.id, e])), [i]), P = (e) => {
-		if (e === "all") return;
-		let t = Array.from(e).map(String);
-		k(t), w((e) => /* @__PURE__ */ new Set([...e, ...t])), v?.(t);
-	}, F = () => {
-		A(), _?.();
-	}, I = (e, t) => {
-		M(e, t);
-	}, L = (e) => {
-		j(e);
-	}, R = (e) => {
-		w((t) => {
-			let n = new Set(t);
-			return n.delete(e), n;
-		});
-	}, z = O === "WITH_ALL_FILTERS_APPLIED", B = O !== "EMPTY", { base: V, filters: H, actions: U } = g(), W = o(() => ({
-		toolbar: x.formatMessage({
-			id: "unity:component:filter-toolbar:label",
-			defaultMessage: "Filter toolbar"
-		}),
-		filterList: x.formatMessage({
-			id: "unity:component:filter-toolbar:filter-list:label",
-			defaultMessage: "Applied filters"
-		}),
-		filterControls: x.formatMessage({
-			id: "unity:component:filter-toolbar:filter-controls:label",
-			defaultMessage: "Filter control"
-		})
-	}), [x]), G = o(() => ({
-		filterList: `filter-toolbar-${S}__filter-list`,
-		filterControls: `filter-toolbar-${S}__filter-controls`
-	}), [S]);
-	return /* @__PURE__ */ u(f, {
-		ref: b,
-		className: V(),
-		"aria-label": W.toolbar,
-		...y,
-		children: [T.length > 0 && /* @__PURE__ */ l("ul", {
-			className: H(),
-			"aria-live": "polite",
-			"aria-atomic": "true",
-			"aria-relevant": "additions removals",
-			"aria-label": W.filterList,
-			id: G.filterList,
-			children: T.map((e, n) => {
-				let r = N.get(e);
-				if (!r) return null;
-				let i = D.get(e);
-				return /* @__PURE__ */ l("li", {
-					role: "presentation",
-					children: /* @__PURE__ */ l(t, {
-						id: r.id,
-						label: r.label,
-						value: i,
-						onChange: (e) => {
-							I(r.id, e);
-						},
-						renderControl: r.renderControl,
-						renderLabel: r.renderLabel,
-						isDismissable: !0,
-						isDefaultOpen: C.has(e),
-						onFilterOpen: () => {
-							R(r.id);
-						},
-						onDismiss: () => {
-							L(r.id);
-						},
-						onClearSelection: () => {
-							M(r.id, void 0);
-						},
-						onConfirmSelection: () => {
-							M(r.id, i);
-						},
-						...r.filterProps
-					})
-				}, `filter-item-${n}`);
-			})
-		}), /* @__PURE__ */ u(d, {
-			className: U(),
-			"aria-label": W.filterControls,
-			id: G.filterControls,
-			children: [/* @__PURE__ */ l(r, {
-				availableFilterDefs: [...E],
-				isDisabled: z,
-				onSelectionChange: P,
-				"aria-controls": G.filterControls
-			}), B && /* @__PURE__ */ l(e, {
-				variant: "ghost",
-				color: "neutral",
-				onPress: F,
-				"aria-controls": G.filterList,
-				children: /* @__PURE__ */ l(p, {
-					id: "unity:component:filter-toolbar:clear-filters:label",
-					defaultMessage: "Clear filters"
-				})
-			})]
-		})]
-	});
-});
-_.displayName = "FilterToolbar";
-//#endregion
-export { i as FilterAdapters, _ as FilterToolbar, g as filterToolbar };

package/dist/esm/components/filter-toolbar/hooks/use-filter-toolbar-state.js

@@ -1,130 +0,0 @@
-import { normalizeFilterValue as e } from "../utils/normalize-filter-value.js";
-import { useCallback as t, useMemo as n, useReducer as r } from "react";
-//#region src/components/filter-toolbar/hooks/use-filter-toolbar-state.ts
-function i(e) {
-	return (t, n) => {
-		switch (n.type) {
-			case "ADD_FILTERS": {
-				let r = new Set(t.appliedFilters), i = !1;
-				for (let t of n.payload) e.has(t) && !r.has(t) && (r.add(t), i = !0);
-				return i ? {
-					appliedFilters: r,
-					filterValues: t.filterValues
-				} : t;
-			}
-			case "REMOVE_FILTERS": {
-				let e = new Set(t.appliedFilters), r = new Map(t.filterValues), i = !1;
-				for (let t of n.payload) e.delete(t) && (r.delete(t), i = !0);
-				return i ? {
-					appliedFilters: e,
-					filterValues: r
-				} : t;
-			}
-			case "CLEAR_FILTERS": return {
-				appliedFilters: /* @__PURE__ */ new Set(),
-				filterValues: /* @__PURE__ */ new Map()
-			};
-			case "SET_FILTER_VALUE": {
-				let { filterId: e, value: r } = n.payload;
-				if (!t.appliedFilters.has(e)) return t;
-				let i = new Map(t.filterValues);
-				if (r == null) {
-					if (!i.has(e)) return t;
-					i.delete(e);
-				} else {
-					if (i.get(e) === r) return t;
-					i.set(e, r);
-				}
-				return {
-					appliedFilters: t.appliedFilters,
-					filterValues: i
-				};
-			}
-			default: return t;
-		}
-	};
-}
-function a(a) {
-	let { filterDefs: o, initialValue: s, onChange: c } = a, l = n(() => new Set(o.map((e) => e.id)), [o]), u = n(() => {
-		let e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Map();
-		if (s) for (let n of s) {
-			let r = n.id, i = n.value;
-			l.has(r) && (e.add(r), i != null && t.set(r, i));
-		}
-		return {
-			appliedFilters: e,
-			filterValues: t
-		};
-	}, [s, l]), [d, f] = r(n(() => i(l), [l]), u), p = n(() => Array.from(d.appliedFilters), [d.appliedFilters]), m = n(() => Array.from(l).filter((e) => !d.appliedFilters.has(e)), [l, d.appliedFilters]), h = n(() => {
-		let e = [];
-		for (let t of o) d.appliedFilters.has(t.id) || e.push(t);
-		return e;
-	}, [o, d.appliedFilters]), g = n(() => {
-		let e = d.appliedFilters.size, t = l.size;
-		return e === 0 ? "EMPTY" : t > 0 && e === t ? "WITH_ALL_FILTERS_APPLIED" : "WITH_SOME_FILTERS_APPLIED";
-	}, [d.appliedFilters.size, l.size]), _ = t((t, n) => Array.from(t).map((t) => ({
-		id: t,
-		value: e(n.get(t))
-	})), []), v = t((e) => {
-		let t = Array.isArray(e) ? e : [e], n = new Set(d.appliedFilters), r = !1;
-		for (let e of t) l.has(e) && !n.has(e) && (n.add(e), r = !0);
-		r && (f({
-			type: "ADD_FILTERS",
-			payload: t
-		}), c && c(_(n, d.filterValues)));
-	}, [
-		c,
-		d.appliedFilters,
-		d.filterValues,
-		l,
-		_
-	]), y = t((e) => {
-		let t = Array.isArray(e) ? e : [e], n = new Set(d.appliedFilters), r = !1;
-		for (let e of t) n.delete(e) && (r = !0);
-		if (r && (f({
-			type: "REMOVE_FILTERS",
-			payload: t
-		}), c)) {
-			let e = new Map(d.filterValues);
-			for (let n of t) e.delete(n);
-			c(_(n, e));
-		}
-	}, [
-		c,
-		d.appliedFilters,
-		d.filterValues,
-		_
-	]), b = t(() => {
-		d.appliedFilters.size > 0 && (f({ type: "CLEAR_FILTERS" }), c && c([]));
-	}, [c, d.appliedFilters.size]), x = t((e, t) => {
-		let n = d.filterValues.get(e), r = t == null, i = d.filterValues.has(e);
-		if (d.appliedFilters.has(e) && (r ? i : n !== t) && (f({
-			type: "SET_FILTER_VALUE",
-			payload: {
-				filterId: e,
-				value: t
-			}
-		}), c)) {
-			let n = new Map(d.filterValues);
-			r ? n.delete(e) : n.set(e, t), c(_(d.appliedFilters, n));
-		}
-	}, [
-		c,
-		d.appliedFilters,
-		d.filterValues,
-		_
-	]);
-	return {
-		status: g,
-		appliedFilters: p,
-		remainingFilters: m,
-		availableFilterDefs: h,
-		filterValues: d.filterValues,
-		addFilter: v,
-		removeFilter: y,
-		clearFilters: b,
-		setFilterValue: x
-	};
-}
-//#endregion
-export { a as useFilterToolbarState };

package/dist/esm/components/filter-toolbar/parts/AddFilter.js

@@ -1,82 +0,0 @@
-import { filterPopover as e } from "../../filter/parts/FilterPopover.js";
-import { AddFilterItem as t } from "./AddFilterItem.js";
-import { useRef as n, useState as r } from "react";
-import { uyTv as i } from "@payfit/unity-themes";
-import { Fragment as a, jsx as o, jsxs as s } from "react/jsx-runtime";
-import { FormattedMessage as c, useIntl as l } from "react-intl";
-import { Button as u } from "react-aria-components/Button";
-import { Icon as d } from "@payfit/unity-icons";
-import { ListBox as f } from "react-aria-components/ListBox";
-import { Popover as p } from "react-aria-components/Popover";
-import { Dialog as m } from "react-aria-components/Dialog";
-//#region src/components/filter-toolbar/parts/AddFilter.tsx
-var h = i({ slots: {
-	button: [
-		"uy:flex uy:group uy:items-center",
-		"uy:rounded-sm",
-		"uy:border uy:border-solid",
-		"uy:cursor-pointer uy:data-[disabled=true]:cursor-not-allowed",
-		"uy:w-fit uy:p-100 uy:pl-100 uy:pr-150",
-		"uy:typography-action",
-		"uy:border-border-form-enabled uy:bg-surface-form-enabled uy:text-content-form-enabled",
-		"uy:hover:border-border-form-hover uy:hover:bg-surface-form-hover",
-		"uy:data-[pressed=true]:border-border-form-pressed uy:data-[pressed=true]:bg-surface-form-pressed",
-		"uy:data-[disabled=true]:border-border-form-disabled uy:data-[disabled=true]:bg-surface-form-disabled uy:data-[disabled=true]:text-content-form-disabled",
-		"uy:focus-visible:outline-2 uy:focus-visible:outline-offset-2 uy:focus-visible:outline-utility-focus-ring"
-	],
-	icon: [
-		"uy:p-0.25",
-		"uy:text-content-neutral-low",
-		"uy:group-data-[status=active]:text-content-primary-enabled",
-		"uy:group-data-[disabled=true]:text-content-neutral-disabled"
-	],
-	listbox: ["uy:p-100"]
-} }), g = ({ availableFilterDefs: i, onSelectionChange: g, isDisabled: _ = !1, ...v }) => {
-	let y = l(), [b, x] = r(!1), S = n(null), { popover: C, dialog: w } = e(), { icon: T, button: E, listbox: D } = h();
-	return /* @__PURE__ */ s(a, { children: [/* @__PURE__ */ s(u, {
-		className: E(),
-		ref: S,
-		onPress: () => {
-			x(!0);
-		},
-		isDisabled: _,
-		...v,
-		children: [/* @__PURE__ */ o(d, {
-			src: "PlusOutlined",
-			role: "presentation",
-			size: 20,
-			className: T()
-		}), /* @__PURE__ */ o(c, {
-			id: "unity:component:filter-toolbar:add-filter:label",
-			defaultMessage: "Add filter"
-		})]
-	}), /* @__PURE__ */ o(p, {
-		className: C(),
-		triggerRef: S,
-		isOpen: b,
-		onOpenChange: x,
-		placement: "bottom start",
-		children: /* @__PURE__ */ o(m, {
-			className: w(),
-			"aria-label": y.formatMessage({
-				id: "unity:component:filter-toolbar:add-filter:popover:label",
-				defaultMessage: "Select a filter to add"
-			}),
-			children: /* @__PURE__ */ o(f, {
-				className: D(),
-				selectionMode: "single",
-				items: i,
-				onSelectionChange: (e) => {
-					g?.(e), x(!1);
-				},
-				children: (e) => /* @__PURE__ */ o(t, {
-					id: e.id,
-					children: e.label
-				})
-			})
-		})
-	})] });
-};
-g.displayName = "AddFilter";
-//#endregion
-export { g as AddFilter };

package/dist/esm/components/filter-toolbar/parts/AddFilterItem.js

@@ -1,20 +0,0 @@
-import { uyTv as e } from "@payfit/unity-themes";
-import { jsx as t } from "react/jsx-runtime";
-import { ListBoxItem as n } from "react-aria-components/ListBox";
-//#region src/components/filter-toolbar/parts/AddFilterItem.tsx
-var r = e({ base: [
-	"uy:flex uy:items-center uy:gap-100 uy:text-content-neutral uy:typography-body",
-	"uy:px-150 uy:py-100",
-	"uy:rounded-50 uy:cursor-pointer",
-	"uy:hover:bg-surface-neutral-hover",
-	"uy:active:bg-surface-neutral-pressed",
-	"uy:data-[focus-visible]:outline-2 uy:data-[focus-visible]:outline-utility-focus-ring uy:data-[focus-visible]:outline-offset-2"
-] }), i = ({ id: e, children: i, ...a }) => /* @__PURE__ */ t(n, {
-	className: r(),
-	id: e,
-	...a,
-	children: i
-});
-i.displayName = "AddFilterItem";
-//#endregion
-export { i as AddFilterItem, r as addFilterItem };

package/dist/esm/components/filter-toolbar/utils/filter-adapters.d.ts

@@ -1,107 +0,0 @@
-import { ColumnFiltersState } from '@tanstack/react-table';
-import { AppliedFilter } from '../FilterToolbar.types.js';
-/**
- * Adapters for converting FilterToolbar's AppliedFilter format to and from external formats.
- *
- * Use these adapters to integrate FilterToolbar with other libraries like Tanstack Table.
- * Each adapter provides bidirectional conversion methods.
- * @example
- * ```tsx
- * import { FilterAdapters } from '@payfit/unity-components'
- *
- * // Convert FilterToolbar filters to Tanstack Table format
- * const columnFilters = FilterAdapters.TanstackTable.toColumnFilters(appliedFilters)
- *
- * // Convert Tanstack Table filters back to FilterToolbar format
- * const appliedFilters = FilterAdapters.TanstackTable.fromColumnFilters(columnFilters)
- * ```
- */
-export declare const FilterAdapters: {
-    /**
-     * Adapter for Tanstack Table integration.
-     *
-     * Handles conversion between FilterToolbar's AppliedFilter format and
-     * Tanstack Table's ColumnFiltersState format.
-     * @example
-     * ```tsx
-     * import {
-     *   columnFilteringFeature,
-     *   createFilteredRowModel,
-     *   tableFeatures,
-     *   useTable,
-     * } from '@tanstack/react-table'
-     *
-     * const features = tableFeatures({
-     *   columnFilteringFeature,
-     *   filteredRowModel: createFilteredRowModel(),
-     * })
-     *
-     * const [appliedFilters, setAppliedFilters] = useState<AppliedFilter[]>([])
-     * const columnFilters = FilterAdapters.TanstackTable.toColumnFilters(appliedFilters)
-     *
-     * const table = useTable({
-     *   features,
-     *   data,
-     *   columns,
-     *   state: { columnFilters },
-     * })
-     *
-     * return (
-     *   <>
-     *     <FilterToolbar
-     *       filterDefs={filterDefs}
-     *       initialValue={appliedFilters}
-     *       onChange={setAppliedFilters}
-     *     />
-     *     <DataTable table={table} />
-     *   </>
-     * )
-     * ```
-     * @see {@link https://tanstack.com/table/latest/docs/guide/filters Tanstack Table Filters Documentation}
-     */
-    TanstackTable: {
-        /**
-         * Converts FilterToolbar's AppliedFilter format to Tanstack Table's ColumnFiltersState format.
-         *
-         * This method handles two key transformations:
-         * 1. Filters out empty filters (filters without values) so the table shows all results
-         * 2. Converts Set values to Arrays (React Aria uses Set, Tanstack Table uses Array)
-         * @param appliedFilters - Array of applied filters from FilterToolbar's onChange callback
-         * @returns Column filters compatible with Tanstack Table's state.columnFilters
-         * @remarks
-         * - Empty filters (undefined values or empty Sets) are excluded from the result
-         * - This ensures that adding a filter without selecting values doesn't hide all table rows
-         * - Set values are converted to Arrays for compatibility with Tanstack Table's filter functions
-         * @example
-         * ```tsx
-         * const columnFilters = FilterAdapters.TanstackTable.toColumnFilters([
-         *   { id: 'status', value: new Set(['active', 'pending']) },
-         *   { id: 'department', value: undefined }, // Will be filtered out
-         * ])
-         * // Result: [{ id: 'status', value: ['active', 'pending'] }]
-         * ```
-         */
-        toColumnFilters(appliedFilters: AppliedFilter[]): ColumnFiltersState;
-        /**
-         * Converts Tanstack Table's ColumnFiltersState format to FilterToolbar's AppliedFilter format.
-         *
-         * This is useful when you need to initialize FilterToolbar from existing table state,
-         * URL parameters, or server-side filter state.
-         * @param columnFilters - Column filters from Tanstack Table's state
-         * @returns Array of applied filters compatible with FilterToolbar's initialValue
-         * @remarks
-         * - Array values are converted to Sets for compatibility with React Aria's SelectList
-         * - In most cases, you should make FilterToolbar the source of truth and use toColumnFilters
-         *   to derive table state instead of syncing bidirectionally
-         * @example
-         * ```tsx
-         * // Initialize FilterToolbar from URL params
-         * const urlFilters = parseUrlToColumnFilters(searchParams)
-         * const appliedFilters = FilterAdapters.TanstackTable.fromColumnFilters(urlFilters)
-         *
-         * return <FilterToolbar initialValue={appliedFilters} />
-         * ```
-         */
-        fromColumnFilters(columnFilters: ColumnFiltersState): AppliedFilter[];
-    };
-};

package/dist/esm/components/filter-toolbar/utils/filter-adapters.js

@@ -1,17 +0,0 @@
-//#region src/components/filter-toolbar/utils/filter-adapters.ts
-var e = { TanstackTable: {
-	toColumnFilters(e) {
-		return e.filter((e) => e.value instanceof Set ? e.value.size > 0 : e.value !== void 0 && e.value !== null).map((e) => ({
-			id: e.id,
-			value: e.value instanceof Set ? Array.from(e.value) : e.value
-		}));
-	},
-	fromColumnFilters(e) {
-		return e.map((e) => ({
-			id: e.id,
-			value: Array.isArray(e.value) ? new Set(e.value) : e.value
-		}));
-	}
-} };
-//#endregion
-export { e as FilterAdapters };

package/dist/esm/components/filter-toolbar/utils/normalize-filter-value.js

@@ -1,13 +0,0 @@
-//#region src/components/filter-toolbar/utils/normalize-filter-value.ts
-function e(e) {
-	if (e != null) {
-		if (Array.isArray(e)) return e.map((e) => String(e));
-		if (typeof e == "object" && Symbol.iterator in e) return Array.from(e).map((e) => String(e));
-		if (e instanceof Date) return e.toISOString();
-		if (typeof e == "object") return JSON.stringify(e);
-		if (typeof e == "string") return e;
-		if (typeof e == "number" || typeof e == "boolean") return String(e);
-	}
-}
-//#endregion
-export { e as normalizeFilterValue };

package/dist/esm/components/flex/Flex.js

@@ -1,38 +0,0 @@
-import { flex as e } from "./Flex.variants.js";
-import { forwardRef as t, useMemo as n } from "react";
-import { jsx as r } from "react/jsx-runtime";
-//#region src/components/flex/Flex.tsx
-var i = t(({ asElement: t = "div", children: i, className: a, inline: o, direction: s, isReversed: c, wrap: l, gap: u, gapX: d, gapY: f, justify: p, align: m, alignContent: h, ...g }, _) => /* @__PURE__ */ r(t, {
-	ref: _,
-	className: n(() => e({
-		inline: o,
-		direction: s,
-		isReversed: c,
-		wrap: l,
-		gap: u,
-		gapX: d,
-		gapY: f,
-		justify: p,
-		align: m,
-		alignContent: h,
-		className: a
-	}), [
-		m,
-		h,
-		a,
-		s,
-		u,
-		d,
-		f,
-		o,
-		c,
-		p,
-		l
-	]),
-	...g,
-	children: i
-}));
-i.displayName = "Flex";
-var a = i;
-//#endregion
-export { i as Flex, a as Stack };