@povio/ui 3.4.0-rc.2 → 3.4.0-rc.22

package/dist/helpers/dynamicColumns.d.ts

@@ -1,44 +0,0 @@
-import { CellContext, ColumnDef, ColumnMeta } from '@tanstack/react-table';
-import { ReactNode } from 'react';
-import { FieldPath } from '../components/inputs/shared/form.binding';
-import { z } from 'zod';
-type NestedTypeFromKey<T, K extends string> = K extends keyof T ? T[K] : K extends `${infer First}.${infer Rest}` ? First extends keyof T ? NestedTypeFromKey<T[First], Rest> : never : never;
-type SchemaType<TSchema extends z.ZodObject<any>> = z.infer<TSchema>;
-type SchemaKey<TSchema extends z.ZodObject<any>> = keyof SchemaType<TSchema>;
-type NestedSchemaKey<TSchema extends z.ZodObject<any>> = FieldPath<SchemaType<TSchema>>;
-type SchemaValue<TSchema extends z.ZodObject<any>> = SchemaType<TSchema>[SchemaKey<TSchema>];
-type ColumnMetaType<TSchema extends z.ZodObject<any>> = ColumnMeta<SchemaType<TSchema>, SchemaValue<TSchema>>;
-type GetNestedValueType<TSchema extends z.ZodObject<any>, K extends string> = NestedTypeFromKey<SchemaType<TSchema>, K>;
-type NestedSchemaKeyOrString<TSchema extends z.ZodObject<any>> = NestedSchemaKey<TSchema> | (string & {});
-type DynamicColumnDef<TSchema extends z.ZodObject<any>, TValue = any> = Omit<ColumnDef<SchemaType<TSchema>, TValue>, "accessorKey" | "cell"> & {
-    cell?: ((props: CellContext<SchemaType<TSchema>, TValue>) => any) | NestedSchemaKey<TSchema>;
-};
-type ColumnsConfig<TSchema extends z.ZodObject<any>> = {
-    [K in NestedSchemaKey<TSchema>]?: DynamicColumnDef<TSchema, GetNestedValueType<TSchema, K>> | ((props: CellContext<SchemaType<TSchema>, GetNestedValueType<TSchema, K>>) => any) | NestedSchemaKey<TSchema> | boolean;
-};
-type CustomColumnDef<TSchema extends z.ZodObject<any>> = Omit<ColumnDef<SchemaType<TSchema>, any>, "accessorKey" | "cell"> & {
-    accessorKey?: NestedSchemaKeyOrString<TSchema>;
-    cell?: ((props: CellContext<SchemaType<TSchema>, any>) => any) | NestedSchemaKey<TSchema>;
-};
-type CustomColumnsConfig<TSchema extends z.ZodObject<any>> = Record<string, CustomColumnDef<TSchema> | ((props: CellContext<SchemaType<TSchema>, undefined>) => any) | NestedSchemaKey<TSchema>>;
-export interface DynamicColumnsOptions<TSchema extends z.ZodObject<any>> {
-    columns?: ColumnsConfig<TSchema>;
-    customColumns?: CustomColumnsConfig<TSchema>;
-    order?: NestedSchemaKeyOrString<TSchema>[];
-    sortable?: NestedSchemaKeyOrString<TSchema>[] | z.ZodEnum<any>;
-    disableFormatting?: NestedSchemaKeyOrString<TSchema>[];
-    emptyValue?: ReactNode;
-    namespace?: string;
-    overridePresetLocales?: boolean;
-    globalMeta?: Omit<ColumnMetaType<TSchema>, "sortKey">;
-    globalWrapper?: (children: ReactNode) => ReactNode;
-    includeAll?: boolean;
-}
-export declare const sortColumns: <TSchema extends z.ZodObject<any>>(columns: ColumnDef<SchemaType<TSchema>>[], orderKeys?: DynamicColumnsOptions<TSchema>["order"]) => ColumnDef<SchemaType<TSchema>>[];
-interface DynamicColumnsParams<TSchema extends z.ZodObject<any>> {
-    schema: TSchema;
-    preset?: ColumnDef<SchemaType<TSchema>>[];
-    options: DynamicColumnsOptions<TSchema>;
-}
-export declare const dynamicColumns: <TSchema extends z.ZodObject<any>>({ schema, preset, options, }: DynamicColumnsParams<TSchema>) => ColumnDef<SchemaType<TSchema>>[];
-export {};

package/dist/helpers/dynamicColumns.js

@@ -1,275 +0,0 @@
-import { IntlUtils } from "../utils/intl.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 = {
-	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";
-	}
-};
-var 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) => {
-	if (typeof value === "function" || typeof value === "string") return { cell: value };
-	if (typeof value === "boolean" || value === void 0) return {};
-	return value;
-};
-var convertEntriesToColumnDefs = (entries) => {
-	return entries.map(([key, value]) => [key, configValueToColumnDef(value)]);
-};
-var customConfigValueToColumnDef = (value) => {
-	if (typeof value === "string") return {
-		accessorKey: value,
-		cell: value
-	};
-	if (typeof value === "function") return { cell: value };
-	return value;
-};
-var convertCustomEntriesToColumnDefs = (entries) => {
-	return entries.map(([key, value]) => [key, customConfigValueToColumnDef(value)]);
-};
-var excludeEntries = (entries) => {
-	return entries.filter(([, value]) => value !== false && value !== void 0);
-};
-var 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
-	];
-};
-var 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);
-};
-var getNestedValue = (obj, path) => {
-	return path.split(".").reduce((current, key) => {
-		return current && typeof current === "object" ? current[key] : void 0;
-	}, obj);
-};
-var 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;
-};
-var 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;
-	};
-};
-var 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 localeKey = `${options.namespace ?? DEFAULT_NAMESPACE}.${key}`;
-	if (i18next.exists(localeKey)) return String(i18next.t(localeKey));
-	return StringUtils.capitalize(key);
-};
-var 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
-		};
-	});
-};
-var 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
-	};
-};
-var 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
-	};
-};
-var 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];
-};
-var 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 = new Set([...usedColumnsIds, ...usedCustomColumnsIds]);
-	return presetColumns.filter((column) => {
-		if (!column.id) return true;
-		return !usedIds.has(column.id);
-	});
-};
-var 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;
-};
-var 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) => {
-	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 { 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 presetKeys = presetColumns.map((column) => column.id).filter((id) => id !== void 0);
-	const schemaKeys = includeAll ? getAllSchemaKeys(schema) : [];
-	const allKeys = 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");
-};
-var 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
-	];
-	return sortColumns(options.includeAll ? addMissingSchemaFields(schema, mergedColumns, options, sortableKeys) : mergedColumns, options.order);
-};
-//#endregion
-export { dynamicColumns };

package/dist/helpers/dynamicInputs.d.ts

@@ -1,86 +0,0 @@
-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';
-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";
-};
-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";
-}>;
-interface DynamicInputDefBase<TProps> {
-    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 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;
-} & 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 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>>;
-interface DynamicInputsObjectOptions<TSchema extends z.ZodObject<any>> {
-    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>;
-}
-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 {};

package/dist/helpers/dynamicInputs.js

@@ -1,193 +0,0 @@
-import { StringUtils } from "../utils/string.utils.js";
-import { ZodUtils } from "../utils/zod.utils.js";
-import { z } from "zod";
-import i18next from "i18next";
-//#region src/helpers/dynamicInputs.ts
-var defaultComponentTypes = {
-	datetime: "datePicker",
-	dateRange: "dateRangePicker",
-	boolean: "toggle",
-	number: "numberInput",
-	enum: "select",
-	string: "textInput",
-	email: "textInput",
-	object: "unknown",
-	array: "select",
-	uuid: "select",
-	unknown: "unknown"
-};
-var ZOD_TYPE_COMPONENT_TYPE = [
-	[z.ZodBoolean, defaultComponentTypes.boolean],
-	[z.ZodNumber, defaultComponentTypes.number],
-	[z.ZodEnum, defaultComponentTypes.enum],
-	[z.ZodISODateTime, defaultComponentTypes.datetime],
-	[z.ZodString, defaultComponentTypes.string],
-	[z.ZodEmail, defaultComponentTypes.email],
-	[z.ZodObject, defaultComponentTypes.object],
-	[z.ZodArray, defaultComponentTypes.array],
-	[z.ZodUUID, defaultComponentTypes.uuid]
-];
-var DEFAULT_NAMESPACE = "dynamicInputs";
-var sortInputDefs = (inputDefs, orderKeys) => {
-	if (!orderKeys) return inputDefs;
-	return inputDefs.sort((a, b) => {
-		const orderMap = new Map(orderKeys.map((key, index) => [key, index]));
-		const orderA = orderMap.get(a.name);
-		const orderB = orderMap.get(b.name);
-		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;
-	});
-};
-var excludeEntries = (entries) => {
-	return entries.filter(([, value]) => value !== false && value !== void 0);
-};
-var inputConfigToObjectDefinition = (value) => {
-	if (typeof value === "object") return value;
-	if (typeof value === "function") return { render: value };
-	return {};
-};
-var convertInputsConfigToObjectDefinitions = (entries) => {
-	return entries.map(([key, value]) => {
-		return [key, inputConfigToObjectDefinition(value)];
-	});
-};
-var 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 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,
-		label: StringUtils.capitalize(value)
-	}));
-	return [];
-};
-var getDefaultSelectionMode = (keyType) => {
-	return keyType instanceof z.ZodArray ? "multiple" : "single";
-};
-var getDefaultProps = (componentType, keyType) => {
-	const props = {};
-	const unwrappedType = ZodUtils.unwrapZodType(keyType);
-	if ([
-		"select",
-		"autocomplete",
-		"segment"
-	].includes(componentType)) props.items = getDefaultSelectionItems(unwrappedType);
-	if ([
-		"select",
-		"querySelect",
-		"autocomplete",
-		"queryAutocomplete",
-		"segment"
-	].includes(componentType)) props.selectionMode = getDefaultSelectionMode(unwrappedType);
-	return props;
-};
-var getLabelAndPlaceholder = (value, options, schemaKey) => {
-	const namespace = options.namespace ?? DEFAULT_NAMESPACE;
-	const stringKey = String(schemaKey);
-	let { label, placeholder } = value;
-	if (!label) {
-		const key = `${namespace}.${stringKey}.label`;
-		const translation = i18next.exists(key) ? i18next.t(key) : null;
-		label = typeof translation === "string" ? translation : StringUtils.capitalize(stringKey);
-	}
-	if (!placeholder) {
-		const key = `${namespace}.${stringKey}.placeholder`;
-		const translation = i18next.exists(key) ? i18next.t(key) : null;
-		placeholder = typeof translation === "string" ? translation : void 0;
-	}
-	return {
-		label,
-		placeholder
-	};
-};
-var overridePresetLabelsAndPlaceholders = (presetInputDefs, options) => {
-	const namespace = options.namespace ?? DEFAULT_NAMESPACE;
-	return presetInputDefs.map((inputDef) => {
-		const labelName = String(inputDef.name);
-		const labelKey = `${namespace}.${labelName}.label`;
-		const placeholderKey = `${namespace}.${labelName}.placeholder`;
-		const labelTranslation = i18next.exists(labelKey) ? i18next.t(labelKey) : null;
-		const placeholderTranslation = i18next.exists(placeholderKey) ? i18next.t(placeholderKey) : null;
-		return {
-			...inputDef,
-			label: typeof labelTranslation === "string" ? labelTranslation : inputDef.label,
-			placeholder: typeof placeholderTranslation === "string" ? placeholderTranslation : inputDef.placeholder
-		};
-	});
-};
-var 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 { 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([
-		...inputKeys,
-		...presetKeys,
-		...schemaKeys
-	]);
-	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 name = String(schemaKey);
-	const { label, placeholder } = getLabelAndPlaceholder(value, options, schemaKey);
-	const inputWrapper = value.inputWrapper ?? options.globalInputWrapper;
-	if ("render" in value) return {
-		name,
-		label,
-		placeholder,
-		render: value.render
-	};
-	const schemaKeyType = schema.shape[schemaKey];
-	const componentType = "type" in value ? value.type : getDefaultInputComponentType(schemaKeyType);
-	const props = {
-		...componentType ? getDefaultProps(componentType, schemaKeyType) : {},
-		...options.globalProps,
-		...value.props
-	};
-	return {
-		type: componentType === "unknown" ? null : componentType,
-		name,
-		label,
-		placeholder,
-		inputWrapper,
-		props
-	};
-};
-var 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) => {
-		return populateInputDef(schema, field, {}, options);
-	});
-	return [...existingInputDefs, ...additionalInputDefs];
-};
-function dynamicInputs({ schema: rawSchema, preset = [], options }) {
-	const schema = ZodUtils.unwrapToZodObject(rawSchema);
-	const objectOptions = options;
-	validateParams(schema, preset, objectOptions);
-	let entries = Object.entries(objectOptions.inputs ?? {});
-	entries = excludeEntries(entries);
-	const inputDefs = convertInputsConfigToObjectDefinitions(entries).map(([key, value]) => {
-		return populateInputDef(schema, key, value, objectOptions);
-	});
-	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);
-}
-//#endregion
-export { dynamicInputs, getDefaultInputComponentType };

package/dist/hooks/useAutosave.d.ts

@@ -1,10 +0,0 @@
-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;
-}
-export declare function useAutosave<TFieldValues extends Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown>({ form, delay, enabled, trigger, onSave, onSaveSuccess, }: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>): void;