@sdata/web-vue 1.6.0 → 1.7.0

package/es/config-provider/config-provider.vue.d.ts

@@ -1,6 +1,7 @@
 import type { PropType } from 'vue';
 import { Size } from '../_utils/constant';
 import { SDLang } from '../locale/interface';
+import { SDThemeConfig, SDThemeMode } from './theme';
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
@@ -34,7 +35,13 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: BooleanConstructor;
         default: boolean;
     };
-}>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    theme: {
+        type: PropType<SDThemeConfig>;
+    };
+    themeMode: {
+        type: PropType<SDThemeMode>;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     prefixCls: {
         type: StringConstructor;
         default: string;
@@ -65,6 +72,12 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         type: BooleanConstructor;
         default: boolean;
     };
+    theme: {
+        type: PropType<SDThemeConfig>;
+    };
+    themeMode: {
+        type: PropType<SDThemeMode>;
+    };
 }>> & Readonly<{}>, {
     prefixCls: string;
     updateAtScroll: boolean;
@@ -72,4 +85,51 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     rtl: boolean;
     global: boolean;
     exchangeTime: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {
+    ThemeProvider: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+            theme?: SDThemeConfig;
+            themeMode?: SDThemeMode;
+            global?: boolean;
+            tag?: string;
+        }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            themeMode: SDThemeMode;
+            global: boolean;
+            tag: string;
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            theme?: SDThemeConfig;
+            themeMode?: SDThemeMode;
+            global?: boolean;
+            tag?: string;
+        }> & Readonly<{}>, {}, {}, {}, {}, {
+            themeMode: SDThemeMode;
+            global: boolean;
+            tag: string;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<{
+        theme?: SDThemeConfig;
+        themeMode?: SDThemeMode;
+        global?: boolean;
+        tag?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        themeMode: SDThemeMode;
+        global: boolean;
+        tag: string;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        } & {
+            default?: (props: {}) => any;
+        };
+    });
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/es/config-provider/config-provider.vue_vue_type_script_lang.js

@@ -1,5 +1,7 @@
 import { configProviderInjectionKey } from "./context.js";
-import { defineComponent, getCurrentInstance, provide, reactive, toRefs } from "vue";
+import { normalizeTheme } from "./theme.js";
+import theme_provider_default from "./theme-provider.js";
+import { defineComponent, getCurrentInstance, provide, reactive, toRefs, watch } from "vue";
 //#region components/config-provider/config-provider.vue?vue&type=script&lang.ts
 var config_provider_vue_vue_type_script_lang_default = defineComponent({
 	name: "ConfigProvider",
@@ -29,7 +31,9 @@ var config_provider_vue_vue_type_script_lang_default = defineComponent({
 		rtl: {
 			type: Boolean,
 			default: false
-		}
+		},
+		theme: { type: Object },
+		themeMode: { type: String }
 	},
 	setup(props, { slots }) {
 		const { prefixCls, locale, size, updateAtScroll, scrollToClose, exchangeTime, rtl } = toRefs(props);
@@ -41,13 +45,22 @@ var config_provider_vue_vue_type_script_lang_default = defineComponent({
 			updateAtScroll,
 			scrollToClose,
 			exchangeTime,
-			rtl
+			rtl,
+			theme: normalizeTheme(props.theme)
+		});
+		watch(() => props.theme, (themeConfig) => {
+			config.theme = normalizeTheme(themeConfig);
+		}, {
+			immediate: true,
+			deep: true
 		});
 		if (props.global) {
 			const instance = getCurrentInstance();
 			if (instance) instance.appContext.app.provide(configProviderInjectionKey, config);
 		} else provide(configProviderInjectionKey, config);
-	}
+		return {};
+	},
+	components: { ThemeProvider: theme_provider_default }
 });
 //#endregion
 export { config_provider_vue_vue_type_script_lang_default as default };

package/es/config-provider/context.d.ts

@@ -1,6 +1,7 @@
 import { InjectionKey, Slots } from 'vue';
 import { Size } from '../_utils/constant';
 import { SDLang } from '../locale/interface';
+import { SDThemeNormalized } from './theme';
 export interface ConfigProvider {
     slots: Slots;
     prefixCls?: string;
@@ -10,5 +11,6 @@ export interface ConfigProvider {
     scrollToClose?: boolean;
     exchangeTime?: boolean;
     rtl?: boolean;
+    theme?: SDThemeNormalized;
 }
 export declare const configProviderInjectionKey: InjectionKey<ConfigProvider>;

package/es/config-provider/index.d.ts

@@ -33,14 +33,67 @@ declare const ConfigProvider: {
             type: BooleanConstructor;
             default: boolean;
         };
-    }>> & Readonly<{}>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        theme: {
+            type: import("vue").PropType<import("./theme").SDThemeConfig>;
+        };
+        themeMode: {
+            type: import("vue").PropType<import("./theme").SDThemeMode>;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
         prefixCls: string;
         updateAtScroll: boolean;
         scrollToClose: boolean;
         rtl: boolean;
         global: boolean;
         exchangeTime: boolean;
-    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+    }, true, {}, {}, {
+        ThemeProvider: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                theme?: import("./theme").SDThemeConfig;
+                themeMode?: import("./theme").SDThemeMode;
+                global?: boolean;
+                tag?: string;
+            }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                themeMode: import("./theme").SDThemeMode;
+                global: boolean;
+                tag: string;
+            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{
+                theme?: import("./theme").SDThemeConfig;
+                themeMode?: import("./theme").SDThemeMode;
+                global?: boolean;
+                tag?: string;
+            }> & Readonly<{}>, {}, {}, {}, {}, {
+                themeMode: import("./theme").SDThemeMode;
+                global: boolean;
+                tag: string;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<{
+            theme?: import("./theme").SDThemeConfig;
+            themeMode?: import("./theme").SDThemeMode;
+            global?: boolean;
+            tag?: string;
+        }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            themeMode: import("./theme").SDThemeMode;
+            global: boolean;
+            tag: string;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            } & {
+                default?: (props: {}) => any;
+            };
+        });
+    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -78,6 +131,12 @@ declare const ConfigProvider: {
             type: BooleanConstructor;
             default: boolean;
         };
+        theme: {
+            type: import("vue").PropType<import("./theme").SDThemeConfig>;
+        };
+        themeMode: {
+            type: import("vue").PropType<import("./theme").SDThemeMode>;
+        };
     }>> & Readonly<{}>, {}, {}, {}, {}, {
         prefixCls: string;
         updateAtScroll: boolean;
@@ -120,14 +179,67 @@ declare const ConfigProvider: {
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & Readonly<{}>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    theme: {
+        type: import("vue").PropType<import("./theme").SDThemeConfig>;
+    };
+    themeMode: {
+        type: import("vue").PropType<import("./theme").SDThemeMode>;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
     prefixCls: string;
     updateAtScroll: boolean;
     scrollToClose: boolean;
     rtl: boolean;
     global: boolean;
     exchangeTime: boolean;
-}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+}, {}, string, {}, {
+    ThemeProvider: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+            theme?: import("./theme").SDThemeConfig;
+            themeMode?: import("./theme").SDThemeMode;
+            global?: boolean;
+            tag?: string;
+        }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            themeMode: import("./theme").SDThemeMode;
+            global: boolean;
+            tag: string;
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            theme?: import("./theme").SDThemeConfig;
+            themeMode?: import("./theme").SDThemeMode;
+            global?: boolean;
+            tag?: string;
+        }> & Readonly<{}>, {}, {}, {}, {}, {
+            themeMode: import("./theme").SDThemeMode;
+            global: boolean;
+            tag: string;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<{
+        theme?: import("./theme").SDThemeConfig;
+        themeMode?: import("./theme").SDThemeMode;
+        global?: boolean;
+        tag?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        themeMode: import("./theme").SDThemeMode;
+        global: boolean;
+        tag: string;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        } & {
+            default?: (props: {}) => any;
+        };
+    });
+} & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     install: (app: App, options?: SDOptions) => void;
 };
 export type ConfigProviderInstance = InstanceType<typeof _ConfigProvider>;

package/es/config-provider/theme-provider.js

@@ -0,0 +1,7 @@
+import _plugin_vue_export_helper_default from "../_virtual/_plugin-vue_export-helper.js";
+import theme_provider_vue_vue_type_script_setup_true_lang_default from "./theme-provider.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                               */
+//#region components/config-provider/theme-provider.vue
+var theme_provider_default = /* @__PURE__ */ _plugin_vue_export_helper_default(theme_provider_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-a0a91a8a"]]);
+//#endregion
+export { theme_provider_default as default };

package/es/config-provider/theme-provider.vue.d.ts

@@ -0,0 +1,26 @@
+import { type SDThemeConfig, type SDThemeMode } from './theme';
+type __VLS_Props = {
+    theme?: SDThemeConfig;
+    themeMode?: SDThemeMode;
+    global?: boolean;
+    tag?: string;
+};
+declare var __VLS_9: {}, __VLS_11: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_9) => any;
+} & {
+    default?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    themeMode: SDThemeMode;
+    global: boolean;
+    tag: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/config-provider/theme-provider.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,108 @@
+import { _objectSpread2 } from "../_virtual/_@oxc-project_runtime@0.124.0/helpers/objectSpread2.js";
+import { applyThemeCSSVariables, clearThemeCSSVariables, normalizeTheme } from "./theme.js";
+import { computed, createBlock, defineComponent, onBeforeUnmount, openBlock, renderSlot, resolveDynamicComponent, shallowRef, watch, withCtx } from "vue";
+//#region components/config-provider/theme-provider.vue?vue&type=script&setup=true&lang.ts
+var theme_provider_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent(_objectSpread2(_objectSpread2({}, { name: "ThemeProvider" }), {}, {
+	__name: "theme-provider",
+	props: {
+		theme: {},
+		themeMode: { default: void 0 },
+		global: {
+			type: Boolean,
+			default: false
+		},
+		tag: { default: "div" }
+	},
+	setup(__props) {
+		const props = __props;
+		const rootElement = shallowRef(null);
+		const normalizedTheme = computed(() => normalizeTheme(props.theme));
+		const usesLocalThemeContainer = computed(() => {
+			if (props.global) return false;
+			return Boolean(props.themeMode) || Object.keys(normalizedTheme.value.tokens).length > 0 || Object.keys(normalizedTheme.value.components).length > 0;
+		});
+		let appliedThemeKeys = /* @__PURE__ */ new Set();
+		let activeTarget = null;
+		let previousGlobalThemeMode;
+		function resolveThemeTarget() {
+			if (typeof document === "undefined") return null;
+			if (props.global) return document.body || document.documentElement;
+			if (!usesLocalThemeContainer.value) return null;
+			return rootElement.value;
+		}
+		function restoreThemeMode(target) {
+			if (!props.global) {
+				if (props.themeMode) target.setAttribute("sd-theme", props.themeMode);
+				else target.removeAttribute("sd-theme");
+				return;
+			}
+			if (props.themeMode) {
+				target.setAttribute("sd-theme", props.themeMode);
+				return;
+			}
+			if (previousGlobalThemeMode === null) {
+				target.removeAttribute("sd-theme");
+				return;
+			}
+			if (previousGlobalThemeMode) target.setAttribute("sd-theme", previousGlobalThemeMode);
+		}
+		function resetActiveTarget() {
+			if (!activeTarget) return;
+			cleanupTarget(activeTarget);
+			activeTarget = null;
+		}
+		function cleanupTarget(target) {
+			if (!target) return;
+			clearThemeCSSVariables(target, appliedThemeKeys);
+			appliedThemeKeys = /* @__PURE__ */ new Set();
+			if (props.global) {
+				if (previousGlobalThemeMode === void 0) target.removeAttribute("sd-theme");
+				else if (previousGlobalThemeMode === null) target.removeAttribute("sd-theme");
+				else target.setAttribute("sd-theme", previousGlobalThemeMode);
+				previousGlobalThemeMode = void 0;
+				return;
+			}
+			target.removeAttribute("sd-theme");
+		}
+		function syncThemeTarget() {
+			const nextTarget = resolveThemeTarget();
+			if (!nextTarget) {
+				resetActiveTarget();
+				return;
+			}
+			if (activeTarget && activeTarget !== nextTarget) cleanupTarget(activeTarget);
+			if (props.global && activeTarget !== nextTarget && previousGlobalThemeMode === void 0) previousGlobalThemeMode = nextTarget.getAttribute("sd-theme");
+			appliedThemeKeys = applyThemeCSSVariables(nextTarget, normalizedTheme.value, appliedThemeKeys);
+			restoreThemeMode(nextTarget);
+			activeTarget = nextTarget;
+		}
+		watch([
+			normalizedTheme,
+			() => props.themeMode,
+			() => props.global,
+			usesLocalThemeContainer,
+			rootElement
+		], syncThemeTarget, {
+			deep: true,
+			immediate: true,
+			flush: "post"
+		});
+		onBeforeUnmount(() => {
+			cleanupTarget(activeTarget);
+			activeTarget = null;
+		});
+		return (_ctx, _cache) => {
+			return usesLocalThemeContainer.value ? (openBlock(), createBlock(resolveDynamicComponent(__props.tag), {
+				key: 0,
+				ref_key: "rootElement",
+				ref: rootElement,
+				class: "sd-theme-provider"
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", {}, void 0, true)]),
+				_: 3
+			}, 512)) : renderSlot(_ctx.$slots, "default", { key: 1 }, void 0, true);
+		};
+	}
+}));
+//#endregion
+export { theme_provider_vue_vue_type_script_setup_true_lang_default as default };

package/es/config-provider/theme.d.ts

@@ -0,0 +1,27 @@
+export type ThemeTokenValue = string | number;
+export type ThemeTokenMap = Record<string, ThemeTokenValue>;
+export interface SDThemeMeta {
+    name?: string;
+    schemaVersion?: number;
+    cssVarPrefix?: string;
+}
+export type SDThemeMode = 'light' | 'dark';
+export interface SDThemeConfig {
+    tokens?: ThemeTokenMap;
+    components?: Record<string, ThemeTokenMap>;
+    meta?: SDThemeMeta;
+    token?: ThemeTokenMap;
+    component?: Record<string, ThemeTokenMap>;
+    [key: string]: unknown;
+}
+export interface SDThemeNormalized {
+    tokens: ThemeTokenMap;
+    components: Record<string, ThemeTokenMap>;
+    meta: Required<Pick<SDThemeMeta, 'schemaVersion' | 'cssVarPrefix'>> & Pick<SDThemeMeta, 'name'>;
+}
+export declare function normalizeTokenKey(key: string): string;
+export declare function normalizeTheme(theme?: SDThemeConfig): SDThemeNormalized;
+export declare function resolveThemeToken(theme: SDThemeNormalized, componentName: string, tokenKey: string): ThemeTokenValue | undefined;
+export declare function getThemeCSSVariables(theme: SDThemeNormalized): Record<string, string>;
+export declare function applyThemeCSSVariables(target: HTMLElement, theme: SDThemeNormalized, previousKeys?: Set<string>): Set<string>;
+export declare function clearThemeCSSVariables(target: HTMLElement, keys: Set<string>): void;

package/es/config-provider/theme.js

@@ -0,0 +1,90 @@
+import { _objectSpread2 } from "../_virtual/_@oxc-project_runtime@0.124.0/helpers/objectSpread2.js";
+//#region components/config-provider/theme.ts
+var DEFAULT_THEME_META = {
+	schemaVersion: 1,
+	cssVarPrefix: "--"
+};
+var RESERVED_THEME_KEYS = new Set([
+	"tokens",
+	"components",
+	"meta",
+	"token",
+	"component"
+]);
+function normalizeCssVarPrefix(prefix) {
+	if (!prefix) return "--";
+	const trimmed = prefix.trim();
+	if (!trimmed || trimmed === "--") return "--";
+	if (trimmed.startsWith("--")) return trimmed.endsWith("-") ? trimmed : `${trimmed}-`;
+	return `--${trimmed.replace(/^-+/, "")}${trimmed.endsWith("-") ? "" : "-"}`;
+}
+function normalizeTokenKey(key) {
+	return key.trim().replace(/([a-z\d])([A-Z])/g, "$1-$2").replace(/([a-zA-Z])(\d+)/g, "$1-$2").replace(/(\d+)([a-zA-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+function normalizeTokenMap(tokens) {
+	if (!tokens || typeof tokens !== "object") return {};
+	const normalized = {};
+	for (const [key, value] of Object.entries(tokens)) {
+		if (typeof value !== "string" && typeof value !== "number") continue;
+		const normalizedKey = normalizeTokenKey(key);
+		if (!normalizedKey) continue;
+		normalized[normalizedKey] = typeof value === "string" ? value.trim() : value;
+	}
+	return normalized;
+}
+function normalizeComponentTokenMap(components) {
+	if (!components || typeof components !== "object") return {};
+	const normalized = {};
+	for (const [componentName, tokenMap] of Object.entries(components)) {
+		const normalizedName = normalizeTokenKey(componentName);
+		if (!normalizedName) continue;
+		const normalizedTokens = normalizeTokenMap(tokenMap);
+		if (Object.keys(normalizedTokens).length) normalized[normalizedName] = normalizedTokens;
+	}
+	return normalized;
+}
+function collectLegacyRootTokens(theme) {
+	return normalizeTokenMap(Object.fromEntries(Object.entries(theme).filter(([key, value]) => {
+		if (RESERVED_THEME_KEYS.has(key)) return false;
+		return typeof value === "string" || typeof value === "number";
+	})));
+}
+function normalizeTheme(theme) {
+	var _theme$tokens, _theme$meta, _theme$meta$schemaVer, _theme$meta2, _theme$meta$cssVarPre, _theme$meta3, _theme$components;
+	if (!theme || typeof theme !== "object") return {
+		tokens: {},
+		components: {},
+		meta: DEFAULT_THEME_META
+	};
+	const themeTokens = normalizeTokenMap((_theme$tokens = theme.tokens) !== null && _theme$tokens !== void 0 ? _theme$tokens : theme.token);
+	const legacyRootTokens = collectLegacyRootTokens(theme);
+	const meta = {
+		name: (_theme$meta = theme.meta) === null || _theme$meta === void 0 ? void 0 : _theme$meta.name,
+		schemaVersion: (_theme$meta$schemaVer = (_theme$meta2 = theme.meta) === null || _theme$meta2 === void 0 ? void 0 : _theme$meta2.schemaVersion) !== null && _theme$meta$schemaVer !== void 0 ? _theme$meta$schemaVer : DEFAULT_THEME_META.schemaVersion,
+		cssVarPrefix: normalizeCssVarPrefix((_theme$meta$cssVarPre = (_theme$meta3 = theme.meta) === null || _theme$meta3 === void 0 ? void 0 : _theme$meta3.cssVarPrefix) !== null && _theme$meta$cssVarPre !== void 0 ? _theme$meta$cssVarPre : DEFAULT_THEME_META.cssVarPrefix)
+	};
+	return {
+		tokens: _objectSpread2(_objectSpread2({}, legacyRootTokens), themeTokens),
+		components: normalizeComponentTokenMap((_theme$components = theme.components) !== null && _theme$components !== void 0 ? _theme$components : theme.component),
+		meta
+	};
+}
+function getThemeCSSVariables(theme) {
+	const cssVariables = {};
+	const prefix = theme.meta.cssVarPrefix;
+	for (const [tokenKey, tokenValue] of Object.entries(theme.tokens)) cssVariables[`${prefix}${tokenKey}`] = `${tokenValue}`;
+	for (const [componentName, tokenMap] of Object.entries(theme.components)) for (const [tokenKey, tokenValue] of Object.entries(tokenMap)) cssVariables[`${prefix}component-${componentName}-${tokenKey}`] = `${tokenValue}`;
+	return cssVariables;
+}
+function applyThemeCSSVariables(target, theme, previousKeys = /* @__PURE__ */ new Set()) {
+	const variableMap = getThemeCSSVariables(theme);
+	const nextKeys = new Set(Object.keys(variableMap));
+	for (const key of previousKeys) if (!nextKeys.has(key)) target.style.removeProperty(key);
+	for (const [key, value] of Object.entries(variableMap)) target.style.setProperty(key, value);
+	return nextKeys;
+}
+function clearThemeCSSVariables(target, keys) {
+	for (const key of keys) target.style.removeProperty(key);
+}
+//#endregion
+export { applyThemeCSSVariables, clearThemeCSSVariables, normalizeTheme };