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

package/dist/utils/routing.utils.js

@@ -1,25 +0,0 @@
-//#region src/utils/routing.utils.ts
-var RoutingUtils;
-(function(_RoutingUtils) {
-	const isNumericString = (value) => {
-		return /^-?(0|[1-9]\d*)(\.\d+)?$/.test(value);
-	};
-	const coerceQueryValue = (value) => {
-		if (value === "true") return true;
-		if (value === "false") return false;
-		if (isNumericString(value)) return Number(value);
-		return value;
-	};
-	_RoutingUtils.toRouterSearch = (params) => {
-		const search = {};
-		for (const [key, value] of params.entries()) search[key] = coerceQueryValue(value);
-		return search;
-	};
-	_RoutingUtils.addQueryParams = (path, params) => {
-		const sParams = new URLSearchParams();
-		for (const [key, value] of Object.entries(params)) if (value) sParams.append(key, value.toString());
-		return `${path}?${sParams.toString()}`;
-	};
-})(RoutingUtils || (RoutingUtils = {}));
-//#endregion
-export { RoutingUtils };

package/dist/utils/string.utils.d.ts

@@ -1,4 +0,0 @@
-export declare namespace StringUtils {
-    const containsCaseInsensitive: (str: string, substr: string) => boolean;
-    const capitalize: (str: string) => string;
-}

package/dist/utils/string.utils.js

@@ -1,12 +0,0 @@
-//#region src/utils/string.utils.ts
-var StringUtils;
-(function(_StringUtils) {
-	_StringUtils.containsCaseInsensitive = (str, substr) => {
-		return str.toLowerCase().includes(substr.toLowerCase());
-	};
-	_StringUtils.capitalize = (str) => {
-		return str.charAt(0).toUpperCase() + str.slice(1);
-	};
-})(StringUtils || (StringUtils = {}));
-//#endregion
-export { StringUtils };

package/dist/utils/style-merge.util.d.ts

@@ -1,43 +0,0 @@
-import { ClassProp, ClassValue, StringToBoolean } from 'class-variance-authority/types';
-export declare namespace StyleMergeUtils {
-    export type OverrideMode = "merge" | "overrideEntry" | "overrideCva";
-    export interface CvaVariantMap {
-        [variant: string]: {
-            [value: string]: ClassValue;
-        };
-    }
-    export type ConfigSchema = CvaVariantMap;
-    export type ConfigVariants<TSchema extends ConfigSchema> = {
-        [K in keyof TSchema]?: StringToBoolean<keyof NonNullable<TSchema[K]>> | null | undefined;
-    };
-    export type ConfigVariantsMulti<TSchema extends ConfigSchema> = {
-        [K in keyof TSchema]?: StringToBoolean<keyof NonNullable<TSchema[K]>> | StringToBoolean<keyof NonNullable<TSchema[K]>>[] | undefined;
-    };
-    export interface Config<TSchema extends ConfigSchema> {
-        variants?: TSchema;
-        defaultVariants?: ConfigVariants<TSchema>;
-        compoundVariants?: Array<(ConfigVariants<TSchema> | ConfigVariantsMulti<TSchema>) & ClassProp>;
-    }
-    export interface CvaCompoundEntry {
-        [key: string]: unknown;
-        class?: ClassValue;
-        className?: ClassValue;
-    }
-    export interface CvaConfigShape {
-        variants?: CvaVariantMap;
-        compoundVariants?: CvaCompoundEntry[];
-        defaultVariants?: Record<string, unknown>;
-    }
-    export interface CvaDefinition<TConfig extends CvaConfigShape> {
-        base: string[];
-        config?: TConfig;
-    }
-    type DeepOptionalOverride<T> = T extends string ? string : T extends (infer U)[] ? DeepOptionalOverride<U>[] : T extends object ? {
-        [K in keyof T]?: DeepOptionalOverride<T[K]>;
-    } : T;
-    export type CvaConfigOverride<TConfig extends CvaConfigShape = CvaConfigShape> = DeepOptionalOverride<CvaDefinition<TConfig>> & {
-        mode: OverrideMode;
-    };
-    export const mergeCvaDefinition: <TConfig extends CvaConfigShape>(baseDefinition: CvaDefinition<TConfig>, override?: CvaConfigOverride<TConfig>) => CvaDefinition<TConfig>;
-    export {};
-}

package/dist/utils/style-merge.util.js

@@ -1,233 +0,0 @@
-import { clsx } from "clsx";
-//#region src/utils/style-merge.util.ts
-var StyleMergeUtils;
-(function(_StyleMergeUtils) {
-	const CLASS_NAME_KEY = "className";
-	const CLASS_KEY = "class";
-	const CLASS_KEYS = new Set([CLASS_KEY, CLASS_NAME_KEY]);
-	const isClassKey = (key) => {
-		return CLASS_KEYS.has(key);
-	};
-	const getSelectorEntries = (entry) => {
-		const selectors = [];
-		for (const [key, value] of Object.entries(entry)) {
-			if (isClassKey(key)) continue;
-			selectors.push([key, value]);
-		}
-		return selectors;
-	};
-	const normalizeToArray = (value) => {
-		if (Array.isArray(value)) return value;
-		return [value];
-	};
-	const isSubsetValues = (subset, superset) => {
-		const subsetValues = normalizeToArray(subset).map((item) => String(item));
-		const supersetSet = new Set(normalizeToArray(superset).map((item) => String(item)));
-		for (const value of subsetValues) if (!supersetSet.has(value)) return false;
-		return true;
-	};
-	const canOverrideCompoundEntry = (baseEntry, overrideEntry) => {
-		const baseSelectors = getSelectorEntries(baseEntry);
-		const overrideSelectors = getSelectorEntries(overrideEntry);
-		if (baseSelectors.length !== overrideSelectors.length) return false;
-		const baseSelectorMap = new Map(baseSelectors);
-		for (const [overrideKey, overrideValue] of overrideSelectors) {
-			if (!baseSelectorMap.has(overrideKey)) return false;
-			if (!isSubsetValues(overrideValue, baseSelectorMap.get(overrideKey))) return false;
-		}
-		return true;
-	};
-	const splitCompoundEntryByOverride = (baseEntry, overrideEntry) => {
-		const baseWithoutClass = {};
-		for (const [key, value] of Object.entries(baseEntry)) {
-			if (isClassKey(key)) continue;
-			baseWithoutClass[key] = value;
-		}
-		let hasSplit = false;
-		for (const [key, overrideValue] of getSelectorEntries(overrideEntry)) {
-			const baseValue = baseWithoutClass[key];
-			if (!Array.isArray(baseValue)) continue;
-			const baseValues = [...baseValue];
-			const overrideValues = new Set(normalizeToArray(overrideValue).map((item) => String(item)));
-			const remainingValues = baseValues.filter((item) => !overrideValues.has(String(item)));
-			if (remainingValues.length === baseValues.length) continue;
-			hasSplit = true;
-			if (remainingValues.length === 1) baseWithoutClass[key] = remainingValues[0];
-			else baseWithoutClass[key] = remainingValues;
-		}
-		if (!hasSplit) return;
-		const className = getCompoundClass(baseEntry);
-		if (className) baseWithoutClass.className = className;
-		return normalizeCompoundEntry(baseWithoutClass);
-	};
-	const getCompoundClass = (entry) => {
-		const fromClassName = entry[CLASS_NAME_KEY];
-		if (fromClassName) return clsx(fromClassName);
-		const fromClass = entry[CLASS_KEY];
-		if (fromClass) return clsx(fromClass);
-		return "";
-	};
-	const normalizeCompoundEntry = (entry) => {
-		const normalized = {};
-		for (const [key, value] of Object.entries(entry)) {
-			if (key === CLASS_KEY || key === CLASS_NAME_KEY) continue;
-			normalized[key] = value;
-		}
-		const className = getCompoundClass(entry);
-		if (className) normalized.className = className;
-		return normalized;
-	};
-	const getCompoundIdentity = (entry) => {
-		const keys = Object.keys(entry).sort();
-		const identityParts = [];
-		for (const key of keys) {
-			if (isClassKey(key)) continue;
-			const value = entry[key];
-			if (Array.isArray(value)) {
-				const normalizedValues = value.map((item) => String(item)).sort();
-				identityParts.push(`${key}:[${normalizedValues.join(",")}]`);
-				continue;
-			}
-			identityParts.push(`${key}:${String(value)}`);
-		}
-		return identityParts.join("|");
-	};
-	const mergeClassNames = (baseClassName, overrideClassName, mode) => {
-		if (mode !== "merge") return clsx(overrideClassName);
-		return clsx(baseClassName, overrideClassName);
-	};
-	const mergeClassLists = (baseClassNames, overrideClassNames, mode) => {
-		if (mode !== "merge") return [...overrideClassNames];
-		return [...baseClassNames, ...overrideClassNames];
-	};
-	const mergeVariants = (baseVariants, overrideVariants, mode = "merge") => {
-		const merged = {};
-		if (baseVariants) for (const [variantKey, variantValues] of Object.entries(baseVariants)) merged[variantKey] = { ...variantValues };
-		if (!overrideVariants) {
-			if (!baseVariants) return;
-			return merged;
-		}
-		for (const [variantKey, overrideValues] of Object.entries(overrideVariants)) {
-			if (!overrideValues) continue;
-			if (!merged[variantKey]) merged[variantKey] = {};
-			for (const [valueKey, overrideValue] of Object.entries(overrideValues)) {
-				const baseClass = merged[variantKey][valueKey] ?? "";
-				merged[variantKey][valueKey] = mergeClassNames(baseClass, overrideValue, mode);
-			}
-		}
-		return merged;
-	};
-	const mergeCompoundVariants = (baseCompound, overrideCompound, mode = "merge") => {
-		if (!baseCompound) {
-			if (!overrideCompound) return;
-			return overrideCompound.map((entry) => normalizeCompoundEntry(entry));
-		}
-		const merged = baseCompound.map((entry) => normalizeCompoundEntry(entry));
-		if (!overrideCompound) return merged;
-		if (mode === "merge") {
-			for (const overrideEntry of overrideCompound) {
-				const normalizedOverride = normalizeCompoundEntry(overrideEntry);
-				const overrideIdentity = getCompoundIdentity(normalizedOverride);
-				let index = -1;
-				for (let i = 0; i < merged.length; i++) if (getCompoundIdentity(merged[i]) === overrideIdentity) {
-					index = i;
-					break;
-				}
-				if (index < 0) {
-					merged.push(normalizedOverride);
-					continue;
-				}
-				const mergedClassName = mergeClassNames(getCompoundClass(merged[index]), getCompoundClass(normalizedOverride), "merge");
-				const nextEntry = { ...normalizedOverride };
-				nextEntry.className = mergedClassName;
-				merged[index] = nextEntry;
-			}
-			return merged;
-		}
-		for (const overrideEntry of overrideCompound) {
-			const normalizedOverride = normalizeCompoundEntry(overrideEntry);
-			const overrideIdentity = getCompoundIdentity(normalizedOverride);
-			let exactMatchIndex = -1;
-			for (let i = 0; i < merged.length; i++) {
-				const currentEntry = merged[i];
-				if (getCompoundIdentity(currentEntry) === overrideIdentity) {
-					exactMatchIndex = i;
-					break;
-				}
-			}
-			if (exactMatchIndex >= 0) {
-				merged[exactMatchIndex] = normalizedOverride;
-				continue;
-			}
-			let candidateIndex = -1;
-			for (let i = 0; i < merged.length; i++) if (canOverrideCompoundEntry(merged[i], normalizedOverride)) {
-				candidateIndex = i;
-				break;
-			}
-			if (candidateIndex < 0) {
-				merged.push(normalizedOverride);
-				continue;
-			}
-			const candidate = merged[candidateIndex];
-			const splitBaseEntry = splitCompoundEntryByOverride(candidate, normalizedOverride);
-			if (splitBaseEntry) {
-				merged[candidateIndex] = splitBaseEntry;
-				merged.push(normalizedOverride);
-				continue;
-			}
-			merged[candidateIndex] = normalizedOverride;
-		}
-		return merged;
-	};
-	const mergeDefaultVariants = (baseDefaults, overrideDefaults) => {
-		if (!baseDefaults) {
-			if (!overrideDefaults) return;
-			return { ...overrideDefaults };
-		}
-		if (!overrideDefaults) return { ...baseDefaults };
-		return {
-			...baseDefaults,
-			...overrideDefaults
-		};
-	};
-	const hasConfigContent = (config) => {
-		if (!config) return false;
-		if (config.variants) return true;
-		if (config.compoundVariants) return true;
-		if (config.defaultVariants) return true;
-		return false;
-	};
-	_StyleMergeUtils.mergeCvaDefinition = (baseDefinition, override) => {
-		if (!override) return baseDefinition;
-		const mode = override.mode ?? "merge";
-		const overrideConfig = override.config;
-		if (mode === "overrideCva") {
-			const overrideBase = [];
-			if (override.base && Array.isArray(override.base)) {
-				for (const item of override.base) if (typeof item === "string") overrideBase.push(item);
-			}
-			let finalOverrideConfig = void 0;
-			if (hasConfigContent(overrideConfig)) finalOverrideConfig = overrideConfig;
-			return {
-				base: overrideBase,
-				config: finalOverrideConfig
-			};
-		}
-		let mergedBase = [...baseDefinition.base];
-		if (override.base && Array.isArray(override.base)) mergedBase = mergeClassLists(baseDefinition.base, override.base, mode);
-		const baseConfig = baseDefinition.config;
-		const mergedConfig = {
-			variants: mergeVariants(baseConfig?.variants, overrideConfig?.variants, mode),
-			compoundVariants: mergeCompoundVariants(baseConfig?.compoundVariants, overrideConfig?.compoundVariants, mode),
-			defaultVariants: mergeDefaultVariants(baseConfig?.defaultVariants, overrideConfig?.defaultVariants)
-		};
-		let finalConfig = void 0;
-		if (hasConfigContent(mergedConfig)) finalConfig = mergedConfig;
-		return {
-			base: mergedBase,
-			config: finalConfig
-		};
-	};
-})(StyleMergeUtils || (StyleMergeUtils = {}));
-//#endregion
-export { StyleMergeUtils };

package/dist/utils/style-merge.util.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/zod.utils.d.ts

@@ -1,20 +0,0 @@
-import { z } from 'zod';
-export declare namespace ZodUtils {
-    type UnwrapZod<T> = T extends z.ZodOptional<infer U> ? UnwrapZod<U> : T extends z.ZodNullable<infer U> ? UnwrapZod<U> : T;
-    type IsZodType<T, Z> = UnwrapZod<T> extends Z ? true : false;
-    type IsZodNumber<T> = IsZodType<T, z.ZodNumber>;
-    type IsZodEnum<T> = IsZodType<T, z.ZodEnum<any>>;
-    type IsZodUUID<T> = IsZodType<T, z.ZodUUID>;
-    type IsZodDateTime<T> = IsZodType<T, z.ZodISODateTime>;
-    type IsZodString<T> = IsZodType<T, z.ZodString>;
-    type IsZodEmail<T> = IsZodType<T, z.ZodEmail>;
-    type IsZodDateRange<T> = UnwrapZod<T> extends z.ZodObject ? UnwrapZod<UnwrapZod<T>["shape"]["start"]> extends z.ZodISODateTime ? UnwrapZod<UnwrapZod<T>["shape"]["end"]> extends z.ZodISODateTime ? true : false : false : false;
-    type IsZodObject<T> = IsZodType<T, z.ZodObject<any>>;
-    type IsZodArray<T> = IsZodType<T, z.ZodArray<any>>;
-    type ZodType<T> = IsZodType<T, z.ZodBoolean> extends true ? "boolean" : IsZodNumber<T> extends true ? "number" : IsZodEnum<T> extends true ? "enum" : IsZodDateTime<T> extends true ? "datetime" : IsZodUUID<T> extends true ? "uuid" : IsZodString<T> extends true ? "string" : IsZodEmail<T> extends true ? "email" : IsZodDateRange<T> extends true ? "dateRange" : IsZodObject<T> extends true ? "object" : IsZodArray<T> extends true ? "array" : never;
-    type ZodTypeSwitch<TZodType extends z.ZodType, T extends Record<ZodType<TZodType> | "unknown", unknown>> = ZodType<TZodType> extends never ? never : T[ZodType<TZodType>];
-    const unwrapZodType: (schemaType: z.core.$ZodType) => z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-    /** After stripping optional/nullable wrappers, the inner schema must be a `ZodObject` (e.g. for `.shape`, forms, dynamicInputs). */
-    const unwrapToZodObject: (schema: z.ZodType) => z.ZodObject<any>;
-    const isDateRange: (schemaType: z.core.$ZodType) => boolean;
-}

package/dist/utils/zod.utils.js

@@ -1,24 +0,0 @@
-import { z } from "zod";
-//#region src/utils/zod.utils.ts
-var ZodUtils;
-(function(_ZodUtils) {
-	const unwrapZodType = _ZodUtils.unwrapZodType = (schemaType) => {
-		let unwrappedType = schemaType;
-		while (unwrappedType instanceof z.ZodNullable || unwrappedType instanceof z.ZodOptional) unwrappedType = unwrappedType.unwrap();
-		return unwrappedType;
-	};
-	_ZodUtils.unwrapToZodObject = (schema) => {
-		const inner = unwrapZodType(schema);
-		if (!(inner instanceof z.ZodObject)) throw new Error("ZodUtils.unwrapToZodObject: expected a Zod object, or optional/nullable wrapping a Zod object.");
-		return inner;
-	};
-	const hasZodObjectProperty = (schemaType, property, type) => {
-		return property in schemaType.shape && schemaType.shape[property] instanceof z.core.$ZodType && unwrapZodType(schemaType.shape[property]) instanceof type;
-	};
-	_ZodUtils.isDateRange = (schemaType) => {
-		const unwrappedType = unwrapZodType(schemaType);
-		return unwrappedType instanceof z.ZodObject && hasZodObjectProperty(unwrappedType, "start", z.ZodISODateTime) && hasZodObjectProperty(unwrappedType, "end", z.ZodISODateTime);
-	};
-})(ZodUtils || (ZodUtils = {}));
-//#endregion
-export { ZodUtils };