@povio/ui 3.4.0-rc.15 → 3.4.0-rc.17

package/dist/helpers/dynamicColumns.js

@@ -1,12 +1,12 @@
 import { IntlUtils } from "../utils/intl.utils.js";
+import { DateUtils } from "../utils/date.utils.js";
 import { StringUtils } from "../utils/string.utils.js";
 import { ZodUtils } from "../utils/zod.utils.js";
-import { DateUtils } from "../utils/date.utils.js";
 import { z } from "zod";
 import i18next from "i18next";
 //#region src/helpers/dynamicColumns.ts
-var DEFAULT_NAMESPACE = "dynamicColumns";
-var FORMAT_MAP = {
+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))}`;
@@ -20,22 +20,22 @@ var FORMAT_MAP = {
 		return value ? "Yes" : "No";
 	}
 };
-var ZOD_TYPE_FORMAT_MAP = [
+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]
 ];
-var configValueToColumnDef = (value) => {
+const configValueToColumnDef = (value) => {
 	if (typeof value === "function" || typeof value === "string") return { cell: value };
 	if (typeof value === "boolean" || value === void 0) return {};
 	return value;
 };
-var convertEntriesToColumnDefs = (entries) => {
+const convertEntriesToColumnDefs = (entries) => {
 	return entries.map(([key, value]) => [key, configValueToColumnDef(value)]);
 };
-var customConfigValueToColumnDef = (value) => {
+const customConfigValueToColumnDef = (value) => {
 	if (typeof value === "string") return {
 		accessorKey: value,
 		cell: value
@@ -43,13 +43,13 @@ var customConfigValueToColumnDef = (value) => {
 	if (typeof value === "function") return { cell: value };
 	return value;
 };
-var convertCustomEntriesToColumnDefs = (entries) => {
+const convertCustomEntriesToColumnDefs = (entries) => {
 	return entries.map(([key, value]) => [key, customConfigValueToColumnDef(value)]);
 };
-var excludeEntries = (entries) => {
+const excludeEntries = (entries) => {
 	return entries.filter(([, value]) => value !== false && value !== void 0);
 };
-var sortColumns = (columns, orderKeys) => {
+const sortColumns = (columns, orderKeys) => {
 	if (!orderKeys) return columns;
 	const wildcardIndex = orderKeys.indexOf("*");
 	if (wildcardIndex === -1) return columns.sort((columnA, columnB) => {
@@ -84,7 +84,7 @@ var sortColumns = (columns, orderKeys) => {
 		...after
 	];
 };
-var formatValueByType = (value, schemaType) => {
+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);
@@ -97,12 +97,12 @@ var formatValueByType = (value, schemaType) => {
 	if (formatFunction) return formatFunction(value);
 	return String(value);
 };
-var getNestedValue = (obj, path) => {
+const getNestedValue = (obj, path) => {
 	return path.split(".").reduce((current, key) => {
 		return current && typeof current === "object" ? current[key] : void 0;
 	}, obj);
 };
-var getKeyType = (schema, key) => {
+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]];
@@ -112,7 +112,7 @@ var getKeyType = (schema, key) => {
 	}
 	return currentType;
 };
-var getCellFunction = (schema, schemaKey, columnDef, options) => {
+const getCellFunction = (schema, schemaKey, columnDef, options) => {
 	const { cell } = columnDef;
 	if (typeof cell === "function") return cell;
 	return ({ data }) => {
@@ -125,17 +125,17 @@ var getCellFunction = (schema, schemaKey, columnDef, options) => {
 		return finalValue;
 	};
 };
-var normalizeSortable = (sortable) => {
+const normalizeSortable = (sortable) => {
 	if (!sortable) return;
 	if (Array.isArray(sortable)) return sortable;
 	if (sortable instanceof z.ZodEnum) return Object.values(sortable.enum);
 };
-var getDefaultColumnHeader = (key, options) => {
+const getDefaultColumnHeader = (key, options) => {
 	const localeKey = `${options.namespace ?? DEFAULT_NAMESPACE}.${key}`;
 	if (i18next.exists(localeKey)) return String(i18next.t(localeKey));
 	return StringUtils.capitalize(key);
 };
-var overridePresetColumnsHeaders = (presetColumns, options) => {
+const overridePresetColumnsHeaders = (presetColumns, options) => {
 	const namespace = options.namespace ?? DEFAULT_NAMESPACE;
 	return presetColumns.map((columnDef) => {
 		const localeKey = `${namespace}.${columnDef.id}`;
@@ -146,7 +146,7 @@ var overridePresetColumnsHeaders = (presetColumns, options) => {
 		};
 	});
 };
-var populateColumnDef = (schema, key, columnDef, options, sortableKeys) => {
+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);
@@ -165,7 +165,7 @@ var populateColumnDef = (schema, key, columnDef, options, sortableKeys) => {
 		cell
 	};
 };
-var populateCustomColumnDef = (schema, key, columnDef, options, sortableKeys) => {
+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;
@@ -185,7 +185,7 @@ var populateCustomColumnDef = (schema, key, columnDef, options, sortableKeys) =>
 		cell
 	};
 };
-var addMissingSchemaFields = (schema, existingColumns, options, sortableKeys) => {
+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) => {
@@ -193,7 +193,7 @@ var addMissingSchemaFields = (schema, existingColumns, options, sortableKeys) =>
 	});
 	return [...existingColumns, ...additionalColumns];
 };
-var removeOverriddenPresetColumns = (presetColumns, options) => {
+const removeOverriddenPresetColumns = (presetColumns, options) => {
 	if (presetColumns.length === 0) return presetColumns;
 	const usedColumnsIds = Object.entries(options.columns ?? {}).map(([key, value]) => {
 		return value.id ?? key;
@@ -201,13 +201,13 @@ var removeOverriddenPresetColumns = (presetColumns, options) => {
 	const usedCustomColumnsIds = Object.entries(options.customColumns ?? {}).map(([key, value]) => {
 		return value.id ?? key;
 	});
-	const usedIds = new Set([...usedColumnsIds, ...usedCustomColumnsIds]);
+	const usedIds = /* @__PURE__ */ new Set([...usedColumnsIds, ...usedCustomColumnsIds]);
 	return presetColumns.filter((column) => {
 		if (!column.id) return true;
 		return !usedIds.has(column.id);
 	});
 };
-var getAllSchemaKeys = (schema) => {
+const getAllSchemaKeys = (schema) => {
 	const keys = [];
 	const { shape } = schema;
 	const traverse = (obj, prefix = "") => {
@@ -220,24 +220,24 @@ var getAllSchemaKeys = (schema) => {
 	traverse(shape);
 	return keys;
 };
-var validateCustomColumnKeys = (schema, customColumnKeys) => {
+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.`);
 };
-var validateOptionKeyArray = (usedKeys, optionKeys, optionName) => {
+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(", ")}].`);
 };
-var validateParams = (schema, presetColumns, options) => {
+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 = new Set([...columnKeys, ...customColumnKeys]);
+	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 = new Set([
+	const allKeys = /* @__PURE__ */ new Set([
 		...presetKeys,
 		...usedKeys,
 		...schemaKeys,
@@ -248,7 +248,7 @@ var validateParams = (schema, presetColumns, options) => {
 	validateOptionKeyArray(allKeys, order, "order");
 	validateOptionKeyArray(usedKeys, disableFormatting, "disableFormatting");
 };
-var dynamicColumns = ({ schema, preset = [], options }) => {
+const dynamicColumns = ({ schema, preset = [], options }) => {
 	validateParams(schema, preset, options);
 	const sortableKeys = normalizeSortable(options.sortable);
 	let entries = Object.entries(options.columns ?? {});
@@ -269,7 +269,8 @@ var dynamicColumns = ({ schema, preset = [], options }) => {
 		...columns,
 		...customColumns
 	];
-	return sortColumns(options.includeAll ? addMissingSchemaFields(schema, mergedColumns, options, sortableKeys) : mergedColumns, options.order);
+	const allColumns = options.includeAll ? addMissingSchemaFields(schema, mergedColumns, options, sortableKeys) : mergedColumns;
+	return sortColumns(allColumns, options.order);
 };
 //#endregion
-export { dynamicColumns };
+export { dynamicColumns, sortColumns };

package/dist/helpers/dynamicInputs.d.ts

@@ -1,86 +1,78 @@
-import { ReactElement } from 'react';
-import { FormInstance } from '../components/inputs/shared/form.binding';
-import { z } from 'zod';
-import { InputComponentProps, InputComponentType, InputDef, InputDefBaseProps, InputWrapperType } from '../components/inputs/Inputs/InputItem';
-import { ZodUtils } from '../utils/zod.utils';
+import { FormInstance } from "../components/inputs/shared/form.binding.js";
+import { InputComponentProps, InputComponentType, InputDef, InputDefBaseProps, InputWrapperType } from "../components/inputs/Inputs/InputItem.js";
+import { ZodUtils } from "../utils/zod.utils.js";
+import { ReactElement } from "react";
+import { z } from "zod";
+//#region src/helpers/dynamicInputs.d.ts
 declare const defaultComponentTypes: {
-    readonly datetime: "datePicker";
-    readonly dateRange: "dateRangePicker";
-    readonly boolean: "toggle";
-    readonly number: "numberInput";
-    readonly enum: "select";
-    readonly string: "textInput";
-    readonly email: "textInput";
-    readonly object: "unknown";
-    readonly array: "select";
-    readonly uuid: "select";
-    readonly unknown: "unknown";
+  readonly datetime: "datePicker";
+  readonly dateRange: "dateRangePicker";
+  readonly boolean: "toggle";
+  readonly number: "numberInput";
+  readonly enum: "select";
+  readonly string: "textInput";
+  readonly email: "textInput";
+  readonly object: "unknown";
+  readonly array: "select";
+  readonly uuid: "select";
+  readonly unknown: "unknown";
 };
-export type DefaultComponentType<TZodType extends z.ZodType> = ZodUtils.ZodTypeSwitch<TZodType, typeof defaultComponentTypes>;
-export type AllowedComponentType<TZodType extends z.ZodType> = ZodUtils.ZodTypeSwitch<TZodType, {
-    datetime: "datePicker" | "dateTimePicker" | "timePicker";
-    dateRange: "dateRangePicker";
-    boolean: "toggle" | "checkbox";
-    number: "numberInput" | "slider" | "select" | "querySelect" | "autocomplete" | "queryAutocomplete" | "segment";
-    enum: "select" | "querySelect" | "autocomplete" | "segment";
-    string: "textInput" | "passwordInput" | "textArea" | "select" | "querySelect" | "autocomplete" | "queryAutocomplete" | "segment";
-    email: "textInput";
-    array: "select" | "querySelect" | "autocomplete" | "queryAutocomplete" | "segment";
-    object: InputComponentType;
-    unknown: InputComponentType;
-    uuid: "select" | "querySelect" | "autocomplete" | "queryAutocomplete" | "segment";
+type DefaultComponentType<TZodType extends z.ZodType> = ZodUtils.ZodTypeSwitch<TZodType, typeof defaultComponentTypes>;
+type AllowedComponentType<TZodType extends z.ZodType> = ZodUtils.ZodTypeSwitch<TZodType, {
+  datetime: "datePicker" | "dateTimePicker" | "timePicker";
+  dateRange: "dateRangePicker";
+  boolean: "toggle" | "checkbox";
+  number: "numberInput" | "slider" | "select" | "querySelect" | "autocomplete" | "queryAutocomplete" | "segment";
+  enum: "select" | "querySelect" | "autocomplete" | "segment";
+  string: "textInput" | "passwordInput" | "textArea" | "select" | "querySelect" | "autocomplete" | "queryAutocomplete" | "segment";
+  email: "textInput";
+  array: "select" | "querySelect" | "autocomplete" | "queryAutocomplete" | "segment";
+  object: InputComponentType;
+  unknown: InputComponentType;
+  uuid: "select" | "querySelect" | "autocomplete" | "queryAutocomplete" | "segment";
 }>;
 interface DynamicInputDefBase<TProps> {
-    label?: string;
-    placeholder?: string;
-    props?: Partial<TProps>;
-    inputWrapper?: InputWrapperType;
+  label?: string;
+  placeholder?: string;
+  props?: Partial<TProps>;
+  inputWrapper?: InputWrapperType;
 }
-type ConfigInputDef<TSchema extends z.ZodObject<any>, K extends keyof z.infer<TSchema>> = {
-    [T in AllowedComponentType<TSchema["shape"][K]>]: {
-        type: T;
-    } & DynamicInputDefBase<InputDefBaseProps<InputComponentProps<T>>>;
-}[AllowedComponentType<TSchema["shape"][K]>];
-type UnknownInputDef<TSchema extends z.ZodObject<any>, K extends keyof z.infer<TSchema>> = {
-    [T in DefaultComponentType<TSchema["shape"][K]>]: {
-        type?: never;
-    } & DynamicInputDefBase<InputDefBaseProps<InputComponentProps<T>>>;
-}[DefaultComponentType<TSchema["shape"][K]>];
+type ConfigInputDef<TSchema extends z.ZodObject<any>, K extends keyof z.infer<TSchema>> = { [T in AllowedComponentType<TSchema["shape"][K]>]: {
+  type: T;
+} & DynamicInputDefBase<InputDefBaseProps<InputComponentProps<T>>>; }[AllowedComponentType<TSchema["shape"][K]>];
+type UnknownInputDef<TSchema extends z.ZodObject<any>, K extends keyof z.infer<TSchema>> = { [T in DefaultComponentType<TSchema["shape"][K]>]: {
+  type?: never;
+} & DynamicInputDefBase<InputDefBaseProps<InputComponentProps<T>>>; }[DefaultComponentType<TSchema["shape"][K]>];
 type RenderInputDef<TSchema extends z.ZodObject<any>, K extends keyof z.infer<TSchema>> = {
-    render: (field: {
-        form: FormInstance<z.infer<TSchema>>;
-        name: K;
-    }, form: FormInstance<z.infer<TSchema>>) => ReactElement;
+  render: (field: {
+    form: FormInstance<z.infer<TSchema>>;
+    name: K;
+  }, form: FormInstance<z.infer<TSchema>>) => ReactElement;
 } & DynamicInputDefBase<Record<string, never>>;
 type DynamicInputDef<TSchema extends z.ZodObject<any>, K extends keyof z.infer<TSchema>> = ConfigInputDef<TSchema, K> | UnknownInputDef<TSchema, K> | RenderInputDef<TSchema, K>;
-type InputsConfig<TSchema extends z.ZodObject<any>> = {
-    [K in keyof z.infer<TSchema>]?: DynamicInputDef<TSchema, K> | ((field: {
-        form: FormInstance<z.infer<TSchema>>;
-        name: K;
-    }, form: FormInstance<z.infer<TSchema>>) => ReactElement) | boolean;
-};
-type GlobalProps = {
-    [T in Exclude<InputComponentType, "unknown">]: InputDefBaseProps<InputComponentProps<T>>;
-}[Exclude<InputComponentType, "unknown">];
+type InputsConfig<TSchema extends z.ZodObject<any>> = { [K in keyof z.infer<TSchema>]?: DynamicInputDef<TSchema, K> | ((field: {
+  form: FormInstance<z.infer<TSchema>>;
+  name: K;
+}, form: FormInstance<z.infer<TSchema>>) => ReactElement) | boolean; };
+type GlobalProps = { [T in Exclude<InputComponentType, "unknown">]: InputDefBaseProps<InputComponentProps<T>>; }[Exclude<InputComponentType, "unknown">];
 type SchemaKeyOrString<TSchema extends z.ZodObject<any>> = keyof z.infer<TSchema> | (string & {});
-export type DynamicInputsObjectSchema<TSchema extends z.ZodType> = TSchema extends z.ZodObject<any> ? TSchema : Extract<ZodUtils.UnwrapZod<TSchema>, z.ZodObject<any>>;
+type DynamicInputsObjectSchema<TSchema extends z.ZodType> = TSchema extends z.ZodObject<any> ? TSchema : Extract<ZodUtils.UnwrapZod<TSchema>, z.ZodObject<any>>;
 interface DynamicInputsObjectOptions<TSchema extends z.ZodObject<any>> {
-    inputs?: InputsConfig<TSchema>;
-    order?: SchemaKeyOrString<TSchema>[];
-    globalProps?: Partial<GlobalProps>;
-    globalInputWrapper?: InputWrapperType;
-    namespace?: string;
-    overridePresetLocales?: boolean;
-    includeAll?: boolean;
+  inputs?: InputsConfig<TSchema>;
+  order?: SchemaKeyOrString<TSchema>[];
+  globalProps?: Partial<GlobalProps>;
+  globalInputWrapper?: InputWrapperType;
+  namespace?: string;
+  overridePresetLocales?: boolean;
+  includeAll?: boolean;
 }
-export type DynamicInputsOptions<TSchema extends z.ZodType> = DynamicInputsObjectOptions<DynamicInputsObjectSchema<TSchema>>;
-export interface DynamicInputsParams<TSchema extends z.ZodType> {
-    schema: TSchema;
-    preset?: InputDef<z.infer<DynamicInputsObjectSchema<TSchema>>>[];
-    options: DynamicInputsOptions<TSchema>;
+type DynamicInputsOptions<TSchema extends z.ZodType> = DynamicInputsObjectOptions<DynamicInputsObjectSchema<TSchema>>;
+interface DynamicInputsParams<TSchema extends z.ZodType> {
+  schema: TSchema;
+  preset?: InputDef<z.infer<DynamicInputsObjectSchema<TSchema>>>[];
+  options: DynamicInputsOptions<TSchema>;
 }
-export declare const getDefaultInputComponentType: (schemaType: z.core.$ZodType) => InputComponentType;
-export declare const getDefaultSelectionMode: (keyType: z.core.$ZodType) => "single" | "multiple";
-export declare function dynamicInputs<TSchema extends z.ZodObject<any>>(params: DynamicInputsParams<TSchema>): InputDef<z.infer<TSchema>>[];
-export declare function dynamicInputs<TRawSchema extends z.ZodType>(params: DynamicInputsParams<TRawSchema>): InputDef<z.infer<DynamicInputsObjectSchema<TRawSchema>>>[];
-export {};
+declare function dynamicInputs<TSchema extends z.ZodObject<any>>(params: DynamicInputsParams<TSchema>): InputDef<z.infer<TSchema>>[];
+declare function dynamicInputs<TRawSchema extends z.ZodType>(params: DynamicInputsParams<TRawSchema>): InputDef<z.infer<DynamicInputsObjectSchema<TRawSchema>>>[];
+//#endregion
+export { AllowedComponentType, DefaultComponentType, DynamicInputsObjectSchema, DynamicInputsOptions, DynamicInputsParams, dynamicInputs };

package/dist/helpers/dynamicInputs.js

@@ -3,7 +3,7 @@ import { ZodUtils } from "../utils/zod.utils.js";
 import { z } from "zod";
 import i18next from "i18next";
 //#region src/helpers/dynamicInputs.ts
-var defaultComponentTypes = {
+const defaultComponentTypes = {
 	datetime: "datePicker",
 	dateRange: "dateRangePicker",
 	boolean: "toggle",
@@ -16,7 +16,7 @@ var defaultComponentTypes = {
 	uuid: "select",
 	unknown: "unknown"
 };
-var ZOD_TYPE_COMPONENT_TYPE = [
+const ZOD_TYPE_COMPONENT_TYPE = [
 	[z.ZodBoolean, defaultComponentTypes.boolean],
 	[z.ZodNumber, defaultComponentTypes.number],
 	[z.ZodEnum, defaultComponentTypes.enum],
@@ -27,8 +27,8 @@ var ZOD_TYPE_COMPONENT_TYPE = [
 	[z.ZodArray, defaultComponentTypes.array],
 	[z.ZodUUID, defaultComponentTypes.uuid]
 ];
-var DEFAULT_NAMESPACE = "dynamicInputs";
-var sortInputDefs = (inputDefs, orderKeys) => {
+const DEFAULT_NAMESPACE = "dynamicInputs";
+const sortInputDefs = (inputDefs, orderKeys) => {
 	if (!orderKeys) return inputDefs;
 	return inputDefs.sort((a, b) => {
 		const orderMap = new Map(orderKeys.map((key, index) => [key, index]));
@@ -40,27 +40,27 @@ var sortInputDefs = (inputDefs, orderKeys) => {
 		return 0;
 	});
 };
-var excludeEntries = (entries) => {
+const excludeEntries = (entries) => {
 	return entries.filter(([, value]) => value !== false && value !== void 0);
 };
-var inputConfigToObjectDefinition = (value) => {
+const inputConfigToObjectDefinition = (value) => {
 	if (typeof value === "object") return value;
 	if (typeof value === "function") return { render: value };
 	return {};
 };
-var convertInputsConfigToObjectDefinitions = (entries) => {
+const convertInputsConfigToObjectDefinitions = (entries) => {
 	return entries.map(([key, value]) => {
 		return [key, inputConfigToObjectDefinition(value)];
 	});
 };
-var getDefaultInputComponentType = (schemaType) => {
+const getDefaultInputComponentType = (schemaType) => {
 	if (ZodUtils.isDateRange(schemaType)) return defaultComponentTypes.dateRange;
 	const unwrappedType = ZodUtils.unwrapZodType(schemaType);
 	const componentType = ZOD_TYPE_COMPONENT_TYPE.find(([zodType]) => unwrappedType instanceof zodType)?.[1];
 	if (componentType) return componentType;
 	return defaultComponentTypes.unknown;
 };
-var getDefaultSelectionItems = (keyType) => {
+const getDefaultSelectionItems = (keyType) => {
 	const unwrappedType = ZodUtils.unwrapZodType(keyType instanceof z.ZodArray ? keyType.element : keyType);
 	if (unwrappedType instanceof z.ZodEnum) return Object.values(unwrappedType.options).filter((value) => typeof value === "string").map((value) => ({
 		id: value,
@@ -68,10 +68,10 @@ var getDefaultSelectionItems = (keyType) => {
 	}));
 	return [];
 };
-var getDefaultSelectionMode = (keyType) => {
+const getDefaultSelectionMode = (keyType) => {
 	return keyType instanceof z.ZodArray ? "multiple" : "single";
 };
-var getDefaultProps = (componentType, keyType) => {
+const getDefaultProps = (componentType, keyType) => {
 	const props = {};
 	const unwrappedType = ZodUtils.unwrapZodType(keyType);
 	if ([
@@ -88,7 +88,7 @@ var getDefaultProps = (componentType, keyType) => {
 	].includes(componentType)) props.selectionMode = getDefaultSelectionMode(unwrappedType);
 	return props;
 };
-var getLabelAndPlaceholder = (value, options, schemaKey) => {
+const getLabelAndPlaceholder = (value, options, schemaKey) => {
 	const namespace = options.namespace ?? DEFAULT_NAMESPACE;
 	const stringKey = String(schemaKey);
 	let { label, placeholder } = value;
@@ -107,7 +107,7 @@ var getLabelAndPlaceholder = (value, options, schemaKey) => {
 		placeholder
 	};
 };
-var overridePresetLabelsAndPlaceholders = (presetInputDefs, options) => {
+const overridePresetLabelsAndPlaceholders = (presetInputDefs, options) => {
 	const namespace = options.namespace ?? DEFAULT_NAMESPACE;
 	return presetInputDefs.map((inputDef) => {
 		const labelName = String(inputDef.name);
@@ -122,18 +122,18 @@ var overridePresetLabelsAndPlaceholders = (presetInputDefs, options) => {
 		};
 	});
 };
-var removeOverriddenPresetInputs = (presetInputs, options) => {
+const removeOverriddenPresetInputs = (presetInputs, options) => {
 	if (presetInputs.length === 0) return presetInputs;
 	const usedKeys = new Set(Object.keys(options.inputs ?? {}).map(String));
 	return presetInputs.filter((input) => !usedKeys.has(String(input.name)));
 };
-var validateParams = (schema, presetInputs, options) => {
+const validateParams = (schema, presetInputs, options) => {
 	const { inputs, order, includeAll } = options;
 	if (!order) return;
 	const inputKeys = Object.keys(inputs ?? {});
 	const presetKeys = presetInputs.map((input) => input.name).filter((name) => name !== void 0);
 	const schemaKeys = includeAll ? Object.keys(schema.shape) : [];
-	const allInputKeys = new Set([
+	const allInputKeys = /* @__PURE__ */ new Set([
 		...inputKeys,
 		...presetKeys,
 		...schemaKeys
@@ -141,7 +141,7 @@ var validateParams = (schema, presetInputs, options) => {
 	const unnecessaryOrderKeys = order.filter((key) => !allInputKeys.has(key));
 	if (unnecessaryOrderKeys.length > 0) throw new Error(`Found unnecessary keys in "order": [${unnecessaryOrderKeys.join(", ")}]. These keys are not found in any of the input definitions.\nAll defined input keys are: [${Array.from(allInputKeys).join(", ")}].\nIn the case of a preset input definition, the key is the name attribute.`);
 };
-var populateInputDef = (schema, schemaKey, value, options) => {
+const populateInputDef = (schema, schemaKey, value, options) => {
 	const name = String(schemaKey);
 	const { label, placeholder } = getLabelAndPlaceholder(value, options, schemaKey);
 	const inputWrapper = value.inputWrapper ?? options.globalInputWrapper;
@@ -167,7 +167,7 @@ var populateInputDef = (schema, schemaKey, value, options) => {
 		props
 	};
 };
-var addMissingSchemaFields = (schema, existingInputDefs, options) => {
+const addMissingSchemaFields = (schema, existingInputDefs, options) => {
 	const schemaFields = Object.keys(schema.shape);
 	const definedFields = new Set(existingInputDefs.map((def) => def.name));
 	const additionalInputDefs = schemaFields.filter((field) => !definedFields.has(field)).map((field) => {
@@ -187,7 +187,8 @@ function dynamicInputs({ schema: rawSchema, preset = [], options }) {
 	let presetInputDefs = removeOverriddenPresetInputs(preset, objectOptions);
 	if (objectOptions.overridePresetLocales) presetInputDefs = overridePresetLabelsAndPlaceholders(presetInputDefs, objectOptions);
 	const mergedInputDefs = [...presetInputDefs, ...inputDefs];
-	return sortInputDefs(objectOptions.includeAll ? addMissingSchemaFields(schema, mergedInputDefs, objectOptions) : mergedInputDefs, objectOptions.order);
+	const allInputDefs = objectOptions.includeAll ? addMissingSchemaFields(schema, mergedInputDefs, objectOptions) : mergedInputDefs;
+	return sortInputDefs(allInputDefs, objectOptions.order);
 }
 //#endregion
-export { dynamicInputs, getDefaultInputComponentType };
+export { dynamicInputs, getDefaultInputComponentType, getDefaultSelectionMode };

package/dist/hooks/useAutosave.d.ts

@@ -1,10 +1,13 @@
-import { UIForm } from './useForm';
-export interface UseAutosaveProps<TFieldValues extends Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown> {
-    form: UIForm<TFieldValues>;
-    delay?: number;
-    enabled?: boolean;
-    trigger?: "change" | "blur";
-    onSave: (data: Partial<TTransformedValues>) => Promise<TResponse>;
-    onSaveSuccess?: () => void;
+import { UIForm } from "./useForm.js";
+//#region src/hooks/useAutosave.d.ts
+interface UseAutosaveProps<TFieldValues extends Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown> {
+  form: UIForm<TFieldValues>;
+  delay?: number;
+  enabled?: boolean;
+  trigger?: "change" | "blur";
+  onSave: (data: Partial<TTransformedValues>) => Promise<TResponse>;
+  onSaveSuccess?: () => void;
 }
-export declare function useAutosave<TFieldValues extends Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown>({ form, delay, enabled, trigger, onSave, onSaveSuccess, }: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>): void;
+declare function useAutosave<TFieldValues extends Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown>({ form, delay, enabled, trigger, onSave, onSaveSuccess }: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>): void;
+//#endregion
+export { UseAutosaveProps, useAutosave };

package/dist/hooks/useAutosave.js

@@ -12,7 +12,7 @@ function diffLeftOnly(left, right) {
 	}, {});
 	return ObjectUtils.isEmpty(result) ? void 0 : result;
 }
-var snapshot = (value) => structuredClone(value);
+const snapshot = (value) => structuredClone(value);
 function pickChangedValues(source, changes) {
 	if (!ObjectUtils.isObject(changes) || Array.isArray(changes)) return source;
 	return Object.entries(changes).reduce((result, [key, value]) => {

package/dist/hooks/useBreakpoint.d.ts

@@ -1,3 +1,5 @@
+//#region src/hooks/useBreakpoint.d.ts
 type Breakpoint = "sm" | "md" | "lg" | "xl";
-export declare function useBreakpoint(breakpointKey: Breakpoint): boolean;
-export {};
+declare function useBreakpoint(breakpointKey: Breakpoint): boolean;
+//#endregion
+export { Breakpoint, useBreakpoint };

package/dist/hooks/useBreakpoint.js

@@ -1,7 +1,8 @@
+import { UIConfig } from "../config/uiConfig.context.js";
 import { c } from "react/compiler-runtime";
-import { useMediaQuery } from "react-responsive";
+import { useSyncExternalStore } from "react";
 //#region src/hooks/useBreakpoint.ts
-var breakpoints = null;
+let breakpoints = null;
 function getBreakpoints() {
 	if (breakpoints) return breakpoints;
 	if (typeof window === "undefined") return {
@@ -22,7 +23,8 @@ function getBreakpoints() {
 	return breakpoints;
 }
 function useBreakpoint(breakpointKey) {
-	const $ = c(3);
+	const $ = c(10);
+	const ui = UIConfig.useConfig();
 	let t0;
 	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
 		t0 = getBreakpoints();
@@ -30,14 +32,39 @@ function useBreakpoint(breakpointKey) {
 	} else t0 = $[0];
 	const breakpoints = t0;
 	if (!breakpoints) throw new Error("Tailwind config is missing theme.screens");
-	const t1 = `(min-width: ${breakpoints[breakpointKey]})`;
+	const query = `(min-width: ${breakpoints[breakpointKey]})`;
+	let t1;
+	if ($[1] !== query) {
+		t1 = typeof window === "undefined" ? null : window.matchMedia(query);
+		$[1] = query;
+		$[2] = t1;
+	} else t1 = $[2];
+	const mediaQuery = t1;
 	let t2;
-	if ($[1] !== t1) {
-		t2 = { query: t1 };
-		$[1] = t1;
-		$[2] = t2;
-	} else t2 = $[2];
-	return useMediaQuery(t2);
+	if ($[3] !== mediaQuery) {
+		t2 = (onStoreChange) => {
+			mediaQuery?.addEventListener("change", onStoreChange);
+			return () => mediaQuery?.removeEventListener("change", onStoreChange);
+		};
+		$[3] = mediaQuery;
+		$[4] = t2;
+	} else t2 = $[4];
+	const subscribe = t2;
+	let t3;
+	if ($[5] !== mediaQuery?.matches) {
+		t3 = () => mediaQuery?.matches ?? false;
+		$[5] = mediaQuery?.matches;
+		$[6] = t3;
+	} else t3 = $[6];
+	const getSnapshot = t3;
+	let t4;
+	if ($[7] !== breakpointKey || $[8] !== ui.responsive.ssrMatches) {
+		t4 = () => ui.responsive.ssrMatches[breakpointKey];
+		$[7] = breakpointKey;
+		$[8] = ui.responsive.ssrMatches;
+		$[9] = t4;
+	} else t4 = $[9];
+	return useSyncExternalStore(subscribe, getSnapshot, t4);
 }
 //#endregion
 export { useBreakpoint };

package/dist/hooks/useDebounceCallback.d.ts

@@ -1,6 +1,9 @@
-export declare function useDebounceCallback<T extends (...args: any[]) => any>(callback?: T, { delay }?: {
-    delay?: number;
+//#region src/hooks/useDebounceCallback.d.ts
+declare function useDebounceCallback<T extends (...args: any[]) => any>(callback?: T, { delay }?: {
+  delay?: number;
 }): {
-    callback: (...args: Parameters<T>) => void;
-    isDebouncing: boolean;
+  callback: (...args: Parameters<T>) => void;
+  isDebouncing: boolean;
 };
+//#endregion
+export { useDebounceCallback };