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

package/dist/uiOverrides.context-BdokYcGO.d.ts

@@ -0,0 +1,243 @@
+import { n as ConfigSchema$1, t as CompoundMapper } from "./compoundMapper-CMoX98D2.js";
+import { PropsWithChildren } from "react";
+import { ClassProp, ClassValue, StringToBoolean } from "class-variance-authority/types";
+//#region src/utils/style-merge.util.d.ts
+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 {};
+}
+//#endregion
+//#region src/config/uiOverrides.context.d.ts
+declare namespace UIOverrides {
+  export type Cva<T> = (props?: (T & ClassProp) | ClassProp) => string;
+  type GenericCva = Cva<unknown>;
+  type Mapper = CompoundMapper<unknown, ConfigSchema$1>;
+  type GenericCvaOption = StyleMergeUtils.CvaConfigOverride | GenericCva;
+  type OptionKey = { [K in keyof Options]: Options[K] extends object ? `${K & string}.${keyof Options[K] & string}` : never; }[keyof Options];
+  type OptionValue<K extends OptionKey> = K extends `${infer TSection}.${infer TSlot}` ? TSection extends keyof Options ? TSlot extends keyof Options[TSection] ? Options[TSection][TSlot] : never : never : never;
+  type ConfigFromOverride<TValue> = TValue extends StyleMergeUtils.CvaConfigOverride<infer TConfig> ? TConfig : never;
+  type OverrideConfig<TValue> = [ConfigFromOverride<TValue>] extends [never] ? never : ConfigFromOverride<TValue>;
+  type ExtractConfig<TValue> = [OverrideConfig<TValue>] extends [never] ? TValue extends {
+    config?: infer TConfig;
+  } ? NonNullable<TConfig> : TValue : OverrideConfig<TValue>;
+  type EmptyObject = {};
+  type VariantSchema<TConfig> = [TConfig] extends [never] ? EmptyObject : TConfig extends {
+    variants?: infer TVariants;
+  } ? [NonNullable<TVariants>] extends [never] ? EmptyObject : NonNullable<TVariants> : EmptyObject;
+  export type VariantProps<TConfig> = [keyof VariantSchema<ExtractConfig<TConfig>>] extends [never] ? EmptyObject : StyleMergeUtils.ConfigVariants<Extract<VariantSchema<ExtractConfig<TConfig>>, StyleMergeUtils.ConfigSchema>>;
+  export type OverrideVariantProps<TOverride> = VariantProps<ExtractConfig<TOverride>>;
+  export interface Options {
+    button: {
+      cva?: GenericCvaOption;
+      sizeCva?: GenericCvaOption;
+      contentCva?: GenericCvaOption;
+      iconSize?: GenericCvaOption;
+      typography?: Mapper;
+    };
+    pillButton: {
+      cva?: GenericCvaOption;
+      typography?: Mapper;
+    };
+    checkbox: {
+      cva?: GenericCvaOption;
+      contentWrapperCva?: GenericCvaOption;
+      contentRowCva?: GenericCvaOption;
+      groupLabelCva?: GenericCvaOption;
+      iconCva?: GenericCvaOption;
+      typography?: Mapper;
+      contentClassName?: Mapper;
+    };
+    radio: {
+      cva?: GenericCvaOption;
+      contentWrapperCva?: GenericCvaOption;
+      contentRowCva?: GenericCvaOption;
+      typography?: Mapper;
+      contentClassName?: Mapper;
+    };
+    status: {
+      iconCva?: GenericCvaOption;
+      separatorCva?: GenericCvaOption;
+    };
+    toast: {
+      cva?: GenericCvaOption;
+      containerCva?: GenericCvaOption;
+      buttonColor?: Mapper;
+    };
+    alert: {
+      cva?: GenericCvaOption;
+    };
+    input: {
+      baseCva?: GenericCvaOption;
+      clearClassCva?: GenericCvaOption;
+      contentWrapperCva?: GenericCvaOption;
+      sizeCva?: GenericCvaOption;
+      sideCva?: GenericCvaOption;
+    };
+    textArea: {
+      wrapperCva?: GenericCvaOption;
+    };
+    tooltipWrapper: {
+      triggerCva?: GenericCvaOption;
+    };
+    datePickerInput: {
+      contentRowCva?: GenericCvaOption;
+    };
+    label: {
+      cva?: GenericCvaOption;
+      typography?: Mapper;
+    };
+    toggle: {
+      cva?: GenericCvaOption;
+      typography?: Mapper;
+      contentClassName?: Mapper;
+    };
+    typography: {
+      cva?: GenericCvaOption;
+    };
+    link: {
+      cva?: GenericCvaOption;
+    };
+    tag: {
+      cva?: GenericCvaOption;
+    };
+    table: {
+      theadCva?: GenericCvaOption;
+      headRowCva?: GenericCvaOption;
+      headDataCva?: GenericCvaOption;
+      rowCva?: GenericCvaOption;
+      dataCva?: GenericCvaOption;
+      headerTextCva?: GenericCvaOption;
+      cellTextCva?: GenericCvaOption;
+    };
+    tooltip: {
+      cva?: GenericCvaOption;
+      pointerHorizontalCva?: GenericCvaOption;
+      pointerVerticalCva?: GenericCvaOption;
+      textCva?: GenericCvaOption;
+    };
+    modal: {
+      contentCva?: GenericCvaOption;
+      overlayCva?: GenericCvaOption;
+      mainCva?: GenericCvaOption;
+    };
+    menu: {
+      cva?: GenericCvaOption;
+      itemCva?: GenericCvaOption;
+      popoverCva?: GenericCvaOption;
+      popoverWrapperCva?: GenericCvaOption;
+    };
+    segment: {
+      cva?: GenericCvaOption;
+      itemCva?: GenericCvaOption;
+    };
+    stepper: {
+      cva?: GenericCvaOption;
+      itemCva?: GenericCvaOption;
+      iconCva?: GenericCvaOption;
+      numberCva?: GenericCvaOption;
+      titleCva?: GenericCvaOption;
+      subtextCva?: GenericCvaOption;
+      separatorCva?: GenericCvaOption;
+    };
+    accordion: {
+      cva?: GenericCvaOption;
+      itemCva?: GenericCvaOption;
+      triggerCva?: GenericCvaOption;
+      headingCva?: GenericCvaOption;
+      headingTitleCva?: GenericCvaOption;
+      headingSubtitleCva?: GenericCvaOption;
+      chevronCva?: GenericCvaOption;
+      iconCva?: GenericCvaOption;
+      panelCva?: GenericCvaOption;
+      panelContentCva?: GenericCvaOption;
+    };
+    breadcrumbs: {
+      cva?: GenericCvaOption;
+      itemCva?: GenericCvaOption;
+      segmentCva?: GenericCvaOption;
+      chevronCva?: GenericCvaOption;
+      iconCva?: GenericCvaOption;
+    };
+    popover: {
+      cva?: GenericCvaOption;
+    };
+    formField: {
+      headerCva?: GenericCvaOption;
+      errorLabelCva?: GenericCvaOption;
+      helperLabelCva?: GenericCvaOption;
+    };
+    select: {
+      listBoxItemCva?: GenericCvaOption;
+      popoverCva?: GenericCvaOption;
+      tagsContentWrapperCva?: GenericCvaOption;
+    };
+    progressBar: {
+      cva?: GenericCvaOption;
+      trackWrapperCva?: GenericCvaOption;
+      trackCva?: GenericCvaOption;
+      fillCva?: GenericCvaOption;
+      valueCva?: GenericCvaOption;
+    };
+    fileUpload: {
+      dropZoneCva?: GenericCvaOption;
+    };
+  }
+  export type Config = Partial<Options>;
+  interface ProviderProps {
+    config?: Config;
+  }
+  export const Provider: ({ children, config }: PropsWithChildren<ProviderProps>) => import("react/jsx-runtime").JSX.Element;
+  export const useCvaOverride: <K extends OptionKey>(key: K) => undefined;
+  export function defineConfig(definition: {
+    base: string[];
+  }): {
+    base: string[];
+    config?: StyleMergeUtils.Config<Record<never, never>>;
+  };
+  export function defineConfig<const TSchema extends StyleMergeUtils.ConfigSchema>(definition: {
+    base: string[];
+    config: StyleMergeUtils.Config<TSchema>;
+  }): {
+    base: string[];
+    config: StyleMergeUtils.Config<TSchema>;
+  };
+  export const defineOverride: <K extends OptionKey, const TOverride extends NonNullable<OptionValue<K>>>(_key: K, override: TOverride) => TOverride;
+  export function useCva<K extends OptionKey>(key: K, fallback: StyleMergeUtils.CvaDefinition<ConfigFromOverride<NonNullable<OptionValue<K>>> & StyleMergeUtils.CvaConfigShape>): Cva<any>;
+  export function useCva<K extends OptionKey, TProps>(key: K, fallback: Cva<TProps>): Cva<TProps>;
+  export const useMapper: <T, K extends ConfigSchema$1>(key: OptionKey, fallback: CompoundMapper<T, K>) => CompoundMapper<T, K>;
+  export {};
+}
+//#endregion
+export { StyleMergeUtils as n, UIOverrides as t };

package/dist/uiOverrides.context-Bfm2n-n8.js

@@ -0,0 +1,399 @@
+import { t as clsx } from "./clsx-CnD0nOiA.js";
+import { createContext, use } from "react";
+import { c } from "react/compiler-runtime";
+import { jsx } from "react/jsx-runtime";
+//#region ../../node_modules/.bun/class-variance-authority@0.7.1/node_modules/class-variance-authority/dist/index.mjs
+/**
+* Copyright 2022 Joe Bell. All rights reserved.
+*
+* This file is licensed to you under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with the
+* License. You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+* WARRANTIES OR REPRESENTATIONS OF ANY KIND, either express or implied. See the
+* License for the specific language governing permissions and limitations under
+* the License.
+*/ const falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
+const cx = clsx;
+const cva = (base, config) => (props) => {
+	var _config_compoundVariants;
+	if ((config === null || config === void 0 ? void 0 : config.variants) == null) return cx(base, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+	const { variants, defaultVariants } = config;
+	const getVariantClassNames = Object.keys(variants).map((variant) => {
+		const variantProp = props === null || props === void 0 ? void 0 : props[variant];
+		const defaultVariantProp = defaultVariants === null || defaultVariants === void 0 ? void 0 : defaultVariants[variant];
+		if (variantProp === null) return null;
+		const variantKey = falsyToString(variantProp) || falsyToString(defaultVariantProp);
+		return variants[variant][variantKey];
+	});
+	const propsWithoutUndefined = props && Object.entries(props).reduce((acc, param) => {
+		let [key, value] = param;
+		if (value === void 0) return acc;
+		acc[key] = value;
+		return acc;
+	}, {});
+	const getCompoundVariantClassNames = config === null || config === void 0 ? void 0 : (_config_compoundVariants = config.compoundVariants) === null || _config_compoundVariants === void 0 ? void 0 : _config_compoundVariants.reduce((acc, param) => {
+		let { class: cvClass, className: cvClassName, ...compoundVariantOptions } = param;
+		return Object.entries(compoundVariantOptions).every((param) => {
+			let [key, value] = param;
+			return Array.isArray(value) ? value.includes({
+				...defaultVariants,
+				...propsWithoutUndefined
+			}[key]) : {
+				...defaultVariants,
+				...propsWithoutUndefined
+			}[key] === value;
+		}) ? [
+			...acc,
+			cvClass,
+			cvClassName
+		] : acc;
+	}, []);
+	return cx(base, getVariantClassNames, getCompoundVariantClassNames, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+};
+//#endregion
+//#region src/utils/style-merge.util.ts
+let StyleMergeUtils;
+(function(_StyleMergeUtils) {
+	const CLASS_NAME_KEY = "className";
+	const CLASS_KEY = "class";
+	const CLASS_KEYS = /* @__PURE__ */ 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;
+			const baseValue = baseSelectorMap.get(overrideKey);
+			if (!isSubsetValues(overrideValue, baseValue)) 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 currentClassName = getCompoundClass(merged[index]);
+				const overrideClassName = getCompoundClass(normalizedOverride);
+				const mergedClassName = mergeClassNames(currentClassName, overrideClassName, "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
+//#region src/config/uiOverrides.context.tsx
+let UIOverrides;
+(function(_UIOverrides) {
+	const Context = createContext(null);
+	_UIOverrides.Provider = (t0) => {
+		const $ = c(3);
+		const { children, config } = t0;
+		let t1;
+		if ($[0] !== children || $[1] !== config) {
+			t1 = /* @__PURE__ */ jsx(Context.Provider, {
+				value: config,
+				children
+			});
+			$[0] = children;
+			$[1] = config;
+			$[2] = t1;
+		} else t1 = $[2];
+		return t1;
+	};
+	const useConfig = () => {
+		return use(Context);
+	};
+	const useCvaOverride = _UIOverrides.useCvaOverride = (key) => {
+		const uiOverrides = useConfig();
+		if (!uiOverrides) return;
+		const [k1, k2] = key.split(".");
+		const item = uiOverrides[k1]?.[k2];
+		if (!item) return;
+		return item;
+	};
+	function defineConfig(definition) {
+		return definition;
+	}
+	_UIOverrides.defineConfig = defineConfig;
+	_UIOverrides.defineOverride = (_key, override) => {
+		return override;
+	};
+	const isCvaFunction = (item) => {
+		return typeof item === "function";
+	};
+	const isCvaOverrideConfig = (item) => {
+		if (typeof item !== "object") return false;
+		if (item == null) return false;
+		return "mode" in item;
+	};
+	const isDefinition = (item) => {
+		if (typeof item !== "object") return false;
+		if (item == null) return false;
+		return "base" in item;
+	};
+	function useCva(key, fallback) {
+		const $ = c(6);
+		const override = useCvaOverride(key);
+		let t0;
+		bb0: {
+			if (isCvaFunction(override)) {
+				t0 = override;
+				break bb0;
+			}
+			if (isCvaFunction(fallback)) {
+				t0 = fallback;
+				break bb0;
+			}
+			if (!isDefinition(fallback)) {
+				t0 = _temp;
+				break bb0;
+			}
+			const definition = fallback;
+			const typedOverride = override;
+			if (isCvaOverrideConfig(typedOverride)) {
+				let t1;
+				if ($[0] !== definition || $[1] !== typedOverride) {
+					const mergedDefinition = StyleMergeUtils.mergeCvaDefinition(definition, typedOverride);
+					t1 = cva(clsx(mergedDefinition.base), mergedDefinition.config);
+					$[0] = definition;
+					$[1] = typedOverride;
+					$[2] = t1;
+				} else t1 = $[2];
+				t0 = t1;
+				break bb0;
+			}
+			let t1;
+			if ($[3] !== definition.base || $[4] !== definition.config) {
+				t1 = cva(clsx(definition.base), definition.config);
+				$[3] = definition.base;
+				$[4] = definition.config;
+				$[5] = t1;
+			} else t1 = $[5];
+			t0 = t1;
+		}
+		return t0;
+	}
+	_UIOverrides.useCva = useCva;
+	function _temp() {
+		return "";
+	}
+	_UIOverrides.useMapper = (key, fallback) => {
+		const uiOverrides = useConfig();
+		if (!uiOverrides) return fallback;
+		const [k1, k2] = key.split(".");
+		const item = uiOverrides[k1]?.[k2];
+		if (typeof item !== "function") return fallback;
+		return item;
+	};
+})(UIOverrides || (UIOverrides = {}));
+//#endregion
+export { cva as n, UIOverrides as t };