@povio/ui 2.1.14 → 2.1.15

package/dist/dynamicColumns.js

@@ -0,0 +1,272 @@
+import { StringUtils } from "./string.utils.js";
+import { ZodUtils } from "./zod.utils.js";
+import { DateUtils } from "./date.utils.js";
+import { z } from "zod";
+import i18next from "i18next";
+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) => value.toLocaleString(i18next.language),
+	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);
+};
+const sortColumns = (columns, orderKeys) => {
+	if (!orderKeys) return columns;
+	const wildcardIndex = orderKeys.indexOf("*");
+	if (wildcardIndex === -1) return columns.sort((columnA, columnB) => {
+		const idA = columnA.id;
+		const idB = columnB.id;
+		const orderMap = new Map(orderKeys.map((key, index) => [String(key), index]));
+		const orderA = orderMap.get(String(idA));
+		const orderB = orderMap.get(String(idB));
+		if (orderA !== void 0 && orderB !== void 0) return orderA - orderB;
+		if (orderA !== void 0 && orderB === void 0) return -1;
+		if (orderA === void 0 && orderB !== void 0) return 1;
+		return 0;
+	});
+	const beforeWildcard = orderKeys.slice(0, wildcardIndex);
+	const afterWildcard = orderKeys.slice(wildcardIndex + 1);
+	const beforeMap = new Map(beforeWildcard.map((key, index) => [String(key), index]));
+	const afterMap = new Map(afterWildcard.map((key, index) => [String(key), index]));
+	const before = [];
+	const middle = [];
+	const after = [];
+	columns.forEach((column) => {
+		const id = String(column.id);
+		if (beforeMap.has(id)) before.push(column);
+		else if (afterMap.has(id)) after.push(column);
+		else middle.push(column);
+	});
+	before.sort((a, b) => beforeMap.get(String(a.id)) - beforeMap.get(String(b.id)));
+	after.sort((a, b) => afterMap.get(String(a.id)) - afterMap.get(String(b.id)));
+	return [
+		...before,
+		...middle,
+		...after
+	];
+};
+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");
+};
+const dynamicColumns = ({ schema, preset = [], options }) => {
+	validateParams(schema, preset, options);
+	const sortableKeys = normalizeSortable(options.sortable);
+	let entries = Object.entries(options.columns ?? {});
+	entries = excludeEntries(entries);
+	entries = convertEntriesToColumnDefs(entries);
+	const columns = entries.map(([key, value]) => {
+		return populateColumnDef(schema, key, value, options, sortableKeys);
+	});
+	let customEntries = Object.entries(options.customColumns ?? {});
+	customEntries = convertCustomEntriesToColumnDefs(customEntries);
+	const customColumns = customEntries.map(([key, value]) => {
+		return populateCustomColumnDef(schema, key, value, options, sortableKeys);
+	});
+	let presetColumns = removeOverriddenPresetColumns(preset, options);
+	if (options.overridePresetLocales) presetColumns = overridePresetColumnsHeaders(presetColumns, options);
+	const mergedColumns = [
+		...presetColumns,
+		...columns,
+		...customColumns
+	];
+	return sortColumns(options.includeAll ? addMissingSchemaFields(schema, mergedColumns, options, sortableKeys) : mergedColumns, options.order);
+};
+export { dynamicColumns };

package/dist/dynamicInputs.js

@@ -0,0 +1,186 @@
+import { StringUtils } from "./string.utils.js";
+import { ZodUtils } from "./zod.utils.js";
+import { z } from "zod";
+import i18next from "i18next";
+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)];
+	});
+};
+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 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 [];
+};
+const 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",
+		"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,
+		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];
+};
+const dynamicInputs = ({ schema, preset = [], options }) => {
+	validateParams(schema, preset, options);
+	let entries = Object.entries(options.inputs ?? {});
+	entries = excludeEntries(entries);
+	const inputDefs = convertInputsConfigToObjectDefinitions(entries).map(([key, value]) => {
+		return populateInputDef(schema, key, value, options);
+	});
+	let presetInputDefs = removeOverriddenPresetInputs(preset, options);
+	if (options.overridePresetLocales) presetInputDefs = overridePresetLabelsAndPlaceholders(presetInputDefs, options);
+	const mergedInputDefs = [...presetInputDefs, ...inputDefs];
+	return sortInputDefs(options.includeAll ? addMissingSchemaFields(schema, mergedInputDefs, options) : mergedInputDefs, options.order);
+};
+export { dynamicInputs, getDefaultInputComponentType };

package/dist/error-handling.js

@@ -0,0 +1,87 @@
+import { ns } from "./i18n.js";
+import { RestUtils } from "./rest.utils.js";
+import { logger } from "./logger.js";
+import axios from "axios";
+import { z } from "zod";
+import i18next from "i18next";
+var ApplicationException = class extends Error {
+	constructor(message, code, serverMessage) {
+		super(message);
+		this.serverMessage = null;
+		this.code = code;
+		this.serverMessage = serverMessage;
+	}
+};
+var ErrorHandler = class {
+	constructor(entries) {
+		this.entries = [];
+		const dataValidationError = {
+			code: "DATA_VALIDATION_ERROR",
+			condition: (e) => {
+				return e instanceof z.ZodError;
+			},
+			getMessage: () => i18next.t(($) => $.sharedErrors.dataValidation, { ns: "ui" })
+		};
+		const internalError = {
+			code: "INTERNAL_ERROR",
+			condition: (e) => {
+				if (axios.isAxiosError(e)) return e.response?.status != null && e.response.status >= 500 && e.response.status < 600;
+				return false;
+			},
+			getMessage: () => i18next.t(($) => $.sharedErrors.internalError, { ns: "ui" })
+		};
+		const networkError = {
+			code: "NETWORK_ERROR",
+			condition: (e) => {
+				if (axios.isAxiosError(e)) return e.code === "ERR_NETWORK";
+				return false;
+			},
+			getMessage: () => i18next.t(($) => $.sharedErrors.networkError, { ns: "ui" })
+		};
+		const canceledError = {
+			code: "CANCELED_ERROR",
+			condition: (e) => {
+				if (axios.isCancel(e)) return true;
+				if (axios.isAxiosError(e) && e.code === "ECONNABORTED") return true;
+				return false;
+			},
+			getMessage: () => i18next.t(($) => $.sharedErrors.canceledError, { ns: "ui" })
+		};
+		const unknownError = {
+			code: "UNKNOWN_ERROR",
+			condition: () => true,
+			getMessage: () => i18next.t(($) => $.sharedErrors.unknownError, { ns: "ui" })
+		};
+		this.entries = [
+			...entries,
+			dataValidationError,
+			internalError,
+			networkError,
+			canceledError,
+			unknownError
+		];
+	}
+	rethrowError(error) {
+		logger.error(error);
+		const errorEntry = this.entries.find((entry) => entry.condition(error ?? {}));
+		const serverMessage = RestUtils.extractServerErrorMessage(error);
+		throw new ApplicationException(errorEntry.getMessage(error), errorEntry.code, serverMessage);
+	}
+	getError(error) {
+		if (error instanceof ApplicationException) return error;
+		return null;
+	}
+	getErrorCode(error) {
+		if (error instanceof ApplicationException) return error.code;
+		return null;
+	}
+	static getErrorMessage(error, fallbackToUnknown = true) {
+		if (typeof error === "string") return error;
+		if (error instanceof Error) return error.message;
+		if (error instanceof ApplicationException) return error.message;
+		if (fallbackToUnknown) return i18next.t(($) => $.sharedErrors.unknownError, { ns: "ui" });
+		return null;
+	}
+};
+const SharedErrorHandler = new ErrorHandler([]);
+export { ApplicationException, ErrorHandler, SharedErrorHandler };

package/dist/file.utils.js

@@ -0,0 +1,43 @@
+import { RestUtils } from "./rest.utils.js";
+let FileUtils;
+(function(_FileUtils) {
+	const getObjectUrl = _FileUtils.getObjectUrl = (data, revokeTimeoutMs = 4e4) => {
+		const url = URL.createObjectURL(data instanceof Blob ? data : data.data);
+		setTimeout(() => URL.revokeObjectURL(url), revokeTimeoutMs);
+		return url;
+	};
+	_FileUtils.openFile = (data, target = "_blank", revokeTimeoutMs) => {
+		const url = getObjectUrl(data, revokeTimeoutMs);
+		window.open(url, target);
+	};
+	_FileUtils.downloadFile = (data, fileName, revokeTimeoutMs) => {
+		const url = getObjectUrl(data, revokeTimeoutMs);
+		const contentDispositionFileName = data instanceof Blob ? void 0 : RestUtils.extractContentDispositionFilename(data.headers);
+		const a = document.createElement("a");
+		a.download = fileName ?? contentDispositionFileName ?? "download";
+		a.rel = "noopener";
+		a.href = url;
+		setTimeout(() => a.dispatchEvent(new MouseEvent("click")));
+	};
+	_FileUtils.isFileTypeAccepted = (file, fileTypes) => {
+		if (!fileTypes || fileTypes.length === 0) return true;
+		return fileTypes.some((type) => {
+			if (type.includes("/")) return file.type === type || type.endsWith("/*") && file.type.startsWith(type.slice(0, -1));
+			return file.name.toLowerCase().endsWith(type.toLowerCase());
+		});
+	};
+	_FileUtils.getCalculatedFileSize = (file) => {
+		if (!file) return "";
+		if (file.size < 1024) return `${file.size} B`;
+		if (file.size < 1024 * 1024) return `${(file.size / 1024).toFixed(2)} KB`;
+		if (file.size < 1024 * 1024 * 1024) return `${(file.size / 1024 / 1024).toFixed(2)} MB`;
+		return `${(file.size / 1024 / 1024 / 1024).toFixed(2)} GB`;
+	};
+	_FileUtils.formatBytes = (size, decimals = 2) => {
+		if (size < 1024) return `${size} B`;
+		if (size < 1024 * 1024) return `${(size / 1024).toFixed(decimals)} KB`;
+		if (size < 1024 * 1024 * 1024) return `${(size / 1024 / 1024).toFixed(decimals)} MB`;
+		return `${(size / 1024 / 1024 / 1024).toFixed(decimals)} GB`;
+	};
+})(FileUtils || (FileUtils = {}));
+export { FileUtils };

package/dist/fileUpload.cva.js

@@ -0,0 +1,49 @@
+import { clsx } from "clsx";
+import { cva } from "class-variance-authority";
+const fileUploadDropZoneBase = cva(["relative w-full rounded-input-rounding-default"], {
+	variants: {
+		variant: {
+			vertical: ["flex-col justify-center"],
+			horizontal: ["flex-row justify-between"]
+		},
+		isContainer: {
+			true: [
+				"data-[drop-target]:before:content-['']",
+				"data-[drop-target]:before:absolute",
+				"data-[drop-target]:before:z-40",
+				"data-[drop-target]:before:width-full",
+				"data-[drop-target]:before:height-full",
+				"data-[drop-target]:before:top-0",
+				"data-[drop-target]:before:left-0",
+				"data-[drop-target]:border data-[drop-target]:border-dashed",
+				"data-[drop-target]:border-elevation-outline-default-2",
+				"data-[drop-target]:before:pointer-events-none data-[drop-target]:before:inset-0",
+				"data-[drop-target]:before:bg-elevation-fill-default-2"
+			],
+			false: [
+				"flex items-center",
+				"py-file-upload-container-height-top-bottom",
+				"px-file-upload-container-side-default",
+				"gap-gap-file-upload-content-gap-icon-to-content",
+				"border border-input-outlined-outline-idle border-dashed bg-input-outlined-idle",
+				"hover:border-elevation-outline-default-2 hover:bg-elevation-fill-default-2",
+				"invalid:border invalid:border-input-outlined-outline-error",
+				"data-[drop-target]:border-elevation-outline-default-2 data-[drop-target]:bg-elevation-fill-default-2",
+				"data-[has-files]:border-solid"
+			]
+		}
+	},
+	defaultVariants: { variant: "vertical" }
+});
+const fileUploadDropZone = (props) => {
+	const { className,...rest } = props;
+	return clsx(fileUploadDropZoneBase(rest), className);
+};
+cva(["flex gap-3"], {
+	variants: { variant: {
+		vertical: ["flex-col"],
+		horizontal: ["flex-row flex-wrap"]
+	} },
+	defaultVariants: { variant: "vertical" }
+});
+export { fileUploadDropZone };

package/dist/i18n.js

@@ -0,0 +1,8 @@
+import translation_default from "./translation.js";
+import translation_default$1 from "./translation2.js";
+const ns = "ui";
+const resources = {
+	en: { ["ui"]: translation_default },
+	sl: { ["ui"]: translation_default$1 }
+};
+export { ns, resources };