@zboson/ui 0.0.0-stage → 0.0.1

package/dist/_util/responsiveObserver.js

@@ -0,0 +1,105 @@
+import useToken from "../theme/useToken.js";
+import { addMediaQueryListener, removeMediaQueryListener } from "./mediaQueryUtil.js";
+import { computed } from "vue";
+//#region src/_util/responsiveObserver.ts
+const responsiveArray = [
+	"xxxl",
+	"xxl",
+	"xl",
+	"lg",
+	"md",
+	"sm",
+	"xs"
+];
+const responsiveArrayReversed = [...responsiveArray].reverse();
+function getResponsiveMap(token) {
+	return {
+		xs: `(max-width: ${token.screenXSMax}px)`,
+		sm: `(min-width: ${token.screenSM}px)`,
+		md: `(min-width: ${token.screenMD}px)`,
+		lg: `(min-width: ${token.screenLG}px)`,
+		xl: `(min-width: ${token.screenXL}px)`,
+		xxl: `(min-width: ${token.screenXXL}px)`,
+		xxxl: `(min-width: ${token.screenXXXL}px)`
+	};
+}
+/**
+* Ensures that the breakpoints token are valid, in good order
+* For each breakpoint : screenMin <= screen <= screenMax and screenMax <= nextScreenMin
+*/
+function validateBreakpoints(token) {
+	const indexableToken = token;
+	const revBreakpoints = [...responsiveArray].reverse();
+	revBreakpoints.forEach((breakpoint, i) => {
+		const breakpointUpper = breakpoint.toUpperCase();
+		const screenMin = `screen${breakpointUpper}Min`;
+		const screen = `screen${breakpointUpper}`;
+		if (!(indexableToken[screenMin] <= indexableToken[screen])) throw new Error(`${screenMin}<=${screen} fails : !(${indexableToken[screenMin]}<=${indexableToken[screen]})`);
+		if (i < revBreakpoints.length - 1) {
+			const screenMax = `screen${breakpointUpper}Max`;
+			if (!(indexableToken[screen] <= indexableToken[screenMax])) throw new Error(`${screen}<=${screenMax} fails : !(${indexableToken[screen]}<=${indexableToken[screenMax]})`);
+			const nextScreenMin = `screen${revBreakpoints[i + 1].toUpperCase()}Min`;
+			if (!(indexableToken[screenMax] <= indexableToken[nextScreenMin])) throw new Error(`${screenMax}<=${nextScreenMin} fails : !(${indexableToken[screenMax]}<=${indexableToken[nextScreenMin]})`);
+		}
+	});
+	return token;
+}
+function matchScreen(screens, screenSizes) {
+	if (!screenSizes) return;
+	for (const breakpoint of responsiveArray) if (screens[breakpoint] && screenSizes?.[breakpoint] !== void 0) return screenSizes[breakpoint];
+}
+function useResponsiveObserver() {
+	const [, token] = useToken();
+	return computed(() => {
+		const responsiveMap = getResponsiveMap(validateBreakpoints(token.value));
+		const subscribers = /* @__PURE__ */ new Map();
+		let subUid = -1;
+		let screens = {};
+		return {
+			responsiveMap,
+			matchHandlers: {},
+			dispatch(pointMap) {
+				screens = pointMap;
+				subscribers.forEach((func) => func(screens));
+				return subscribers.size >= 1;
+			},
+			subscribe(func) {
+				if (!subscribers.size) this.register();
+				subUid += 1;
+				subscribers.set(subUid, func);
+				func(screens);
+				return subUid;
+			},
+			unsubscribe(paramToken) {
+				subscribers.delete(paramToken);
+				if (!subscribers.size) this.unregister();
+			},
+			register() {
+				Object.entries(responsiveMap).forEach(([screen, mediaQuery]) => {
+					const listener = ({ matches }) => {
+						this.dispatch({
+							...screens,
+							[screen]: matches
+						});
+					};
+					const mql = window.matchMedia(mediaQuery);
+					addMediaQueryListener(mql, listener);
+					this.matchHandlers[mediaQuery] = {
+						mql,
+						listener
+					};
+					listener(mql);
+				});
+			},
+			unregister() {
+				Object.values(responsiveMap).forEach((mediaQuery) => {
+					const handler = this.matchHandlers[mediaQuery];
+					removeMediaQueryListener(handler?.mql, handler?.listener);
+				});
+				subscribers.clear();
+			}
+		};
+	});
+}
+//#endregion
+export { useResponsiveObserver as default, matchScreen, responsiveArray, responsiveArrayReversed };

package/dist/_util/scrollTo.d.ts

@@ -0,0 +1,12 @@
+//#region src/_util/scrollTo.d.ts
+interface ScrollToOptions {
+  /** Scroll container, default as window */
+  getContainer?: () => HTMLElement | Window | Document;
+  /** Scroll end callback */
+  callback?: () => void;
+  /** Animation duration, default as 450 */
+  duration?: number;
+}
+declare function scrollTo(y: number, options?: ScrollToOptions): () => void;
+//#endregion
+export { scrollTo as default };

package/dist/_util/scrollTo.js

@@ -0,0 +1,34 @@
+import getScroll, { isDocument, isWindow } from "./getScroll.js";
+import { easeInOutCubic } from "./easings.js";
+import raf from "@v-c/util/dist/raf";
+//#region src/_util/scrollTo.ts
+function scrollTo(y, options = {}) {
+	const { getContainer = () => window, callback, duration = 450 } = options;
+	const container = getContainer();
+	const scrollTop = getScroll(container);
+	const scroll = (top) => {
+		if (isWindow(container)) container.scrollTo(window.pageXOffset, top);
+		else if (isDocument(container)) container.documentElement.scrollTop = top;
+		else container.scrollTop = top;
+	};
+	if (duration <= 0) {
+		scroll(y);
+		if (typeof callback === "function") callback();
+		return () => {};
+	}
+	const startTime = Date.now();
+	let rafId;
+	const frameFunc = () => {
+		const time = Date.now() - startTime;
+		const nextScrollTop = easeInOutCubic(time > duration ? duration : time, scrollTop, y, duration);
+		scroll(nextScrollTop);
+		if (time < duration) rafId = raf(frameFunc);
+		else if (typeof callback === "function") callback();
+	};
+	rafId = raf(frameFunc);
+	return () => {
+		raf.cancel(rafId);
+	};
+}
+//#endregion
+export { scrollTo as default };

package/dist/_util/statusUtils.d.ts

@@ -0,0 +1,8 @@
+import { ValidateStatus } from "../form/FormItem/index.js";
+//#region src/_util/statusUtils.d.ts
+declare const _InputStatuses: readonly ["warning", "error", "", "success", "validating"];
+type InputStatus = (typeof _InputStatuses)[number];
+declare function getStatusClassNames(prefixCls: string, status?: ValidateStatus, hasFeedback?: boolean): string;
+declare function getMergedStatus(contextStatus?: ValidateStatus, customStatus?: InputStatus): "" | "success" | "warning" | "error" | "validating" | undefined;
+//#endregion
+export { InputStatus, getMergedStatus, getStatusClassNames };

package/dist/_util/statusUtils.js

@@ -0,0 +1,16 @@
+import { clsx } from "@v-c/util";
+//#region src/_util/statusUtils.ts
+function getStatusClassNames(prefixCls, status, hasFeedback) {
+	return clsx({
+		[`${prefixCls}-status-success`]: status === "success",
+		[`${prefixCls}-status-warning`]: status === "warning",
+		[`${prefixCls}-status-error`]: status === "error",
+		[`${prefixCls}-status-validating`]: status === "validating",
+		[`${prefixCls}-has-feedback`]: hasFeedback
+	});
+}
+function getMergedStatus(contextStatus, customStatus) {
+	return customStatus || contextStatus;
+}
+//#endregion
+export { getMergedStatus, getStatusClassNames };

package/dist/_util/styleChecker.d.ts

@@ -0,0 +1,6 @@
+import { isStyleSupport as isStyleSupport$1 } from "@v-c/util/dist/Dom/styleChecker";
+//#region src/_util/styleChecker.d.ts
+declare const canUseDocElement: () => false | HTMLElement;
+declare const isStyleSupport: typeof isStyleSupport$1;
+//#endregion
+export { canUseDocElement, isStyleSupport as default, isStyleSupport };

package/dist/_util/styleChecker.js

@@ -0,0 +1,7 @@
+import canUseDom from "@v-c/util/dist/Dom/canUseDom";
+import { isStyleSupport as isStyleSupport$1 } from "@v-c/util/dist/Dom/styleChecker";
+//#region src/_util/styleChecker.ts
+const canUseDocElement = () => canUseDom() && window.document?.documentElement;
+const isStyleSupport = isStyleSupport$1;
+//#endregion
+export { canUseDocElement, isStyleSupport as default, isStyleSupport };

package/dist/_util/styleUtils.d.ts

@@ -0,0 +1,22 @@
+//#region src/_util/styleUtils.d.ts
+declare function formatUnit(value: string | number | undefined | null): string | undefined;
+/**
+ * Normalize a user-provided `style` (string | object | array of them) into a
+ * plain style object.
+ *
+ * Vue passes string styles through `props.style` untouched (a string is a
+ * legal vnode style, applied as `cssText`), so components that spread or
+ * merge the user style into an object must normalize it first: spreading a
+ * string produces numeric keys (`{0:'w', 1:'i', ...}`) which makes Vue's
+ * `patchStyle` throw "Failed to set an indexed property [0] on
+ * 'CSSStyleDeclaration'".
+ *
+ * Delegates to Vue's own `normalizeStyle`, which merges arrays (parsing each
+ * string entry with its parenthesis-aware cssText split, so values like
+ * `background-image: url("data:image/svg+xml;...")` stay intact). The only
+ * addition here is parsing a *top-level* string, which Vue intentionally
+ * leaves as-is because `patchStyle` can apply it directly as `cssText`.
+ */
+declare function normalizeStyle(style?: unknown): Record<PropertyKey, unknown> | undefined;
+//#endregion
+export { formatUnit, normalizeStyle };

package/dist/_util/styleUtils.js

@@ -0,0 +1,32 @@
+import { normalizeStyle as normalizeStyle$1 } from "vue";
+//#region src/_util/styleUtils.ts
+function formatUnit(value) {
+	if (value === void 0 || value === null) return;
+	if (typeof value === "number") return `${value}px`;
+	if (typeof value === "string" && !value.endsWith("px") && !Number.isNaN(Number(value))) return `${value}px`;
+	return value;
+}
+/**
+* Normalize a user-provided `style` (string | object | array of them) into a
+* plain style object.
+*
+* Vue passes string styles through `props.style` untouched (a string is a
+* legal vnode style, applied as `cssText`), so components that spread or
+* merge the user style into an object must normalize it first: spreading a
+* string produces numeric keys (`{0:'w', 1:'i', ...}`) which makes Vue's
+* `patchStyle` throw "Failed to set an indexed property [0] on
+* 'CSSStyleDeclaration'".
+*
+* Delegates to Vue's own `normalizeStyle`, which merges arrays (parsing each
+* string entry with its parenthesis-aware cssText split, so values like
+* `background-image: url("data:image/svg+xml;...")` stay intact). The only
+* addition here is parsing a *top-level* string, which Vue intentionally
+* leaves as-is because `patchStyle` can apply it directly as `cssText`.
+*/
+function normalizeStyle(style) {
+	const normalized = normalizeStyle$1(style);
+	if (typeof normalized === "string") return normalizeStyle$1([normalized]);
+	return normalized || void 0;
+}
+//#endregion
+export { formatUnit, normalizeStyle };

package/dist/_util/throttleByAnimationFrame.d.ts

@@ -0,0 +1,7 @@
+//#region src/_util/throttleByAnimationFrame.d.ts
+declare function throttleByAnimationFrame<T extends any[]>(fn: (...args: T) => void): {
+  (...args: T): void;
+  cancel(): void;
+};
+//#endregion
+export { throttleByAnimationFrame as default };

package/dist/_util/throttleByAnimationFrame.js

@@ -0,0 +1,19 @@
+import raf from "@v-c/util/dist/raf";
+//#region src/_util/throttleByAnimationFrame.ts
+function throttleByAnimationFrame(fn) {
+	let requestId = null;
+	const later = (args) => () => {
+		requestId = null;
+		fn(...args);
+	};
+	const throttled = (...args) => {
+		if (requestId === null) requestId = raf(later(args));
+	};
+	throttled.cancel = () => {
+		raf.cancel(requestId);
+		requestId = null;
+	};
+	return throttled;
+}
+//#endregion
+export { throttleByAnimationFrame as default };

package/dist/_util/toList.d.ts

@@ -0,0 +1,4 @@
+//#region src/_util/toList.d.ts
+declare function toList<T>(candidate: T | T[], skipEmpty?: boolean): T[];
+//#endregion
+export { toList as default };

package/dist/_util/toList.js

@@ -0,0 +1,7 @@
+//#region src/_util/toList.ts
+function toList(candidate, skipEmpty = false) {
+	if (skipEmpty && (candidate === void 0 || candidate === null)) return [];
+	return Array.isArray(candidate) ? candidate : [candidate];
+}
+//#endregion
+export { toList as default };

package/dist/_util/tools.d.ts

@@ -0,0 +1,24 @@
+import { Ref } from "vue";
+import { classNames } from "@v-c/util";
+//#region src/_util/tools.d.ts
+declare function getSlotPropFn(slots: any, props: any, key: string): any;
+declare function getSlotPropsFnRun(slots: any, props: any, key: string, isNull?: boolean, params?: any): any;
+/** Resolve a slot/prop render prop: slot first, empty slot (undefined / []) falls back to prop; explicit null is kept; function props are invoked, never leaked. */
+declare function getSlotPropsFnRunWithFallback(slots: any, props: any, key: string, params?: any): any;
+declare function toPropsRefs<T extends Record<string, any>, K extends keyof T>(obj: T, ...args: K[]): { [key in K]-?: Ref<T[key]>; };
+/**
+ * 返回一个「稳定引用」的事件转发器，调用时实时读取组件当前 vnode 上的监听器。
+ *
+ * 用途：解决「把 emit 事件回调按值捕获进子组件、之后才触发」导致的陈旧闭包问题。
+ * 当组件实例被复用且本次更新里只有事件回调发生了变化时（典型场景：无 `rowKey` 的
+ * 表格翻页后按位置复用行），Vue 的 `shouldUpdateComponent` 会把它当作「仅 emit 监听器
+ * 变化」而跳过该组件的重新渲染，于是渲染期捕获的回调会停留在旧值。
+ *
+ * 这里通过 `instance.vnode.props` 实时取值，而该字段在跳过更新时仍会被 `updateComponent`
+ * 同步为最新 vnode，因此永远拿到最新回调；同时保留处理函数的返回值（`emit` 会丢弃返回值，
+ * 故无法直接用 `emit` 替代——`ActionButton` 依赖 confirm 的返回值驱动异步 loading）。
+ */
+declare function useLiveListener<Args extends any[] = any[], R = any>(name: string): (...args: Args) => R | undefined;
+declare const clsx: typeof classNames;
+//#endregion
+export { clsx, getSlotPropFn, getSlotPropsFnRun, getSlotPropsFnRunWithFallback, toPropsRefs, useLiveListener };

package/dist/_util/tools.js

@@ -0,0 +1,66 @@
+import fallbackProp from "./fallbackProp.js";
+import { getCurrentInstance, toHandlerKey, toRef } from "vue";
+import { classNames } from "@v-c/util";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+//#region src/_util/tools.ts
+function getSlotPropFn(slots, props, key) {
+	const fn = slots[key] || props[key];
+	if (typeof fn === "function") return fn;
+	return () => [fn];
+}
+function getSlotPropsFnRun(slots, props, key, isNull = true, params) {
+	const fn = getSlotPropFn(slots, props, key);
+	if (typeof fn === "function") {
+		let node = fn?.(params);
+		if (!Array.isArray(node)) node = [node];
+		if (node && node.length === 1 && node[0] === null) return null;
+		const nodes = filterEmpty(node).filter((node) => node !== void 0 && node !== null);
+		if (nodes.length) {
+			if (nodes.length === 1) return nodes[0];
+			return nodes;
+		}
+		return isNull ? null : void 0;
+	}
+	return fn;
+}
+/** Resolve a slot/prop render prop: slot first, empty slot (undefined / []) falls back to prop; explicit null is kept; function props are invoked, never leaked. */
+function getSlotPropsFnRunWithFallback(slots, props, key, params) {
+	return fallbackProp(getSlotPropsFnRun(slots, {}, key, false, params), getSlotPropsFnRun({}, props, key, false, params));
+}
+function toPropsRefs(obj, ...args) {
+	const _res = {};
+	args.forEach((key) => {
+		_res[key] = toRef(obj, key);
+	});
+	return _res;
+}
+/**
+* 返回一个「稳定引用」的事件转发器，调用时实时读取组件当前 vnode 上的监听器。
+*
+* 用途：解决「把 emit 事件回调按值捕获进子组件、之后才触发」导致的陈旧闭包问题。
+* 当组件实例被复用且本次更新里只有事件回调发生了变化时（典型场景：无 `rowKey` 的
+* 表格翻页后按位置复用行），Vue 的 `shouldUpdateComponent` 会把它当作「仅 emit 监听器
+* 变化」而跳过该组件的重新渲染，于是渲染期捕获的回调会停留在旧值。
+*
+* 这里通过 `instance.vnode.props` 实时取值，而该字段在跳过更新时仍会被 `updateComponent`
+* 同步为最新 vnode，因此永远拿到最新回调；同时保留处理函数的返回值（`emit` 会丢弃返回值，
+* 故无法直接用 `emit` 替代——`ActionButton` 依赖 confirm 的返回值驱动异步 loading）。
+*/
+function useLiveListener(name) {
+	const instance = getCurrentInstance();
+	const handlerKey = toHandlerKey(name);
+	return (...args) => {
+		const handler = (instance?.vnode.props)?.[handlerKey];
+		if (Array.isArray(handler)) {
+			let result;
+			handler.forEach((fn) => {
+				if (typeof fn === "function") result = fn(...args);
+			});
+			return result;
+		}
+		return typeof handler === "function" ? handler(...args) : void 0;
+	};
+}
+const clsx = classNames;
+//#endregion
+export { clsx, getSlotPropFn, getSlotPropsFnRun, getSlotPropsFnRunWithFallback, toPropsRefs, useLiveListener };

package/dist/_util/transKeys.d.ts

@@ -0,0 +1,9 @@
+import { TransferKey } from "../transfer/interface.js";
+//#region src/_util/transKeys.d.ts
+declare function groupKeysMap(keys: TransferKey[]): Map<TransferKey, number>;
+declare function groupDisabledKeysMap<RecordType extends {
+  disabled?: boolean;
+  key?: TransferKey;
+}>(dataSource: RecordType[]): Map<TransferKey, number>;
+//#endregion
+export { groupDisabledKeysMap, groupKeysMap };

package/dist/_util/transKeys.js

@@ -0,0 +1,17 @@
+//#region src/_util/transKeys.ts
+function groupKeysMap(keys) {
+	const map = /* @__PURE__ */ new Map();
+	keys.forEach((key, index) => {
+		map.set(key, index);
+	});
+	return map;
+}
+function groupDisabledKeysMap(dataSource) {
+	const map = /* @__PURE__ */ new Map();
+	dataSource.forEach(({ disabled, key }, index) => {
+		if (disabled && key !== void 0) map.set(key, index);
+	});
+	return map;
+}
+//#endregion
+export { groupDisabledKeysMap, groupKeysMap };

package/dist/_util/type.d.ts

@@ -0,0 +1,15 @@
+import { VNode, VNodeChild } from "vue";
+//#region src/_util/type.d.ts
+type AnyObject = Record<string, any>;
+type EmptyObject = Record<never, never>;
+type RenderNodeFn<Args extends any[] = any[]> = (...args: Args) => VNodeChild;
+type VueNode<Args extends any[] = any[]> = RenderNodeFn<Args> | string | number | null | undefined | VNode | boolean;
+type EmitsArrToEvent<T extends Record<string, any>> = { [K in keyof T]: T[K] extends any[] ? (...args: T[K]) => void : T[K]; };
+type EmitsType<T extends Record<string, any>> = EmitsArrToEvent<T>;
+interface EmptyEmit {}
+type SlotsDefineType<T extends Record<string, any> = Record<string, any>> = {
+  default?: () => any;
+} & T;
+type ValidChar = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+//#endregion
+export { AnyObject, EmitsArrToEvent, EmitsType, EmptyEmit, EmptyObject, RenderNodeFn, SlotsDefineType, ValidChar, VueNode };

package/dist/_util/type.js

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

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

@@ -0,0 +1,8 @@
+import { VNode } from "vue";
+//#region src/_util/vnode/index.d.ts
+declare function resolveVNodeProps(vnode: VNode, name?: string, markerKey?: string): {
+  [x: string]: any;
+};
+declare function resolveSlotsNode<T = any>(slots: Record<string, any>, slotName: string, name?: string, markerKey?: string): T[];
+//#endregion
+export { resolveSlotsNode, resolveVNodeProps };

package/dist/_util/vnode/index.js

@@ -0,0 +1,152 @@
+import { Comment } from "vue";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+//#region src/_util/vnode/index.ts
+const EMPTY_OBJ = Object.freeze({});
+function hasOwn(obj, key) {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function isFunction(value) {
+	return typeof value === "function";
+}
+function camelize$1(str) {
+	return str.replace(/-(\w)/g, (_, c) => c ? c.toUpperCase() : "");
+}
+function hyphenate(str) {
+	return str.replace(/\B([A-Z])/g, "-$1").toLowerCase();
+}
+function isBooleanType(type) {
+	return isFunction(type) && type.name === "Boolean";
+}
+function isStringType(type) {
+	return isFunction(type) && type.name === "String";
+}
+function isReservedProp(key) {
+	return key === "key" || key === "ref";
+}
+function isComponentVNode(vnode) {
+	return typeof vnode.type === "object" || typeof vnode.type === "function";
+}
+function getVNodeComponentName(vnode) {
+	if (!isComponentVNode(vnode)) return;
+	const type = vnode.type;
+	return type.name || type.__name || type.displayName;
+}
+function isTargetComponent(vnode, name) {
+	return getVNodeComponentName(vnode) === name;
+}
+function hasTargetMarker(vnode, markerKey) {
+	if (!isComponentVNode(vnode)) return false;
+	return Boolean(vnode.type?.[markerKey]);
+}
+function normalizePropsOptions(vnode) {
+	if (!isComponentVNode(vnode)) return [];
+	const raw = vnode.type.props;
+	if (!raw) return [];
+	const normalized = {};
+	const needCastKeys = [];
+	if (Array.isArray(raw)) raw.forEach((key) => {
+		if (typeof key !== "string") return;
+		normalized[camelize$1(key)] = {};
+	});
+	else if (typeof raw === "object") Object.keys(raw).forEach((key) => {
+		const normalizedKey = camelize$1(key);
+		const opt = raw[key];
+		const prop = Array.isArray(opt) || isFunction(opt) ? { type: opt } : opt ? { ...opt } : {};
+		const propType = prop.type;
+		let shouldCast = false;
+		let shouldCastTrue = true;
+		if (Array.isArray(propType)) for (let index = 0; index < propType.length; index += 1) {
+			const type = propType[index];
+			if (isBooleanType(type)) {
+				shouldCast = true;
+				break;
+			}
+			if (isStringType(type)) shouldCastTrue = false;
+		}
+		else shouldCast = isBooleanType(propType);
+		prop.shouldCast = shouldCast;
+		prop.shouldCastTrue = shouldCastTrue;
+		normalized[normalizedKey] = prop;
+		if (shouldCast || hasOwn(prop, "default")) needCastKeys.push(normalizedKey);
+	});
+	return [normalized, needCastKeys];
+}
+function resolvePropValue(options, props, key, value, isAbsent) {
+	const opt = options[key];
+	if (!opt) return value;
+	const hasDefault = hasOwn(opt, "default");
+	if (hasDefault && value === void 0) {
+		const defaultValue = opt.default;
+		if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) value = defaultValue(props);
+		else value = defaultValue;
+	}
+	if (opt.shouldCast) {
+		if (isAbsent && !hasDefault) value = false;
+		else if (opt.shouldCastTrue && (value === "" || value === hyphenate(key))) value = true;
+	}
+	return value;
+}
+function normalizeSlotValue(value) {
+	const nodes = filterEmpty(value).filter((node) => node !== void 0 && node !== null && (typeof node !== "object" || node.type !== Comment));
+	if (nodes.length === 0) return;
+	return nodes.length === 1 ? nodes[0] : nodes;
+}
+function resolveVNodeProps(vnode, name, markerKey) {
+	if (markerKey && !hasTargetMarker(vnode, markerKey)) return {};
+	if (!markerKey && name && !isTargetComponent(vnode, name)) return {};
+	const rawProps = vnode.props || EMPTY_OBJ;
+	const normalizedPropsOptions = normalizePropsOptions(vnode);
+	const resolvedProps = {};
+	const attrs = {};
+	if (normalizedPropsOptions.length > 0) {
+		const [options, needCastKeys] = normalizedPropsOptions;
+		const needCastKeySet = new Set(needCastKeys);
+		const rawCastValues = {};
+		Object.keys(rawProps).forEach((key) => {
+			if (isReservedProp(key)) return;
+			const value = rawProps[key];
+			const camelKey = camelize$1(key);
+			if (hasOwn(options, camelKey)) if (!needCastKeySet.has(camelKey)) resolvedProps[camelKey] = value;
+			else rawCastValues[camelKey] = value;
+			else attrs[key] = value;
+		});
+		needCastKeys.forEach((key) => {
+			resolvedProps[key] = resolvePropValue(options, resolvedProps, key, rawCastValues[key], !hasOwn(rawCastValues, key));
+		});
+	} else Object.keys(rawProps).forEach((key) => {
+		if (isReservedProp(key)) return;
+		attrs[key] = rawProps[key];
+	});
+	const result = {
+		...attrs,
+		...resolvedProps
+	};
+	if (result.className === void 0 && result.class !== void 0) result.className = result.class;
+	if (result.class === void 0 && result.className !== void 0) result.class = result.className;
+	if (vnode.key != null && result.key === void 0) result.key = vnode.key;
+	if (typeof vnode.children === "object" && vnode.children && !Array.isArray(vnode.children)) Object.keys(vnode.children).forEach((slotName) => {
+		if (slotName === "_") return;
+		const slotFn = vnode.children[slotName];
+		if (!isFunction(slotFn)) return;
+		const value = normalizeSlotValue(slotFn());
+		if (value === void 0) return;
+		if (slotName === "default") {
+			result.children = value;
+			return;
+		}
+		result[camelize$1(slotName)] = value;
+	});
+	return result;
+}
+function resolveSlotsNode(slots, slotName, name, markerKey) {
+	if (!slots[slotName]) return [];
+	const nodes = filterEmpty(slots?.[slotName]?.() ?? []).filter((node) => node !== void 0 && node !== null && node.type !== Comment);
+	if (nodes.length === 0) return [];
+	const targetNodes = markerKey ? nodes.filter((node) => hasTargetMarker(node, markerKey)) : name ? nodes.filter((node) => isTargetComponent(node, name)) : nodes;
+	return targetNodes.map((node) => resolveVNodeProps(node, void 0, markerKey)).filter((item, index) => {
+		if (Object.keys(item).length > 0) return true;
+		return isComponentVNode(targetNodes[index]);
+	});
+}
+//#endregion
+export { resolveSlotsNode, resolveVNodeProps };

package/dist/_util/vueNode.d.ts

@@ -0,0 +1,14 @@
+import { AnyObject, VueNode } from "./type.js";
+import { VNodeChild } from "vue";
+import { isFragment } from "@v-c/util/dist/Children/isFragment";
+//#region src/_util/vueNode.d.ts
+type RenderProps = AnyObject | ((originProps: AnyObject) => AnyObject | undefined);
+declare function replaceElement(element: VNodeChild, replacement: VNodeChild, props?: RenderProps): VNodeChild;
+declare function cloneElement(element: VNodeChild, props?: RenderProps): VNodeChild;
+declare function getVNode(node: VueNode): VNodeChild;
+declare function checkRenderNode(node: any): any;
+declare function getTextByNode(node: any): any;
+declare function getTextNodeArr(nodes: any[]): any[];
+type EmitToProps<T extends Record<string, any>> = { [K in keyof T as `on${Capitalize<K & string>}`]: T[K]; };
+//#endregion
+export { EmitToProps, checkRenderNode, cloneElement, getTextByNode, getTextNodeArr, getVNode, isFragment, replaceElement };

package/dist/_util/vueNode.js

@@ -0,0 +1,36 @@
+import { Fragment, Text, cloneVNode, h, isVNode } from "vue";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+import { isFragment } from "@v-c/util/dist/Children/isFragment";
+//#region src/_util/vueNode.ts
+function replaceElement(element, replacement, props) {
+	if (!isVNode(element)) return replacement;
+	return cloneVNode(element, typeof props === "function" ? props(element.props || {}) : props);
+}
+function cloneElement(element, props) {
+	return replaceElement(element, element, props);
+}
+function getVNode(node) {
+	if (typeof node === "function") return node?.();
+	return node;
+}
+function checkRenderNode(node) {
+	if (!node) return;
+	const pureChild = filterEmpty(Array.isArray(node) ? node : [node]);
+	if (pureChild.length > 0) if (pureChild.length === 1) return pureChild[0];
+	else return h(Fragment, null, pureChild);
+}
+function getTextByNode(node) {
+	if (isVNode(node) && node.type === Text) return node.children;
+	else if (typeof node === "object" && node !== null && (typeof node.children === "string" || typeof node.children === "number")) return node.children;
+	return node;
+}
+function getTextNodeArr(nodes) {
+	const res = [];
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		res.push(getTextByNode(node));
+	}
+	return res;
+}
+//#endregion
+export { checkRenderNode, cloneElement, getTextByNode, getTextNodeArr, getVNode, isFragment, replaceElement };