@fuf-stack/megapixels 0.8.0 → 0.9.1

package/dist/Filter-nSuQco2t.js

@@ -0,0 +1,751 @@
+import createDebug from "debug";
+import { tv, variantsToClassNames } from "@fuf-stack/pixel-utils";
+import Form from "@fuf-stack/uniform/Form";
+import { Suspense, createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { any, array, boolean, object, refineArray, string, stringToJSON, veto } from "@fuf-stack/veto";
+import Label from "@fuf-stack/pixels/Label";
+import { useFormContext } from "@fuf-stack/uniform/hooks/useFormContext";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { FaSliders } from "react-icons/fa6";
+import Menu from "@fuf-stack/pixels/Menu";
+import { PiSlidersHorizontalBold } from "react-icons/pi";
+import Button from "@fuf-stack/pixels/Button";
+import Modal from "@fuf-stack/pixels/Modal";
+import SubmitButton from "@fuf-stack/uniform/SubmitButton";
+import { FaSearch } from "react-icons/fa";
+import { motion } from "@fuf-stack/pixel-motion";
+import Input from "@fuf-stack/uniform/Input";
+import Switch from "@fuf-stack/uniform/Switch";
+import Checkboxes from "@fuf-stack/uniform/Checkboxes";
+
+//#region src/Filter/hooks/useFilterValidation.ts
+/**
+* useFilterValidation
+*
+* Builds a composite validation schema from all provided filter definitions
+* under "filter" and optionally includes a "search" string field.
+* Memoized by inputs.
+*/
+const useFilterValidation = (filters$1, withSearch) => {
+	return useMemo(() => {
+		let filterSchema = {};
+		filters$1.forEach((f) => {
+			filterSchema = {
+				...filterSchema,
+				[f.name]: f.validation(f.config)
+			};
+		});
+		return veto({
+			filter: stringToJSON().pipe(object(filterSchema)).or(object(filterSchema)).optional().nullable().transform((val) => {
+				return val ?? void 0;
+			}),
+			...withSearch ? { search: string({ min: 0 }).nullable().optional() } : {}
+		});
+	}, [filters$1, withSearch]);
+};
+
+//#endregion
+//#region src/Filter/Subcomponents/FiltersContext.tsx
+/**
+* FiltersContext
+*
+* Central state for the filter UI with a clear boundary:
+* - The parent component controls committed filter values (via value/onChange)
+* - The form acts as an edit buffer (used by the modal)
+*
+* Design:
+* - activeFilters/unusedFilters are names-only and derived from the controlled
+*   form state
+* - getFilterInstanceByName gives access to the concrete registry entry to
+*   retrieve the correct Form/Display components
+* - add seeds defaults in the form and opens the modal
+* - remove un-registers the form field; if the removed filter is currently
+*   open in the modal, the modal is closed without rollback
+* - on a new successful form submit (Apply), the modal closes without rollback
+*   by subscribing to ex-forms submit state
+*/
+const FiltersContext = createContext(void 0);
+const FiltersContextProvider = ({ children, config: config$2 }) => {
+	const { formState, getFieldState, setValue, triggerSubmit, unregister, watch } = useFormContext();
+	/**
+	* currentModalFilter
+	*
+	* Single source of truth for the filter edit modal and its rollback snapshot.
+	* - name: which filter's modal is currently open (null when closed)
+	* - hadValue/previousValue: snapshot of the controlled value taken when the
+	*   modal is opened; used to restore state if the user cancels/closes without
+	*   applying.
+	*
+	* Lifecycle semantics:
+	* - showFilterModal(name): capture snapshot (current controlled value) and open
+	*   the modal for that filter.
+	* - closeFilterModal(): if a snapshot exists, roll back un-applied edits by
+	*   restoring the previous value (setValue) or removing the field (unregister)
+	*   when it did not exist before; then clear currentModalFilter.
+	* - On successful submit (Apply): close and clear currentModalFilter WITHOUT rollback
+	*   so edits remain committed.
+	* - removeFilter(name): unregisters the field; when removing the filter that is
+	*   currently open, close the modal WITHOUT rollback (since removal is explicit).
+	*/
+	const [currentModalFilter, setCurrentModalFilter] = useState(null);
+	const filterValue = watch("filter", {});
+	/**
+	* getFilterFormFieldName
+	*
+	* Returns the fully-qualified field path for a given filter name,
+	* e.g., `${filterUrlParam}.status`.
+	*/
+	const getFilterFormFieldName = useCallback((name) => {
+		return `filter.${name}`;
+	}, []);
+	/**
+	* getFilterValueByName
+	*
+	* Returns the committed value for a filter from the controlled state.
+	*/
+	const getFilterValueByName = useCallback((name) => {
+		return filterValue[name];
+	}, [filterValue]);
+	/** Open the filter edit modal for the given filter name. */
+	const showFilterModal = useCallback((name) => {
+		const prev = getFilterValueByName(name);
+		setCurrentModalFilter({
+			name,
+			hadValue: typeof prev !== "undefined",
+			previousValue: prev
+		});
+	}, [getFilterValueByName]);
+	/** Close the filter edit modal. Rollback un-applied edits to controlled state. */
+	const closeFilterModal = useCallback(() => {
+		if (currentModalFilter?.name) {
+			const fieldName = getFilterFormFieldName(currentModalFilter.name);
+			if (currentModalFilter.hadValue) setValue(fieldName, currentModalFilter.previousValue);
+			else unregister(fieldName);
+		}
+		setCurrentModalFilter(null);
+	}, [
+		getFilterFormFieldName,
+		currentModalFilter,
+		setValue,
+		unregister
+	]);
+	/**
+	* Auto-close on submit success
+	*
+	* Close the modal only on new successful submissions. We track the last
+	* submitCount and only react when it changes AND the form reports a
+	* successful submit. This prevents closing when `isSubmitSuccessful` remains
+	* true without a new submit event.
+	*/
+	const lastSubmitCountRef = useRef(0);
+	useEffect(() => {
+		if (formState.submitCount !== lastSubmitCountRef.current && formState.isSubmitSuccessful) setCurrentModalFilter(null);
+		lastSubmitCountRef.current = formState.submitCount;
+	}, [
+		formState.submitCount,
+		formState.isSubmitSuccessful,
+		setCurrentModalFilter
+	]);
+	/**
+	* activeFilters
+	*
+	* Filter names derived from the controlled form state. A filter is considered
+	* active when a field exists at `filter.<name>`. Newly added filters become
+	* active immediately (seeded default), and will be rolled back on cancel.
+	*/
+	const activeFilters = useMemo(() => {
+		return config$2.filter((f) => {
+			return Object.hasOwn(filterValue ?? {}, f.name);
+		}).map((f) => {
+			return f.name;
+		});
+	}, [config$2, filterValue]);
+	/**
+	* unusedFilters
+	*
+	* Complement of activeFilters (names without a corresponding `filter.<name>`
+	* field in the controlled form state).
+	*/
+	const unusedFilters = useMemo(() => {
+		return config$2.filter((f) => {
+			return !Object.hasOwn(filterValue ?? {}, f.name);
+		}).map((f) => {
+			return f.name;
+		});
+	}, [config$2, filterValue]);
+	/**
+	* getRegistryFilterByName
+	*
+	* Looks up the concrete registry entry for a filter by name, enabling access
+	* to typed Form/Display components and other registry-level metadata.
+	*/
+	const getFilterInstanceByName = useCallback((name) => {
+		return config$2.find((f) => {
+			return f.name === name;
+		});
+	}, [config$2]);
+	/**
+	* addFilter
+	*
+	* Seeds the filter with its registry default value inside the form and opens
+	* the modal for immediate editing. No URL writes happen here.
+	*/
+	const addFilter = useCallback((name) => {
+		const inst = getFilterInstanceByName(name);
+		showFilterModal(name);
+		setValue(getFilterFormFieldName(name), inst.defaultValue);
+	}, [
+		getFilterFormFieldName,
+		getFilterInstanceByName,
+		setValue,
+		showFilterModal
+	]);
+	/**
+	* removeFilter
+	*
+	* Unregisters the filter field from the form. This immediately removes the
+	* filter from the active list since derived state watches the form. It
+	* closes the modal without rollback if the removed filter is currently open.
+	*/
+	const removeFilter = useCallback((name) => {
+		unregister(getFilterFormFieldName(name));
+		if (currentModalFilter?.name === name) setCurrentModalFilter(null);
+		triggerSubmit();
+	}, [
+		getFilterFormFieldName,
+		currentModalFilter,
+		setCurrentModalFilter,
+		triggerSubmit,
+		unregister
+	]);
+	/**
+	* hasError
+	*
+	* Helper that checks the ex-forms field state for a specific filter and
+	* reports whether the field is currently invalid.
+	*/
+	const hasError = useCallback((name) => {
+		return getFieldState(getFilterFormFieldName(name)).invalid;
+	}, [getFieldState, getFilterFormFieldName]);
+	const contextValue = useMemo(() => {
+		return {
+			activeFilters,
+			addFilter,
+			closeFilterModal,
+			getFilterFormFieldName,
+			getFilterValueByName,
+			getFilterInstanceByName,
+			hasError,
+			modalFilterName: currentModalFilter?.name,
+			removeFilter,
+			showFilterModal,
+			unusedFilters
+		};
+	}, [
+		activeFilters,
+		addFilter,
+		closeFilterModal,
+		getFilterFormFieldName,
+		getFilterValueByName,
+		getFilterInstanceByName,
+		hasError,
+		currentModalFilter,
+		removeFilter,
+		showFilterModal,
+		unusedFilters
+	]);
+	return /* @__PURE__ */ jsx(FiltersContext.Provider, {
+		value: contextValue,
+		children
+	});
+};
+/**
+* useFilters
+*
+* Convenience hook to consume the FiltersContext. Throws a descriptive error
+* when used outside of a FiltersContextProvider to make integration mistakes
+* obvious during development.
+*/
+const useFilters = () => {
+	const ctx = useContext(FiltersContext);
+	if (!ctx) throw new Error("useFilters must be used within FiltersContextProvider");
+	return ctx;
+};
+
+//#endregion
+//#region src/Filter/Subcomponents/ActiveFilters.tsx
+const ActiveFilters = ({ className = void 0 }) => {
+	const { activeFilters, getFilterValueByName, getFilterInstanceByName, hasError, removeFilter, showFilterModal } = useFilters();
+	return /* @__PURE__ */ jsx(Fragment, { children: activeFilters.map((name) => {
+		const instance = getFilterInstanceByName(name);
+		const value = getFilterValueByName(name);
+		const DisplayComponent = instance.components.Display;
+		return /* @__PURE__ */ jsx("button", {
+			"aria-label": `Open ${name} filter`,
+			type: "button",
+			onClick: () => {
+				showFilterModal(name);
+			},
+			children: /* @__PURE__ */ jsxs(Label, {
+				className,
+				color: hasError(name) ? "danger" : "primary",
+				variant: "flat",
+				onClose: () => {
+					removeFilter(name);
+				},
+				children: [instance.icon, /* @__PURE__ */ jsx(DisplayComponent, {
+					config: instance.config,
+					value
+				})]
+			})
+		}, name);
+	}) });
+};
+var ActiveFilters_default = ActiveFilters;
+
+//#endregion
+//#region src/Filter/Subcomponents/AddFilterMenu.tsx
+/**
+* AddFilterMenu
+*
+* Renders a menu trigger that opens a list of addable filters. Selecting an
+* item triggers the parent to seed a default value and open the modal.
+*/
+const AddFilterMenu = ({ classNames = {} }) => {
+	const { unusedFilters, addFilter, getFilterInstanceByName } = useFilters();
+	const menuItems = unusedFilters.map((name) => {
+		const instance = getFilterInstanceByName(name);
+		const label = instance.config?.text ?? name;
+		return {
+			key: name,
+			icon: instance.icon,
+			label,
+			onClick: () => {
+				addFilter(name);
+			}
+		};
+	});
+	return /* @__PURE__ */ jsxs(Menu, {
+		isDisabled: !menuItems.length,
+		items: menuItems,
+		placement: "bottom-start",
+		className: {
+			item: classNames.addFilterMenuItem,
+			trigger: classNames.addFilterMenuButton
+		},
+		triggerButtonProps: {
+			"aria-label": "Add Filter",
+			"data-testid": "add_filter_button",
+			disableRipple: true,
+			size: "sm",
+			variant: "bordered"
+		},
+		children: [/* @__PURE__ */ jsx(FaSliders, {}), "Filter"]
+	});
+};
+var AddFilterMenu_default = AddFilterMenu;
+
+//#endregion
+//#region src/Filter/Subcomponents/FilterModal.tsx
+const FilterModal = ({ classNames = {} }) => {
+	const { closeFilterModal, getFilterFormFieldName, getFilterInstanceByName, modalFilterName, removeFilter } = useFilters();
+	if (!modalFilterName) return null;
+	const instance = getFilterInstanceByName(modalFilterName);
+	const config$2 = instance.config;
+	const FormComponent = instance.components.Form;
+	return /* @__PURE__ */ jsx(Modal, {
+		isOpen: true,
+		onClose: closeFilterModal,
+		className: {
+			body: classNames.body,
+			footer: classNames.footer,
+			header: classNames.header
+		},
+		footer: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Button, {
+			ariaLabel: "Remove filter",
+			color: "danger",
+			testId: "remove_filter_button",
+			variant: "flat",
+			onClick: () => {
+				removeFilter(modalFilterName);
+			},
+			children: "Remove"
+		}), /* @__PURE__ */ jsx(SubmitButton, {
+			ariaLabel: "Apply filter",
+			testId: "apply_filter_button",
+			children: "Apply Filter"
+		})] }),
+		header: /* @__PURE__ */ jsxs(Fragment, { children: [instance.icon ?? /* @__PURE__ */ jsx(PiSlidersHorizontalBold, {}), /* @__PURE__ */ jsx("div", { children: `${config$2?.text ?? modalFilterName} Filter` })] }),
+		children: /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(FormComponent, {
+			config: config$2,
+			fieldName: getFilterFormFieldName(modalFilterName)
+		}) })
+	});
+};
+var FilterModal_default = FilterModal;
+
+//#endregion
+//#region src/Filter/Subcomponents/SearchInput.tsx
+/**
+* SearchInput
+*
+* By default renders only a search button. When clicked, the text input animates in
+* and a trailing submit button is shown.
+*/
+const SearchInput = ({ classNames = {}, config: config$2 }) => {
+	const { formState, setFocus, triggerSubmit } = useFormContext();
+	const isInitiallyVisible = !!formState?.defaultValues?.search;
+	const [isVisible, setIsVisible] = useState(isInitiallyVisible);
+	const placeholder = typeof config$2 === "object" ? config$2.placeholder : void 0;
+	return /* @__PURE__ */ jsxs("div", {
+		className: classNames.searchWrapper,
+		children: [!isVisible && /* @__PURE__ */ jsx(Button, {
+			ariaLabel: "Show search input",
+			className: classNames.searchShowButton,
+			icon: /* @__PURE__ */ jsx(FaSearch, {}),
+			size: "sm",
+			testId: "show_search_input_button",
+			variant: "bordered",
+			onClick: () => {
+				setIsVisible(true);
+			}
+		}), isVisible ? /* @__PURE__ */ jsxs(motion.div, {
+			animate: { opacity: 1 },
+			className: classNames.searchMotionDiv,
+			initial: !isInitiallyVisible ? { opacity: .5 } : false,
+			onAnimationComplete: () => {
+				if (!isInitiallyVisible) setFocus("search");
+			},
+			transition: {
+				duration: .3,
+				ease: "circOut"
+			},
+			children: [/* @__PURE__ */ jsx(Input, {
+				clearable: true,
+				debounceDelay: 0,
+				name: "search",
+				placeholder,
+				size: "sm",
+				className: {
+					input: classNames.searchInput,
+					inputWrapper: classNames.searchInputWrapper
+				},
+				onClear: () => {
+					triggerSubmit();
+				}
+			}), /* @__PURE__ */ jsx(SubmitButton, {
+				ariaLabel: "Submit search",
+				children: null,
+				className: classNames.searchSubmitButton,
+				color: "primary",
+				icon: /* @__PURE__ */ jsx(FaSearch, {}),
+				size: "sm",
+				testId: "submit_search_button"
+			})]
+		}, "search-input") : null]
+	});
+};
+var SearchInput_default = SearchInput;
+
+//#endregion
+//#region src/Filter/Filter.tsx
+const debug = createDebug("megapixels:Filter");
+const filterVariants = tv({ slots: {
+	base: "flex flex-auto flex-col",
+	addFilterMenuButton: "",
+	addFilterMenuItem: "",
+	activeFilterLabel: "h-8 cursor-pointer rounded-md dark:text-foreground",
+	filterModalBody: "",
+	filterModalHeader: "flex items-center gap-3 text-default-700",
+	filterModalFooter: "justify-between",
+	form: "mb-3 flex flex-wrap gap-3",
+	searchInput: "",
+	searchInputWrapper: "",
+	searchMotionDiv: "flex w-72 gap-2",
+	searchShowButton: "",
+	searchSubmitButton: "",
+	searchWrapper: "flex items-center"
+} });
+/**
+* Renders the filter UI bound to a single ex-forms `Form`.
+* The form is the source of truth during user interaction; the committed
+* state is controlled by the parent via `values`/`onChange`.
+*/
+const Filter = ({ children = void 0, className = void 0, config: config$2, formName = "filterComponentForm", onChange, values }) => {
+	const handleSubmit = (nextValues) => {
+		debug("handleSubmit", { nextValues });
+		onChange(nextValues);
+	};
+	const validation = useFilterValidation(config$2.filters, Boolean(config$2.search));
+	const { data: valuesValidated, errors, success } = validation.validate(values);
+	const classNames = variantsToClassNames(filterVariants(), className, "base");
+	debug("render", {
+		props: {
+			config: config$2,
+			values
+		},
+		validation: {
+			errors,
+			success,
+			valuesValidated
+		}
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		className: classNames.base,
+		children: [/* @__PURE__ */ jsxs(Form, {
+			className: classNames.form,
+			debug: { disable: true },
+			initialValues: valuesValidated ?? {},
+			name: formName,
+			onSubmit: handleSubmit,
+			validation,
+			children: [config$2.search ? /* @__PURE__ */ jsx(SearchInput_default, {
+				config: config$2.search,
+				classNames: {
+					searchInput: classNames.searchInput,
+					searchInputWrapper: classNames.searchInputWrapper,
+					searchMotionDiv: classNames.searchMotionDiv,
+					searchShowButton: classNames.searchShowButton,
+					searchSubmitButton: classNames.searchSubmitButton,
+					searchWrapper: classNames.searchWrapper
+				}
+			}) : null, /* @__PURE__ */ jsxs(FiltersContextProvider, {
+				config: config$2.filters,
+				children: [
+					/* @__PURE__ */ jsx(ActiveFilters_default, { className: classNames.activeFilterLabel }),
+					/* @__PURE__ */ jsx(AddFilterMenu_default, { classNames: {
+						addFilterMenuButton: classNames.addFilterMenuButton,
+						addFilterMenuItem: classNames.addFilterMenuItem
+					} }),
+					/* @__PURE__ */ jsx(FilterModal_default, { classNames: {
+						body: classNames.filterModalBody,
+						footer: classNames.filterModalFooter,
+						header: classNames.filterModalHeader
+					} })
+				]
+			})]
+		}), children?.(valuesValidated ?? {})]
+	});
+};
+var Filter_default = Filter;
+
+//#endregion
+//#region src/Filter/filters/createFilter.ts
+/**
+* createFilter
+*
+* Builds a filter factory from a static FilterDefinition. The returned factory
+* accepts a usage descriptor (name/icon and optional partial config) and
+* produces a concrete FilterInstance with:
+* - merged config (shallow: definition.defaults.config overlaid by overrides)
+* - Form/Display components
+* - validate function (forwarded from the definition)
+* - defaultValue (forwarded from the definition)
+* - name and icon for UI integration
+*
+* @typeParam Config - Configuration object shape for the filter
+* @typeParam Value  - Runtime value type for the filter
+* @param definition - Static description of the filter (components, defaults, validate)
+* @returns FilterFactory that creates FilterInstance<Config, Value>
+*/
+const createFilter = (definition) => {
+	return ({ name, icon, config: config$2 }) => {
+		return {
+			components: definition.components,
+			config: {
+				...definition.defaults.config,
+				...config$2 ?? {}
+			},
+			defaultValue: definition.defaults.value,
+			icon,
+			name,
+			validation: definition.validation
+		};
+	};
+};
+var createFilter_default = createFilter;
+
+//#endregion
+//#region src/Filter/filters/boolean/Display.tsx
+/**
+* Read-only presentation for the boolean filter.
+* Displays human-readable text based on the current boolean `value`
+* and the provided `config` strings.
+*/
+const Display$1 = ({ value, config: { text, textPrefix, textNoWord } }) => {
+	if (typeof value === "boolean") return /* @__PURE__ */ jsx(Fragment, { children: `${value ? textPrefix : `${textPrefix} ${textNoWord ?? "no"}`} ${text}` });
+	return /* @__PURE__ */ jsx(Fragment, { children: `${text}...` });
+};
+var Display_default$1 = Display$1;
+
+//#endregion
+//#region src/Filter/filters/boolean/Form.tsx
+/**
+* Renders the form control for the boolean filter.
+* Uses a `Switch` to toggle the boolean value and composes
+* the label from the provided `config` and `fieldName`.
+*/
+const Form$2 = ({ fieldName, config: { text, textPrefix } }) => {
+	return /* @__PURE__ */ jsx(Switch, {
+		label: `${textPrefix} ${text}`,
+		name: fieldName
+	});
+};
+var Form_default$1 = Form$2;
+
+//#endregion
+//#region src/Filter/filters/boolean/schema.ts
+/** configuration of the filter */
+const config$1 = object({
+	text: string(),
+	textPrefix: string().optional(),
+	textNoWord: string().optional()
+});
+/** validate the filter value */
+const validate$1 = (_config) => {
+	return boolean().optional();
+};
+
+//#endregion
+//#region src/Filter/filters/boolean/boolean.ts
+/**
+* Boolean filter definition for the Filter system.
+* Provides Display and Form components, default value/config, and validation.
+*
+* Defaults:
+* - value: true
+* - config: { text: 'Active', textPrefix: 'is', textNoWord: 'no' }
+*
+* @see Display
+* @see Form
+* @see validate
+*/
+const boolean$1 = createFilter_default({
+	components: {
+		Display: Display_default$1,
+		Form: Form_default$1
+	},
+	defaults: {
+		value: true,
+		config: {
+			text: "Active",
+			textPrefix: "is",
+			textNoWord: "no"
+		}
+	},
+	validation: validate$1
+});
+
+//#endregion
+//#region src/Filter/filters/checkboxes/Display.tsx
+/**
+* Read-only presentation for the checkboxes filter.
+* Resolves and displays selected option labels based on `value` and `config`.
+* Supports string, ReactNode, and function labels (mode: 'display').
+*/
+const Display = ({ value, config: { text, options } }) => {
+	if (value && value.length > 0) return /* @__PURE__ */ jsxs("span", {
+		className: "flex items-center gap-1",
+		children: [
+			text,
+			" is",
+			value.map((val) => {
+				const label = options.find((op) => {
+					return op.value === val;
+				})?.label ?? val;
+				return /* @__PURE__ */ jsx("span", { children: typeof label === "function" ? label("display") : label }, val);
+			})
+		]
+	});
+	return `${text} is ...`;
+};
+var Display_default = Display;
+
+//#endregion
+//#region src/Filter/filters/checkboxes/Form.tsx
+/**
+* Renders the form control for the checkboxes filter.
+* Uses a `Checkboxes` to select multiple options.
+* Resolves function labels with 'form' mode.
+*/
+const Form$1 = ({ fieldName, config: config$2 }) => {
+	return /* @__PURE__ */ jsx(Checkboxes, {
+		name: fieldName,
+		options: config$2.options.map((option) => {
+			return {
+				...option,
+				label: typeof option.label === "function" ? option.label("form") : option.label
+			};
+		})
+	});
+};
+var Form_default = Form$1;
+
+//#endregion
+//#region src/Filter/filters/checkboxes/schema.ts
+/** configuration of the filter */
+const config = object({
+	text: string(),
+	options: array(object({
+		label: any(),
+		value: string()
+	}))
+});
+/** validate the filter value */
+const validate = (cfg) => {
+	return refineArray(array(string()).optional())({
+		unique: true,
+		custom: (values, ctx) => {
+			if (!cfg) return;
+			values.forEach((value) => {
+				if (!cfg.options.find((option) => {
+					return option?.value === value;
+				})) ctx.addIssue({
+					code: "custom",
+					message: `Invalid value: ${value}`
+				});
+			});
+		}
+	});
+};
+
+//#endregion
+//#region src/Filter/filters/checkboxes/checkboxes.ts
+/**
+* Checkboxes filter definition for the Filter system.
+* Provides Display and Form components, default value/config, and validation.
+*
+* Defaults:
+* - value: []
+* - config: { text: 'Options', options: [] }
+*
+* @see Display
+* @see Form
+* @see validate
+*/
+const checkboxes = createFilter_default({
+	components: {
+		Display: Display_default,
+		Form: Form_default
+	},
+	defaults: {
+		value: [],
+		config: {
+			text: "Options",
+			options: []
+		}
+	},
+	validation: validate
+});
+
+//#endregion
+//#region src/Filter/index.ts
+const filters = {
+	boolean: boolean$1,
+	checkboxes
+};
+var Filter_default$1 = Filter_default;
+
+//#endregion
+export { filterVariants as i, filters as n, createFilter_default as r, Filter_default$1 as t };
+//# sourceMappingURL=Filter-nSuQco2t.js.map