@antdv-vue/pro-utils 0.0.0-stage → 2.1.1

package/dist/components/Draggable/DraggableCore.d.ts

@@ -0,0 +1,40 @@
+import { DraggableEventHandler } from "./types.js";
+import * as _$vue from "vue";
+import { ShallowRef } from "vue";
+import { CustomSlotsType, VueNode } from "@v-c/util/dist/type";
+
+//#region src/components/Draggable/DraggableCore.d.ts
+interface DraggableCoreDefaultProps {
+  allowAnyClick?: boolean;
+  allowMobileScroll?: boolean;
+  disabled?: boolean;
+  enableUserSelectHack?: boolean;
+  scale?: number;
+}
+type DraggableCoreProps = DraggableCoreDefaultProps & {
+  cancel?: string;
+  offsetParent?: HTMLElement;
+  grid?: [number, number];
+  nodeRef?: ShallowRef<HTMLElement | null> | null;
+  handle?: string;
+};
+interface DraggableCoreEmits {
+  drag: DraggableEventHandler;
+  mousedown: (e: MouseEvent) => void;
+  start: DraggableEventHandler;
+  stop: DraggableEventHandler;
+  [key: string]: (...args: any[]) => void;
+}
+declare const DraggableCore: _$vue.DefineSetupFnComponent<DraggableCoreProps, DraggableCoreEmits, CustomSlotsType<{
+  default?: () => VueNode[];
+}>, DraggableCoreDefaultProps & {
+  cancel?: string;
+  offsetParent?: HTMLElement;
+  grid?: [number, number];
+  nodeRef?: ShallowRef<HTMLElement | null> | null;
+  handle?: string;
+} & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, _$vue.PublicProps>;
+//#endregion
+export { DraggableCoreDefaultProps, DraggableCoreEmits, DraggableCoreProps, DraggableCore as default };

package/dist/components/Draggable/DraggableCore.js

@@ -0,0 +1,149 @@
+import { useState } from "../../hooks/useState/index.js";
+import { addEvent, addUserSelectStyles, getTouchIdentifier, matchesSelectorAndParentsTo, removeEvent, scheduleRemoveUserSelectStyles } from "./utils/domFns.js";
+import { createCoreData, getControlPosition, snapToGrid } from "./utils/positionFns.js";
+import { cloneVNode, defineComponent, getCurrentInstance, onMounted, onUnmounted, shallowRef } from "vue";
+import findDOMNode from "@v-c/util/dist/Dom/findDOMNode";
+//#region src/components/Draggable/DraggableCore.tsx
+const eventsFor = {
+	touch: {
+		start: "touchstart",
+		move: "touchmove",
+		stop: "touchend"
+	},
+	mouse: {
+		start: "mousedown",
+		move: "mousemove",
+		stop: "mouseup"
+	}
+};
+const DraggableCore = /* @__PURE__ */ defineComponent((props, { slots, expose, emit }) => {
+	const touchIdentifier = shallowRef(null);
+	const dragEventFor = shallowRef(eventsFor.mouse);
+	const [lastX, setLastX] = useState(NaN);
+	const [lastY, setLastY] = useState(NaN);
+	const [dragging, setDragging] = useState(false);
+	const proxy = getCurrentInstance();
+	const mountedNode = shallowRef(null);
+	const activeDocument = shallowRef(null);
+	const getNode = () => {
+		if (props.nodeRef?.value) return props.nodeRef.value;
+		if (!proxy?.proxy) return null;
+		return findDOMNode(proxy.proxy);
+	};
+	const removeDragEvents = () => {
+		const ownerDocument = activeDocument.value;
+		if (!ownerDocument) return;
+		removeEvent(ownerDocument, eventsFor.mouse.move, handleDrag);
+		removeEvent(ownerDocument, eventsFor.touch.move, handleDrag);
+		removeEvent(ownerDocument, eventsFor.mouse.stop, handleDragStop);
+		removeEvent(ownerDocument, eventsFor.touch.stop, handleDragStop);
+		removeEvent(ownerDocument, "touchcancel", handleDragStop);
+		if (props.enableUserSelectHack !== false) scheduleRemoveUserSelectStyles(ownerDocument);
+		activeDocument.value = null;
+	};
+	function handleDrag(e) {
+		const position = getControlPosition(e, touchIdentifier.value, proxy, props.scale ?? 1);
+		if (position == null) return;
+		let { x = 0, y = 0 } = position;
+		if (Array.isArray(props.grid)) {
+			let deltaX = x - lastX.value;
+			let deltaY = y - lastY.value;
+			[deltaX, deltaY] = snapToGrid(props.grid, deltaX, deltaY);
+			if (!deltaX && !deltaY) return;
+			x = lastX.value + deltaX;
+			y = lastY.value + deltaY;
+		}
+		emit("drag", e, createCoreData(proxy, x, y));
+		setLastX(x);
+		setLastY(y);
+	}
+	function handleDragStop(e) {
+		if (!dragging.value) return;
+		const position = getControlPosition(e, touchIdentifier.value, proxy, props.scale ?? 1);
+		let { x, y } = position ?? {
+			x: lastX.value,
+			y: lastY.value
+		};
+		if (position && Array.isArray(props.grid)) {
+			let deltaX = x - lastX.value || 0;
+			let deltaY = y - lastY.value || 0;
+			[deltaX, deltaY] = snapToGrid(props.grid, deltaX, deltaY);
+			x = lastX.value + deltaX;
+			y = lastY.value + deltaY;
+		}
+		emit("stop", e, createCoreData(proxy, x, y));
+		setDragging(false);
+		setLastX(NaN);
+		setLastY(NaN);
+		touchIdentifier.value = null;
+		removeDragEvents();
+	}
+	const handleDragStart = (e) => {
+		if (e instanceof MouseEvent) emit("mousedown", e);
+		if (!props.allowAnyClick && e instanceof MouseEvent && (e.button !== 0 || e.ctrlKey)) return false;
+		const node = getNode();
+		if (!node) return false;
+		const { ownerDocument } = node;
+		if (props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || props.handle && !matchesSelectorAndParentsTo(e.target, props.handle, node) || props.cancel && matchesSelectorAndParentsTo(e.target, props.cancel, node)) return false;
+		if (e.type === "touchstart" && !props.allowMobileScroll) e.preventDefault();
+		touchIdentifier.value = getTouchIdentifier(e);
+		const position = getControlPosition(e, touchIdentifier.value, proxy, props.scale ?? 1);
+		if (position == null) return false;
+		const { x, y } = position;
+		emit("start", e, createCoreData(proxy, x, y));
+		if (props.enableUserSelectHack !== false) addUserSelectStyles(ownerDocument);
+		activeDocument.value = ownerDocument;
+		setDragging(true);
+		setLastX(x);
+		setLastY(y);
+		addEvent(ownerDocument, dragEventFor.value.move, handleDrag);
+		addEvent(ownerDocument, dragEventFor.value.stop, handleDragStop);
+		if (dragEventFor.value === eventsFor.touch) addEvent(ownerDocument, "touchcancel", handleDragStop);
+	};
+	const handleTouchStart = (e) => {
+		dragEventFor.value = eventsFor.touch;
+		return handleDragStart(e);
+	};
+	onMounted(() => {
+		mountedNode.value = getNode();
+		if (mountedNode.value) addEvent(mountedNode.value, eventsFor.touch.start, handleTouchStart, { passive: false });
+	});
+	onUnmounted(() => {
+		if (mountedNode.value) removeEvent(mountedNode.value, eventsFor.touch.start, handleTouchStart, { passive: false });
+		removeDragEvents();
+	});
+	expose({
+		lastX,
+		lastY
+	});
+	return () => {
+		const [children] = slots.default?.();
+		return cloneVNode(children, { onMousedown: (e) => {
+			dragEventFor.value = eventsFor.mouse;
+			return handleDragStart(e);
+		} });
+	};
+}, {
+	name: "DraggableCore",
+	inheritAttrs: false,
+	props: [
+		"allowAnyClick",
+		"allowMobileScroll",
+		"cancel",
+		"disabled",
+		"enableUserSelectHack",
+		"grid",
+		"handle",
+		"nodeRef",
+		"offsetParent",
+		"scale"
+	],
+	emits: [
+		"drag",
+		"mousedown",
+		"start",
+		"stop"
+	]
+});
+//#endregion
+export { DraggableCore as default };

package/dist/components/Draggable/index.d.ts

@@ -0,0 +1,4 @@
+import { Bounds, ControlPosition, DraggableData, DraggableEvent, DraggableEventHandler, EventHandler, MouseTouchEvent, PositionOffsetControlPosition } from "./types.js";
+import DraggableCore, { DraggableCoreProps } from "./DraggableCore.js";
+import Draggable, { DraggableProps } from "./Draggable.js";
+export { Bounds, ControlPosition, Draggable, DraggableCore, type DraggableCoreProps, DraggableData, DraggableEvent, DraggableEventHandler, type DraggableProps, EventHandler, MouseTouchEvent, PositionOffsetControlPosition };

package/dist/components/Draggable/index.js

@@ -0,0 +1,3 @@
+import DraggableCore from "./DraggableCore.js";
+import Draggable from "./Draggable.js";
+export { Draggable, DraggableCore };

package/dist/components/Draggable/types.d.ts

@@ -0,0 +1,30 @@
+//#region src/components/Draggable/types.d.ts
+interface DraggableData {
+  node: HTMLElement;
+  x: number;
+  y: number;
+  deltaX: number;
+  deltaY: number;
+  lastX: number;
+  lastY: number;
+}
+type DraggableEvent = MouseEvent | TouchEvent;
+type DraggableEventHandler = (e: DraggableEvent, data: DraggableData) => void;
+interface Bounds {
+  left?: number;
+  top?: number;
+  right?: number;
+  bottom?: number;
+}
+interface ControlPosition {
+  x: number;
+  y: number;
+}
+interface PositionOffsetControlPosition {
+  x: number | string;
+  y: number | string;
+}
+type EventHandler<T> = (e: T) => void | false;
+type MouseTouchEvent = MouseEvent | TouchEvent;
+//#endregion
+export { Bounds, ControlPosition, DraggableData, DraggableEvent, DraggableEventHandler, EventHandler, MouseTouchEvent, PositionOffsetControlPosition };

package/dist/components/Draggable/types.js

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

package/dist/components/Draggable/utils/domFns.d.ts

@@ -0,0 +1,36 @@
+import { ControlPosition, MouseTouchEvent, PositionOffsetControlPosition } from "../types.js";
+
+//#region src/components/Draggable/utils/domFns.d.ts
+type EventListenerLike = (event: never) => void | false;
+declare function matchesSelector(el: Node, selector: string): boolean;
+declare function matchesSelectorAndParentsTo(el: Node, selector: string, baseNode: Node): boolean;
+declare function addEvent(el: Node | null | undefined, event: string, handler: EventListenerLike, inputOptions?: AddEventListenerOptions): void;
+declare function removeEvent(el: Node | null | undefined, event: string, handler: EventListenerLike, inputOptions?: AddEventListenerOptions): void;
+declare function outerHeight(node: HTMLElement): number;
+declare function outerWidth(node: HTMLElement): number;
+declare function innerHeight(node: HTMLElement): number;
+declare function innerWidth(node: HTMLElement): number;
+interface EventWithOffset {
+  clientX: number;
+  clientY: number;
+}
+declare function offsetXYFromParent(evt: EventWithOffset, offsetParent: HTMLElement, scale: number): ControlPosition;
+declare function createCSSTransform(controlPos: ControlPosition, positionOffset: PositionOffsetControlPosition): {
+  [key: string]: string;
+};
+declare function createSVGTransform(controlPos: ControlPosition, positionOffset: PositionOffsetControlPosition): string;
+declare function getTranslation({
+  x,
+  y
+}: ControlPosition, positionOffset: PositionOffsetControlPosition, unitSuffix: string): string;
+declare function getTouch(e: MouseTouchEvent, identifier: number): {
+  clientX: number;
+  clientY: number;
+} | null | undefined;
+declare function getTouchIdentifier(e: MouseTouchEvent): number | undefined;
+declare function addUserSelectStyles(doc: Document | null | undefined): void;
+declare function scheduleRemoveUserSelectStyles(doc: Document | null | undefined): void;
+declare function addClassName(el: HTMLElement, className: string): void;
+declare function removeClassName(el: HTMLElement, className: string): void;
+//#endregion
+export { addClassName, addEvent, addUserSelectStyles, createCSSTransform, createSVGTransform, getTouch, getTouchIdentifier, getTranslation, innerHeight, innerWidth, matchesSelector, matchesSelectorAndParentsTo, offsetXYFromParent, outerHeight, outerWidth, removeClassName, removeEvent, scheduleRemoveUserSelectStyles };

package/dist/components/Draggable/utils/domFns.js

@@ -0,0 +1,165 @@
+import getPrefix_default, { browserPrefixToKey } from "./getPrefix.js";
+import { findInArray, int, isFunction } from "./shims.js";
+//#region src/components/Draggable/utils/domFns.ts
+let matchesSelectorFunc = "";
+const userSelectStates = /* @__PURE__ */ new WeakMap();
+function matchesSelector(el, selector) {
+	if (!matchesSelectorFunc) matchesSelectorFunc = findInArray([
+		"matches",
+		"webkitMatchesSelector",
+		"mozMatchesSelector",
+		"msMatchesSelector",
+		"oMatchesSelector"
+	], (method) => {
+		return isFunction(el[method]);
+	}) ?? "";
+	const matchFn = el[matchesSelectorFunc];
+	if (!isFunction(matchFn)) return false;
+	return Boolean(matchFn.call(el, selector));
+}
+function matchesSelectorAndParentsTo(el, selector, baseNode) {
+	let node = el;
+	do {
+		if (matchesSelector(node, selector)) return true;
+		if (node === baseNode) return false;
+		node = node.parentNode;
+	} while (node);
+	return false;
+}
+function addEvent(el, event, handler, inputOptions) {
+	if (!el) return;
+	const options = {
+		capture: true,
+		...inputOptions
+	};
+	const listener = handler;
+	if (el.addEventListener) el.addEventListener(event, listener, options);
+	else if (el.attachEvent) el.attachEvent(`on${event}`, listener);
+	else el[`on${event}`] = listener;
+}
+function removeEvent(el, event, handler, inputOptions) {
+	if (!el) return;
+	const options = {
+		capture: true,
+		...inputOptions
+	};
+	const listener = handler;
+	if (el.removeEventListener) el.removeEventListener(event, listener, options);
+	else if (el.detachEvent) el.detachEvent(`on${event}`, listener);
+	else el[`on${event}`] = null;
+}
+function outerHeight(node) {
+	let height = node.clientHeight;
+	const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+	height += int(computedStyle.borderTopWidth);
+	height += int(computedStyle.borderBottomWidth);
+	return height;
+}
+function outerWidth(node) {
+	let width = node.clientWidth;
+	const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+	width += int(computedStyle.borderLeftWidth);
+	width += int(computedStyle.borderRightWidth);
+	return width;
+}
+function innerHeight(node) {
+	let height = node.clientHeight;
+	const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+	height -= int(computedStyle.paddingTop);
+	height -= int(computedStyle.paddingBottom);
+	return height;
+}
+function innerWidth(node) {
+	let width = node.clientWidth;
+	const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+	width -= int(computedStyle.paddingLeft);
+	width -= int(computedStyle.paddingRight);
+	return width;
+}
+function offsetXYFromParent(evt, offsetParent, scale) {
+	const offsetParentRect = offsetParent === offsetParent.ownerDocument.body ? {
+		left: 0,
+		top: 0
+	} : offsetParent.getBoundingClientRect();
+	return {
+		x: (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale,
+		y: (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale
+	};
+}
+function createCSSTransform(controlPos, positionOffset) {
+	const translation = getTranslation(controlPos, positionOffset, "px");
+	return { [browserPrefixToKey("transform", getPrefix_default)]: translation };
+}
+function createSVGTransform(controlPos, positionOffset) {
+	return getTranslation(controlPos, positionOffset, "");
+}
+function getTranslation({ x, y }, positionOffset, unitSuffix) {
+	let translation = `translate(${x}${unitSuffix},${y}${unitSuffix})`;
+	if (positionOffset) translation = `translate(${`${typeof positionOffset.x === "string" ? positionOffset.x : positionOffset.x + unitSuffix}`}, ${`${typeof positionOffset.y === "string" ? positionOffset.y : positionOffset.y + unitSuffix}`})${translation}`;
+	return translation;
+}
+function getTouch(e, identifier) {
+	if (!("targetTouches" in e)) return null;
+	return e.targetTouches && findInArray(e.targetTouches, (touch) => identifier === touch.identifier) || e.changedTouches && findInArray(e.changedTouches, (touch) => identifier === touch.identifier);
+}
+function getTouchIdentifier(e) {
+	if (!("targetTouches" in e)) return void 0;
+	if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;
+	if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;
+}
+function addUserSelectStyles(doc) {
+	if (!doc) return;
+	let styleEl = doc.getElementById("vue-draggable-style-el");
+	if (!styleEl) {
+		styleEl = doc.createElement("style");
+		styleEl.id = "vue-draggable-style-el";
+		styleEl.textContent = `.vue-draggable-transparent-selection *::-moz-selection {all: inherit;}\n.vue-draggable-transparent-selection *::selection {all: inherit;}\n`;
+		doc.getElementsByTagName("head")[0].appendChild(styleEl);
+	}
+	if (doc.body) {
+		const state = userSelectStates.get(doc) ?? {
+			count: 0,
+			existed: doc.body.classList.contains("vue-draggable-transparent-selection")
+		};
+		state.count += 1;
+		userSelectStates.set(doc, state);
+		addClassName(doc.body, "vue-draggable-transparent-selection");
+	}
+}
+function scheduleRemoveUserSelectStyles(doc) {
+	if (!doc) return;
+	const state = userSelectStates.get(doc);
+	if (!state) return;
+	state.count = Math.max(0, state.count - 1);
+	if (state.count > 0) return;
+	const removeClass = !state.existed;
+	const removeIfIdle = () => {
+		if (userSelectStates.get(doc) !== state || state.count > 0) return;
+		userSelectStates.delete(doc);
+		removeUserSelectStyles(doc, removeClass);
+	};
+	if (window.requestAnimationFrame) window.requestAnimationFrame(removeIfIdle);
+	else removeIfIdle();
+}
+function removeUserSelectStyles(doc, removeClass) {
+	if (!doc) return;
+	try {
+		if (doc.body && removeClass) removeClassName(doc.body, "vue-draggable-transparent-selection");
+		const ieSelection = doc.selection;
+		if (ieSelection) ieSelection.empty();
+		else {
+			const selection = (doc.defaultView || window).getSelection();
+			if (selection && selection.type !== "Caret") selection.removeAllRanges();
+		}
+	} catch {}
+}
+function addClassName(el, className) {
+	if (el.classList) el.classList.add(className);
+	else if (!el.className.match(new RegExp(`(?:^|\\s)${className}(?!\\S)`))) el.className += ` ${className}`;
+}
+function removeClassName(el, className) {
+	if (el.classList) el.classList.remove(className);
+	else el.className = el.className.replace(new RegExp(`(?:^|\\s)${className}(?!\\S)`, "g"), "");
+}
+//#endregion
+export { addClassName, addEvent, addUserSelectStyles, createCSSTransform, createSVGTransform, getTouch, getTouchIdentifier, getTranslation, innerHeight, innerWidth, matchesSelector, matchesSelectorAndParentsTo, offsetXYFromParent, outerHeight, outerWidth, removeClassName, removeEvent, scheduleRemoveUserSelectStyles };

package/dist/components/Draggable/utils/getPrefix.d.ts

@@ -0,0 +1,6 @@
+//#region src/components/Draggable/utils/getPrefix.d.ts
+declare function getPrefix(prop?: string): string;
+declare function browserPrefixToKey(prop: string, prefix: string): string;
+declare const _default: string;
+//#endregion
+export { browserPrefixToKey, _default as default, getPrefix };

package/dist/components/Draggable/utils/getPrefix.js

@@ -0,0 +1,31 @@
+//#region src/components/Draggable/utils/getPrefix.ts
+const prefixes = [
+	"Moz",
+	"Webkit",
+	"O",
+	"ms"
+];
+function getPrefix(prop = "transform") {
+	if (typeof window === "undefined") return "";
+	const style = window.document?.documentElement?.style;
+	if (!style) return "";
+	if (prop in style) return "";
+	for (let i = 0; i < prefixes.length; i++) if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];
+	return "";
+}
+function browserPrefixToKey(prop, prefix) {
+	return prefix ? `${prefix}${kebabToTitleCase(prop)}` : prop;
+}
+function kebabToTitleCase(str) {
+	let out = "";
+	let shouldCapitalize = true;
+	for (let i = 0; i < str.length; i++) if (shouldCapitalize) {
+		out += str[i].toUpperCase();
+		shouldCapitalize = false;
+	} else if (str[i] === "-") shouldCapitalize = true;
+	else out += str[i];
+	return out;
+}
+var getPrefix_default = getPrefix();
+//#endregion
+export { browserPrefixToKey, getPrefix_default as default, getPrefix };

package/dist/components/Draggable/utils/positionFns.d.ts

@@ -0,0 +1,13 @@
+import { ControlPosition, DraggableData, MouseTouchEvent } from "../types.js";
+import { ComponentInternalInstance } from "vue";
+
+//#region src/components/Draggable/utils/positionFns.d.ts
+declare function getBoundPosition(draggable: ComponentInternalInstance | null, x: number, y: number): [number, number];
+declare function snapToGrid(grid: [number, number], pendingX: number, pendingY: number): [number, number];
+declare function canDragX(axis: 'both' | 'x' | 'y' | 'none'): boolean;
+declare function canDragY(axis: 'both' | 'x' | 'y' | 'none'): boolean;
+declare function getControlPosition(e: MouseTouchEvent, touchIdentifier: number | null | undefined, draggableCore: ComponentInternalInstance | null, scale?: number): ControlPosition | null;
+declare function createCoreData(draggable: ComponentInternalInstance | null, x: number, y: number): DraggableData;
+declare function createDraggableData(draggable: ComponentInternalInstance | null, coreData: DraggableData): DraggableData;
+//#endregion
+export { canDragX, canDragY, createCoreData, createDraggableData, getBoundPosition, getControlPosition, snapToGrid };

package/dist/components/Draggable/utils/positionFns.js

@@ -0,0 +1,96 @@
+import { int, isNum } from "./shims.js";
+import { getTouch, innerHeight, innerWidth, offsetXYFromParent, outerHeight, outerWidth } from "./domFns.js";
+import findDOMNode from "@v-c/util/dist/Dom/findDOMNode";
+//#region src/components/Draggable/utils/positionFns.ts
+function getBoundPosition(draggable, x, y) {
+	if (!draggable?.props.bounds) return [x, y];
+	let { bounds } = draggable.props;
+	bounds = typeof bounds === "string" ? bounds : cloneBounds(bounds);
+	const node = findDOMNode(draggable.ctx);
+	if (typeof bounds === "string") {
+		const { ownerDocument } = node;
+		const ownerWindow = ownerDocument.defaultView;
+		if (!ownerWindow) throw new Error("Cannot resolve the owner window of the draggable node.");
+		let boundNode;
+		if (bounds === "parent") boundNode = node.parentNode;
+		else boundNode = node.getRootNode().querySelector(bounds);
+		if (!(boundNode instanceof ownerWindow.HTMLElement)) throw new TypeError(`Bounds selector "${bounds}" could not find an element.`);
+		const boundNodeEl = boundNode;
+		const nodeStyle = ownerWindow.getComputedStyle(node);
+		const boundNodeStyle = ownerWindow.getComputedStyle(boundNodeEl);
+		bounds = {
+			left: -node.offsetLeft + int(boundNodeStyle.paddingLeft) + int(nodeStyle.marginLeft),
+			top: -node.offsetTop + int(boundNodeStyle.paddingTop) + int(nodeStyle.marginTop),
+			right: innerWidth(boundNodeEl) - outerWidth(node) - node.offsetLeft + int(boundNodeStyle.paddingRight) - int(nodeStyle.marginRight),
+			bottom: innerHeight(boundNodeEl) - outerHeight(node) - node.offsetTop + int(boundNodeStyle.paddingBottom) - int(nodeStyle.marginBottom)
+		};
+	}
+	if (isNum(bounds.right)) x = Math.min(x, bounds.right);
+	if (isNum(bounds.bottom)) y = Math.min(y, bounds.bottom);
+	if (isNum(bounds.left)) x = Math.max(x, bounds.left);
+	if (isNum(bounds.top)) y = Math.max(y, bounds.top);
+	return [x, y];
+}
+function snapToGrid(grid, pendingX, pendingY) {
+	return [Math.round(pendingX / grid[0]) * grid[0], Math.round(pendingY / grid[1]) * grid[1]];
+}
+function canDragX(axis) {
+	return axis === "both" || axis === "x";
+}
+function canDragY(axis) {
+	return axis === "both" || axis === "y";
+}
+function getControlPosition(e, touchIdentifier, draggableCore, scale = 1) {
+	const touchObj = typeof touchIdentifier === "number" ? getTouch(e, touchIdentifier) : null;
+	if (typeof touchIdentifier === "number" && !touchObj) return null;
+	const node = findDOMNode(draggableCore.ctx);
+	const offsetParent = draggableCore?.props.offsetParent || node.offsetParent || node.ownerDocument.body;
+	const eventPosition = touchObj || ("clientX" in e ? e : null);
+	if (!eventPosition) return null;
+	return offsetXYFromParent(eventPosition, offsetParent, scale);
+}
+function createCoreData(draggable, x, y) {
+	const isStart = !isNum(draggable?.exposed?.lastX.value);
+	const node = findDOMNode(draggable.ctx);
+	if (isStart) return {
+		node,
+		deltaX: 0,
+		deltaY: 0,
+		lastX: x,
+		lastY: y,
+		x,
+		y
+	};
+	else return {
+		node,
+		deltaX: x - draggable?.exposed?.lastX.value,
+		deltaY: y - draggable?.exposed?.lastY.value,
+		lastX: draggable?.exposed?.lastX.value,
+		lastY: draggable?.exposed?.lastY.value,
+		x,
+		y
+	};
+}
+function createDraggableData(draggable, coreData) {
+	const currentX = (draggable?.exposed)?.x.value ?? 0;
+	const currentY = (draggable?.exposed)?.y.value ?? 0;
+	return {
+		node: coreData.node,
+		x: currentX + coreData.deltaX,
+		y: currentY + coreData.deltaY,
+		deltaX: coreData.deltaX,
+		deltaY: coreData.deltaY,
+		lastX: currentX,
+		lastY: currentY
+	};
+}
+function cloneBounds(bounds) {
+	return {
+		left: bounds.left,
+		top: bounds.top,
+		right: bounds.right,
+		bottom: bounds.bottom
+	};
+}
+//#endregion
+export { canDragX, canDragY, createCoreData, createDraggableData, getBoundPosition, getControlPosition, snapToGrid };

package/dist/components/Draggable/utils/shims.d.ts

@@ -0,0 +1,7 @@
+//#region src/components/Draggable/utils/shims.d.ts
+declare function findInArray<T>(array: ArrayLike<T>, callback: (value: T, index: number, array: ArrayLike<T>) => unknown): T | undefined;
+declare function isFunction(func: unknown): func is (...args: unknown[]) => unknown;
+declare function isNum(num: unknown): num is number;
+declare function int(a: string): number;
+//#endregion
+export { findInArray, int, isFunction, isNum };

package/dist/components/Draggable/utils/shims.js

@@ -0,0 +1,19 @@
+//#region src/components/Draggable/utils/shims.ts
+function findInArray(array, callback) {
+	for (let i = 0, length = array.length; i < length; i++) if (callback.apply(callback, [
+		array[i],
+		i,
+		array
+	])) return array[i];
+}
+function isFunction(func) {
+	return typeof func === "function" || Object.prototype.toString.call(func) === "[object Function]";
+}
+function isNum(num) {
+	return typeof num === "number" && !Number.isNaN(num);
+}
+function int(a) {
+	return Number.parseInt(a, 10);
+}
+//#endregion
+export { findInArray, int, isFunction, isNum };

package/dist/components/DropdownFooter/index.d.ts

@@ -0,0 +1,20 @@
+import { VueNode as VueNode$1 } from "../../typing.js";
+import * as _$vue from "vue";
+import { VNode } from "vue";
+import { CustomSlotsType } from "@v-c/util/dist/type";
+
+//#region src/components/DropdownFooter/index.d.ts
+type LightFilterFooterRender = ((onConfirm?: (e?: MouseEvent) => void, onClear?: (e?: MouseEvent) => void) => VueNode$1) | false;
+type OnClick = (e?: MouseEvent) => void;
+interface DropdownFooterProps {
+  onClear?: OnClick;
+  onConfirm?: OnClick;
+  disabled?: boolean;
+  prefixCls?: string;
+  footerRender?: LightFilterFooterRender;
+}
+declare const DropdownFooter: _$vue.DefineSetupFnComponent<DropdownFooterProps, {}, CustomSlotsType<{
+  default?: () => VNode[];
+}>, DropdownFooterProps & {}, _$vue.PublicProps>;
+//#endregion
+export { DropdownFooterProps, DropdownFooter as default };