@zboson/ui 0.0.0-stage → 0.0.1

package/dist/_util/warning.d.ts

@@ -0,0 +1,37 @@
+import { Ref } from "vue";
+//#region src/_util/warning.d.ts
+declare function noop(): void;
+declare function resetWarned(): void;
+declare const isDev: boolean;
+type Warning = (valid: boolean, component: string, message?: string) => void;
+declare const warning: Warning;
+type BaseTypeWarning = (valid: boolean,
+/**
+ * - deprecated: Some API will be removed in future but still support now.
+ * - usage: Some API usage is not correct.
+ * - breaking: Breaking change like API is removed.
+ */
+type: 'deprecated' | 'usage' | 'breaking', message?: string) => void;
+type TypeWarning = BaseTypeWarning & {
+  deprecated: (valid: boolean, oldProp: string, newProp: string, message?: string) => void;
+};
+interface WarningContextProps {
+  /**
+   * @descCN 设置警告等级，设置 `false` 时会将废弃相关信息聚合为单条信息。
+   * @descEN Set the warning level. When set to `false`, discard related information will be aggregated into a single message.
+   */
+  strict?: boolean;
+}
+interface WarningContextType {
+  strict: Ref<boolean | undefined>;
+}
+declare function useWarningProvider(props: WarningContextType): void;
+declare function useWarningContext(): any;
+/**
+ * This is a hook but we not named as `useWarning`
+ * since this is only used in development.
+ * We should always wrap this in `if (process.env.NODE_ENV !== 'production')` condition
+ */
+declare const devUseWarning: (component: string) => TypeWarning;
+//#endregion
+export { WarningContextProps, WarningContextType, warning as default, devUseWarning, isDev, noop, resetWarned, useWarningContext, useWarningProvider };

package/dist/_util/warning.js

@@ -0,0 +1,51 @@
+import { getCurrentInstance, inject, provide, ref } from "vue";
+import rcWarning, { resetWarned as resetWarned$1 } from "@v-c/util/dist/warning";
+//#region src/_util/warning.ts
+function noop() {}
+let deprecatedWarnList = null;
+function resetWarned() {
+	deprecatedWarnList = null;
+	resetWarned$1();
+}
+const isDev = process.env.NODE_ENV !== "production";
+let _warning = noop;
+if (isDev) _warning = (valid, component, message) => {
+	rcWarning(valid, `[antd: ${component}] ${message}`);
+	if (isDev) resetWarned();
+};
+const warning = _warning;
+const WarningContextKey = Symbol("WarningContext");
+function useWarningProvider(props) {
+	provide(WarningContextKey, props);
+}
+function useWarningContext() {
+	if (!getCurrentInstance()) return {};
+	return inject(WarningContextKey, { strict: ref(true) });
+}
+/**
+* This is a hook but we not named as `useWarning`
+* since this is only used in development.
+* We should always wrap this in `if (process.env.NODE_ENV !== 'production')` condition
+*/
+const devUseWarning = isDev ? (component) => {
+	const { strict } = useWarningContext();
+	const typeWarning = (valid, type, message) => {
+		if (!valid) if (strict?.value === false && type === "deprecated") {
+			const existWarning = deprecatedWarnList;
+			if (!deprecatedWarnList) deprecatedWarnList = {};
+			deprecatedWarnList[component] = deprecatedWarnList[component] || [];
+			if (!deprecatedWarnList[component].includes(message || "")) deprecatedWarnList[component].push(message || "");
+			if (!existWarning) console.warn("[antd] There exists deprecated usage in your code:", deprecatedWarnList);
+		} else warning(valid, component, message);
+	};
+	typeWarning.deprecated = (valid, oldProp, newProp, message) => {
+		typeWarning(valid, "deprecated", `\`${oldProp}\` is deprecated. Please use \`${newProp}\` instead.${message ? ` ${message}` : ""}`);
+	};
+	return typeWarning;
+} : () => {
+	const noopWarning = () => {};
+	noopWarning.deprecated = noop;
+	return noopWarning;
+};
+//#endregion
+export { warning as default, devUseWarning, isDev, noop, resetWarned, useWarningContext, useWarningProvider };

package/dist/_util/wave/WaveEffect.d.ts

@@ -0,0 +1,44 @@
+import { ShowWaveEffect, WaveComponent } from "./interface.js";
+import { WaveProps } from "./index.js";
+import { PropType } from "vue";
+//#region src/_util/wave/WaveEffect.d.ts
+declare const WaveEffect: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  className: {
+    type: StringConstructor;
+    required: true;
+  };
+  target: {
+    type: PropType<HTMLElement>;
+    required: true;
+  };
+  component: {
+    type: PropType<WaveComponent>;
+    required: false;
+  };
+  colorSource: {
+    type: PropType<WaveProps["colorSource"]>;
+    required: false;
+  };
+}>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "finish"[], "finish", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  className: {
+    type: StringConstructor;
+    required: true;
+  };
+  target: {
+    type: PropType<HTMLElement>;
+    required: true;
+  };
+  component: {
+    type: PropType<WaveComponent>;
+    required: false;
+  };
+  colorSource: {
+    type: PropType<WaveProps["colorSource"]>;
+    required: false;
+  };
+}>> & Readonly<{
+  onFinish?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const showWaveEffect: ShowWaveEffect;
+//#endregion
+export { WaveEffect, showWaveEffect as default };

package/dist/_util/wave/WaveEffect.js

@@ -0,0 +1,183 @@
+import { useConfig } from "../../config-provider/context.js";
+import { genCssVar } from "../../theme/util/genStyleUtils.js";
+import { TARGET_CLS } from "./interface.js";
+import { getTargetWaveColor } from "./util.js";
+import { computed, createVNode, defineComponent, nextTick, onBeforeUnmount, ref, render, shallowRef, watch } from "vue";
+import { classNames } from "@v-c/util";
+import raf from "@v-c/util/dist/raf";
+//#region src/_util/wave/WaveEffect.tsx
+function validateNum(value) {
+	return Number.isNaN(value) ? 0 : value;
+}
+const WaveEffect = /* @__PURE__ */ defineComponent({
+	name: "WaveEffect",
+	inheritAttrs: false,
+	props: {
+		className: {
+			type: String,
+			required: true
+		},
+		target: {
+			type: Object,
+			required: true
+		},
+		component: {
+			type: String,
+			required: false
+		},
+		colorSource: {
+			type: String,
+			required: false
+		}
+	},
+	emits: ["finish"],
+	setup(props, { emit }) {
+		const configCtx = useConfig();
+		const rootPrefixCls = computed(() => configCtx.value.getPrefixCls());
+		const waveVarName = computed(() => genCssVar(rootPrefixCls.value, "wave")[0]);
+		const divRef = shallowRef();
+		const waveColor = ref(null);
+		const borderRadius = ref([]);
+		const left = ref(0);
+		const top = ref(0);
+		const width = ref(0);
+		const height = ref(0);
+		const enabled = ref(false);
+		const finished = ref(false);
+		const waveStyle = computed(() => {
+			const style = {
+				left: `${left.value}px`,
+				top: `${top.value}px`,
+				width: `${width.value}px`,
+				height: `${height.value}px`,
+				borderRadius: borderRadius.value.map((radius) => `${radius}px`).join(" ")
+			};
+			if (waveColor.value) style[waveVarName.value("color")] = waveColor.value;
+			return style;
+		});
+		const isSmallComponent = computed(() => {
+			return (props.component === "Checkbox" || props.component === "Radio") && props.target?.classList.contains(TARGET_CLS);
+		});
+		const classes = computed(() => {
+			return classNames(props.className, { "wave-quick": isSmallComponent.value });
+		});
+		function emitFinish() {
+			if (finished.value) return;
+			finished.value = true;
+			emit("finish");
+		}
+		function syncPos(target = props.target) {
+			if (!target) return;
+			const nodeStyle = getComputedStyle(target);
+			waveColor.value = getTargetWaveColor(target, props.colorSource);
+			const isStatic = nodeStyle.position === "static";
+			const { borderLeftWidth, borderTopWidth } = nodeStyle;
+			left.value = isStatic ? target.offsetLeft : validateNum(-Number.parseFloat(borderLeftWidth));
+			top.value = isStatic ? target.offsetTop : validateNum(-Number.parseFloat(borderTopWidth));
+			width.value = target.offsetWidth;
+			height.value = target.offsetHeight;
+			const { borderTopLeftRadius, borderTopRightRadius, borderBottomRightRadius, borderBottomLeftRadius } = nodeStyle;
+			borderRadius.value = [
+				validateNum(Number.parseFloat(borderTopLeftRadius)),
+				validateNum(Number.parseFloat(borderTopRightRadius)),
+				validateNum(Number.parseFloat(borderBottomRightRadius)),
+				validateNum(Number.parseFloat(borderBottomLeftRadius))
+			];
+		}
+		function triggerEffect() {
+			const element = divRef.value;
+			if (!element) return;
+			element.classList.remove("wave-motion-appear");
+			element.classList.remove("wave-motion-appear-active");
+			element.offsetHeight;
+			element.classList.add("wave-motion-appear");
+			element.classList.add("wave-motion-appear-active");
+		}
+		const rafId = ref();
+		let resizeObserver;
+		let deadlineId;
+		const handleTransitionEnd = (event) => {
+			if (event.target !== divRef.value) return;
+			if (event.propertyName === "opacity") emitFinish();
+		};
+		watch(() => divRef.value, (newEl, oldEl) => {
+			oldEl?.removeEventListener("transitionend", handleTransitionEnd);
+			newEl?.addEventListener("transitionend", handleTransitionEnd);
+		}, { immediate: true });
+		function stopEffectSync() {
+			if (rafId.value !== void 0) {
+				raf.cancel(rafId.value);
+				rafId.value = void 0;
+			}
+			resizeObserver?.disconnect();
+			resizeObserver = void 0;
+			if (deadlineId !== void 0) {
+				window.clearTimeout(deadlineId);
+				deadlineId = void 0;
+			}
+		}
+		watch(() => props.target, (target, _, onCleanup) => {
+			if (!target) return;
+			let active = true;
+			rafId.value = raf(() => {
+				if (!active) return;
+				syncPos(target);
+				enabled.value = true;
+				nextTick(() => {
+					if (!active) return;
+					triggerEffect();
+					deadlineId = window.setTimeout(() => {
+						emitFinish();
+					}, 5e3);
+				});
+			});
+			if (typeof ResizeObserver !== "undefined") {
+				resizeObserver = new ResizeObserver(() => {
+					syncPos(target);
+				});
+				resizeObserver.observe(target);
+			}
+			onCleanup(() => {
+				active = false;
+				stopEffectSync();
+			});
+		}, { immediate: true });
+		onBeforeUnmount(() => {
+			stopEffectSync();
+			emitFinish();
+		});
+		return () => {
+			if (!enabled.value) return null;
+			return createVNode("div", {
+				"ref": divRef,
+				"class": classes.value,
+				"style": waveStyle.value
+			}, null);
+		};
+	}
+});
+const showWaveEffect = (target, info) => {
+	const { component } = info;
+	if (component === "Checkbox" && !target.querySelector("input")?.checked) return;
+	const holder = (target.ownerDocument ?? document).createElement("div");
+	holder.style.position = "absolute";
+	holder.style.left = "0px";
+	holder.style.top = "0px";
+	target.insertBefore(holder, target.firstChild);
+	let unmounted = false;
+	const destroy = () => {
+		if (unmounted) return;
+		unmounted = true;
+		render(null, holder);
+		holder.remove();
+	};
+	render(createVNode(WaveEffect, {
+		className: info.className,
+		target,
+		component,
+		colorSource: info.colorSource,
+		onFinish: destroy
+	}), holder);
+};
+//#endregion
+export { WaveEffect, showWaveEffect as default };

package/dist/_util/wave/index.d.ts

@@ -0,0 +1,16 @@
+import { WaveColorSource, WaveComponent } from "./interface.js";
+import { SlotsType } from "vue";
+//#region src/_util/wave/index.d.ts
+interface WaveProps extends WaveEmitsProps {
+  disabled?: boolean;
+  component?: WaveComponent;
+  colorSource?: WaveColorSource;
+}
+interface WaveEmits {}
+interface WaveEmitsProps {}
+interface WaveSlots {
+  default?: () => any;
+}
+declare const _default: import("vue").DefineSetupFnComponent<WaveProps, WaveEmits, SlotsType<WaveSlots>, WaveProps, import("vue").PublicProps>;
+//#endregion
+export { WaveEmits, WaveEmitsProps, WaveProps, WaveSlots, _default as default };

package/dist/_util/wave/index.js

@@ -0,0 +1,95 @@
+import { useConfig } from "../../config-provider/context.js";
+import { useStyleToken } from "../../theme/util/genStyleUtils.js";
+import style_default from "./style.js";
+import useWave from "./useWave.js";
+import { cloneVNode, computed, defineComponent, isVNode, onBeforeUnmount, onMounted, shallowRef, watch } from "vue";
+import { classNames } from "@v-c/util";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+import { unrefElement } from "@vueuse/core";
+//#region src/_util/wave/index.tsx
+const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+const TRIGGER_TYPE_TO_EVENT_MAP = {
+	click: "click",
+	mousedown: "mousedown",
+	mouseup: "mouseup",
+	pointerdown: "pointerdown",
+	pointerup: "pointerup"
+};
+function isVisible(element) {
+	if (!isBrowser) return false;
+	if (!element) return false;
+	if (element === document.body) return true;
+	if (element.offsetWidth || element.offsetHeight || element.getClientRects().length) return true;
+	const style = getComputedStyle(element);
+	return style.display !== "none" && style.visibility !== "hidden";
+}
+var wave_default = /* @__PURE__ */ defineComponent((props, { slots }) => {
+	const configCtx = useConfig();
+	const containerRef = shallowRef(null);
+	const prefixCls = computed(() => configCtx.value.getPrefixCls("wave"));
+	const tokenResult = useStyleToken();
+	const hashId = style_default(prefixCls, void 0, tokenResult);
+	const colorSource = computed(() => props.colorSource);
+	const showWave = useWave(containerRef, computed(() => classNames(prefixCls.value, hashId.value)), computed(() => props.component), colorSource, tokenResult);
+	const handleEvent = (event) => {
+		const node = containerRef.value;
+		if (!node) return;
+		const target = event.target;
+		if (!isVisible(target)) return;
+		const nodeCls = typeof node.className === "string" ? node.className : String(node.className);
+		if (node.getAttribute?.("disabled") || node.disabled || nodeCls.includes("disabled") && !nodeCls.includes("disabled:") || node.getAttribute?.("aria-disabled") === "true" || nodeCls.includes("-leave")) return;
+		showWave(event);
+	};
+	let teardown = null;
+	const attachListener = () => {
+		teardown?.();
+		teardown = null;
+		const node = containerRef.value;
+		if (!node || node.nodeType !== 1 || props.disabled) return;
+		const triggerType = configCtx.value.wave?.triggerType;
+		const eventName = triggerType && triggerType in TRIGGER_TYPE_TO_EVENT_MAP ? TRIGGER_TYPE_TO_EVENT_MAP[triggerType] : "click";
+		node.addEventListener(eventName, handleEvent, true);
+		teardown = () => node.removeEventListener(eventName, handleEvent, true);
+	};
+	onMounted(attachListener);
+	watch([
+		containerRef,
+		() => props.disabled,
+		() => configCtx.value.wave?.triggerType
+	], attachListener);
+	onBeforeUnmount(() => {
+		teardown?.();
+		teardown = null;
+	});
+	const mergedRef = (el, node) => {
+		const _el = unrefElement(el);
+		if (_el) containerRef.value = _el;
+		if (node.ref) {
+			if (typeof node.ref === "function") node.ref(_el);
+			else if (typeof node.ref === "object" && "value" in node.ref?.r) node.ref.r.value = _el;
+		}
+	};
+	return () => {
+		const children = filterEmpty(slots.default?.() ?? []);
+		if (children.length !== 1) return children;
+		const child = children[0];
+		if (!isVNode(child)) return child;
+		return cloneVNode(child, { ref: (el) => mergedRef(el, child) });
+	};
+}, { props: {
+	disabled: {
+		type: Boolean,
+		required: false,
+		default: void 0
+	},
+	component: {
+		type: String,
+		required: false
+	},
+	colorSource: {
+		type: [String, null],
+		required: false
+	}
+} });
+//#endregion
+export { wave_default as default };

package/dist/_util/wave/interface.d.ts

@@ -0,0 +1,17 @@
+import { GlobalToken } from "../../theme/interface/cssinjs-utils.js";
+import "../../theme/internal.js";
+//#region src/_util/wave/interface.d.ts
+declare const TARGET_CLS = "ant-wave-target";
+type WaveComponent = 'Tag' | 'Button' | 'Checkbox' | 'Radio' | 'Switch' | 'Steps';
+type WaveColorSource = 'color' | 'backgroundColor' | 'borderColor' | null;
+type ShowWaveEffect = (element: HTMLElement, info: {
+  className: string;
+  token: GlobalToken;
+  component?: WaveComponent;
+  colorSource?: WaveColorSource;
+  event: MouseEvent;
+  hashId: string;
+}) => void;
+type ShowWave = (event: MouseEvent) => void;
+//#endregion
+export { ShowWave, ShowWaveEffect, TARGET_CLS, WaveColorSource, WaveComponent };

package/dist/_util/wave/interface.js

@@ -0,0 +1,5 @@
+import "../../config-provider/context.js";
+//#region src/_util/wave/interface.ts
+const TARGET_CLS = `ant-wave-target`;
+//#endregion
+export { TARGET_CLS };

package/dist/_util/wave/style.d.ts

@@ -0,0 +1,12 @@
+import { SeedToken } from "../../theme/interface/seeds.js";
+import { AliasToken } from "../../theme/interface/alias.js";
+import { ComponentTokenMap } from "../../theme/interface/components.js";
+import { FullToken } from "../../theme/interface/cssinjs-utils.js";
+import "../../theme/interface/index.js";
+import "../../theme/internal.js";
+//#region src/_util/wave/style.d.ts
+interface ComponentToken {}
+interface WaveToken extends FullToken<'Wave'> {}
+declare const _default: (prefixCls: import("vue").Ref<string>, rootCls?: import("vue").Ref<string | undefined>, tokenResult?: import("@antdv-next/cssinjs").UseTokenReturn<ComponentTokenMap, AliasToken, SeedToken> | undefined) => import("vue").Ref<string, string>;
+//#endregion
+export { ComponentToken, WaveToken, _default as default };

package/dist/_util/wave/style.js

@@ -0,0 +1,26 @@
+import { genComponentStyleHook, genCssVar } from "../../theme/util/genStyleUtils.js";
+//#region src/_util/wave/style.ts
+const genWaveStyle = (token) => {
+	const { componentCls, colorPrimary, motionDurationSlow, motionEaseInOut, motionEaseOutCirc, antCls } = token;
+	const [, varRef] = genCssVar(antCls, "wave");
+	return { [componentCls]: {
+		position: "absolute",
+		background: "transparent",
+		pointerEvents: "none",
+		boxSizing: "border-box",
+		color: varRef("color", colorPrimary),
+		boxShadow: `0 0 0 0 currentcolor`,
+		opacity: .2,
+		"&.wave-motion-appear": {
+			transition: [`box-shadow 0.4s`, `opacity 2s`].map((prop) => `${prop} ${motionEaseOutCirc}`).join(","),
+			"&-active": {
+				boxShadow: `0 0 0 6px currentcolor`,
+				opacity: 0
+			},
+			"&.wave-quick": { transition: [`box-shadow`, `opacity`].map((prop) => `${prop} ${motionDurationSlow} ${motionEaseInOut}`).join(",") }
+		}
+	} };
+};
+var style_default = genComponentStyleHook("Wave", genWaveStyle);
+//#endregion
+export { style_default as default };

package/dist/_util/wave/useWave.d.ts

@@ -0,0 +1,8 @@
+import { StyleTokenResult } from "../../theme/util/genStyleUtils.js";
+import { ShowWave, WaveComponent } from "./interface.js";
+import { WaveProps } from "./index.js";
+import { Ref } from "vue";
+//#region src/_util/wave/useWave.d.ts
+declare function useWave(nodeRef: Ref<HTMLElement | null | undefined>, className: string | Ref<string>, component?: WaveComponent | Ref<WaveComponent | undefined>, colorSource?: Ref<WaveProps['colorSource']>, tokenResult?: StyleTokenResult): ShowWave;
+//#endregion
+export { useWave as default };

package/dist/_util/wave/useWave.js

@@ -0,0 +1,41 @@
+import { useConfig } from "../../config-provider/context.js";
+import { useStyleToken } from "../../theme/util/genStyleUtils.js";
+import { TARGET_CLS } from "./interface.js";
+import showWaveEffect from "./WaveEffect.js";
+import { onBeforeUnmount, ref, unref } from "vue";
+import raf from "@v-c/util/dist/raf";
+//#region src/_util/wave/useWave.ts
+function useWave(nodeRef, className, component, colorSource, tokenResult = useStyleToken()) {
+	const configCtx = useConfig();
+	const token = tokenResult.realToken;
+	const hashId = tokenResult.hashId;
+	const showWave = (event) => {
+		const node = nodeRef.value;
+		if (!node) return;
+		const waveConfig = configCtx.value.wave;
+		if (waveConfig?.disabled) return;
+		const targetNode = node.querySelector(`.${TARGET_CLS}`) || node;
+		const { showEffect } = waveConfig ?? {};
+		(showEffect || showWaveEffect)(targetNode, {
+			className: unref(className),
+			token: token.value,
+			component: unref(component) ?? void 0,
+			event,
+			hashId: hashId.value,
+			colorSource: colorSource ? unref(colorSource) : void 0
+		});
+	};
+	const rafId = ref();
+	const showDebounceWave = (event) => {
+		if (rafId.value !== void 0) raf.cancel(rafId.value);
+		rafId.value = raf(() => {
+			showWave(event);
+		});
+	};
+	onBeforeUnmount(() => {
+		if (rafId.value !== void 0) raf.cancel(rafId.value);
+	});
+	return showDebounceWave;
+}
+//#endregion
+export { useWave as default };

package/dist/_util/wave/util.d.ts

@@ -0,0 +1,5 @@
+//#region src/_util/wave/util.d.ts
+declare function isValidWaveColor(color: CSSStyleDeclaration[keyof CSSStyleDeclaration]): color is string;
+declare function getTargetWaveColor(node: HTMLElement, colorSource?: keyof CSSStyleDeclaration | null): any;
+//#endregion
+export { getTargetWaveColor, isValidWaveColor };

package/dist/_util/wave/util.js

@@ -0,0 +1,16 @@
+//#region src/_util/wave/util.ts
+function isValidWaveColor(color) {
+	return !!color && typeof color === "string" && color !== "#fff" && color !== "#ffffff" && color !== "rgb(255, 255, 255)" && color !== "rgba(255, 255, 255, 1)" && !/rgba\((?:\d*, ){3}0\)/i.test(color) && !/^#(?:[0-9a-f]{3}0|[0-9a-f]{6}00)$/i.test(color) && color !== "transparent" && color !== "canvastext";
+}
+function getTargetWaveColor(node, colorSource = null) {
+	const style = getComputedStyle(node);
+	const { borderTopColor, borderColor, backgroundColor } = style;
+	if (colorSource && isValidWaveColor(style[colorSource])) return style[colorSource];
+	return [
+		borderTopColor,
+		borderColor,
+		backgroundColor
+	].find(isValidWaveColor) ?? null;
+}
+//#endregion
+export { getTargetWaveColor, isValidWaveColor };

package/dist/_util/zindexContext.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from "vue";
+//#region src/_util/zindexContext.d.ts
+declare function useZIndexContext(): Ref<number | null | undefined, number | null | undefined>;
+declare function useZIndexProvider(zIndex: Ref<number | undefined>): void;
+declare const ZIndexProvider: import("vue").DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import("vue").PublicProps>;
+//#endregion
+export { ZIndexProvider, useZIndexContext, useZIndexProvider };

package/dist/_util/zindexContext.js

@@ -0,0 +1,19 @@
+import { computed, defineComponent, inject, provide, ref } from "vue";
+//#region src/_util/zindexContext.ts
+const ZIndexContextKey = Symbol("ZIndexContextKey");
+function useZIndexContext() {
+	return inject(ZIndexContextKey, ref(void 0));
+}
+function useZIndexProvider(zIndex) {
+	provide(ZIndexContextKey, zIndex);
+}
+const ZIndexProvider = defineComponent((props, { slots }) => {
+	useZIndexProvider(computed(() => {
+		return props.value;
+	}));
+	return () => {
+		return slots?.default?.();
+	};
+}, { props: ["value"] });
+//#endregion
+export { ZIndexProvider, useZIndexContext, useZIndexProvider };

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/affix/index.d.ts

@@ -0,0 +1,28 @@
+import throttleByAnimationFrame from "../_util/throttleByAnimationFrame.js";
+import { ComponentBaseProps } from "../config-provider/context.js";
+//#region src/affix/index.d.ts
+interface AffixProps extends ComponentBaseProps, AffixEmitsProps {
+  /** Triggered when the specified offset is reached from the top of the window */
+  offsetTop?: number;
+  /** Triggered when the specified offset is reached from the bottom of the window */
+  offsetBottom?: number;
+  /** Set the element that Affix needs to listen to its scroll event, the value is a function that returns the corresponding DOM element */
+  target?: () => Window | HTMLElement | null;
+}
+interface AffixEmits {
+  change: (affixed: boolean) => void;
+}
+interface AffixEmitsProps {
+  onChange?: AffixEmits['change'];
+}
+interface AffixRef {
+  updatePosition: ReturnType<typeof throttleByAnimationFrame>;
+}
+type InternalAffixProps = AffixProps & {
+  onTestUpdatePosition?: any;
+};
+declare const Affix: import("vue").DefineSetupFnComponent<InternalAffixProps, AffixEmits, {}, AffixProps & {
+  onTestUpdatePosition?: any;
+}, import("vue").PublicProps>;
+//#endregion
+export { Affix, Affix as default, AffixEmits, AffixEmitsProps, AffixProps, AffixRef };