@v-c/util 1.0.18 → 1.0.20

package/dist/Children/isFragment.js

@@ -1,5 +1,7 @@
 import { Fragment, isVNode } from "vue";
+//#region src/Children/isFragment.ts
 function isFragment(node) {
 	return isVNode(node) && node.type === Fragment;
 }
+//#endregion
 export { isFragment };

package/dist/Children/toArray.js

@@ -1,4 +1,5 @@
 import { isFragment } from "./isFragment.js";
+//#region src/Children/toArray.ts
 function toArray(children, option = {}) {
 	let ret = [];
 	if (!Array.isArray(children)) children = [children];
@@ -10,4 +11,5 @@ function toArray(children, option = {}) {
 	}
 	return ret;
 }
+//#endregion
 export { toArray };

package/dist/Dom/addEventListener.js

@@ -1,3 +1,4 @@
+//#region src/Dom/addEventListener.ts
 function addEventListener(...args) {
 	const [target, eventType, cb, option] = args;
 	if (target?.addEventListener) target.addEventListener(eventType, cb, option);
@@ -5,4 +6,5 @@ function addEventListener(...args) {
 		target?.removeEventListener?.(eventType, cb, option);
 	} };
 }
+//#endregion
 export { addEventListener };

package/dist/Dom/canUseDom.js

@@ -1,4 +1,6 @@
+//#region src/Dom/canUseDom.ts
 function canUseDom() {
 	return !!(typeof window !== "undefined" && window.document && window.document.createElement);
 }
+//#endregion
 export { canUseDom as default };

package/dist/Dom/class.js

@@ -1,3 +1,4 @@
+//#region src/Dom/class.ts
 function hasClass(node, className) {
 	if (node.classList) return node.classList.contains(className);
 	return ` ${node.className} `.includes(` ${className} `);
@@ -10,4 +11,5 @@ function removeClass(node, className) {
 	if (node.classList) node.classList.remove(className);
 	else if (hasClass(node, className)) node.className = ` ${node.className} `.replace(` ${className} `, " ");
 }
+//#endregion
 export { addClass, hasClass, removeClass };

package/dist/Dom/contains.js

@@ -1,3 +1,4 @@
+//#region src/Dom/contains.ts
 function contains(root, n) {
 	if (!root) return false;
 	if (root.contains) return root.contains(n);
@@ -8,4 +9,5 @@ function contains(root, n) {
 	}
 	return false;
 }
+//#endregion
 export { contains as default };

package/dist/Dom/css.js

@@ -1,3 +1,4 @@
+//#region src/Dom/css.ts
 var PIXEL_PATTERN = /margin|padding|width|height|max|min|offset/;
 var removePixel = {
 	left: true,
@@ -71,4 +72,5 @@ function getOffset(node) {
 		top: box.top + (window.pageYOffset || docElem.scrollTop) - (docElem.clientTop || document.body.clientTop || 0)
 	};
 }
+//#endregion
 export { get, getClientSize, getDocSize, getOffset, getOuterHeight, getOuterWidth, getScroll, set };

package/dist/Dom/dynamicCSS.js

@@ -1,5 +1,6 @@
 import canUseDom from "./canUseDom.js";
 import contains from "./contains.js";
+//#region src/Dom/dynamicCSS.ts
 var APPEND_ORDER = "data-vc-order";
 var APPEND_PRIORITY = "data-vc-priority";
 var MARK_KEY = `vc-util-key`;
@@ -16,6 +17,9 @@ function getOrder(prepend) {
 	if (prepend === "queue") return "prependQueue";
 	return prepend ? "prepend" : "append";
 }
+/**
+* Find style which inject by rc-util
+*/
 function findStyles(container) {
 	return Array.from((containerCache.get(container) || container).children).filter((node) => node.tagName === "STYLE");
 }
@@ -35,7 +39,8 @@ function injectCSS(css, option = {}) {
 		if (isPrependQueue) {
 			const existStyle = findStyles(container).filter((node) => {
 				if (!["prepend", "prependQueue"].includes(node.getAttribute(APPEND_ORDER))) return false;
-				return priority >= Number(node.getAttribute(APPEND_PRIORITY) || 0);
+				const nodePriority = Number(node.getAttribute(APPEND_PRIORITY) || 0);
+				return priority >= nodePriority;
 			});
 			if (existStyle.length) {
 				container.insertBefore(styleNode, existStyle[existStyle.length - 1].nextSibling);
@@ -54,6 +59,9 @@ function removeCSS(key, option = {}) {
 	const existNode = findExistNode(key, option);
 	if (existNode) getContainer(option).removeChild(existNode);
 }
+/**
+* qiankun will inject `appendChild` to insert into other
+*/
 function syncRealContainer(container, option) {
 	const cachedRealContainer = containerCache.get(container);
 	if (!cachedRealContainer || !contains(document, cachedRealContainer)) {
@@ -63,6 +71,9 @@ function syncRealContainer(container, option) {
 		container.removeChild(placeholderStyle);
 	}
 }
+/**
+* manually clear container cache to avoid global cache in unit testes
+*/
 function clearContainerCache() {
 	containerCache.clear();
 }
@@ -79,4 +90,5 @@ function updateCSS(css, key, option = {}) {
 	newNode.setAttribute(getMark(option), key);
 	return newNode;
 }
+//#endregion
 export { clearContainerCache, injectCSS, removeCSS, updateCSS };

package/dist/Dom/findDOMNode.js

@@ -1,5 +1,6 @@
 import canUseDom from "./canUseDom.js";
 import { unref } from "vue";
+//#region src/Dom/findDOMNode.ts
 function isDOM(node) {
 	return node instanceof HTMLElement || node instanceof SVGElement;
 }
@@ -10,6 +11,9 @@ function getDOM(elementRef) {
 	if (dom && (dom.nodeType === 3 || dom.nodeType === 8) && dom.nextElementSibling) return dom.nextElementSibling;
 	return dom;
 }
+/**
+* Return if a node is a DOM node. Else will return by `findDOMNode`
+*/
 function findDOMNode(_node) {
 	const node = unref(_node);
 	if (!canUseDom()) return node;
@@ -17,4 +21,5 @@ function findDOMNode(_node) {
 	else if (node && "$el" in node) return node.$el;
 	return null;
 }
+//#endregion
 export { findDOMNode as default, getDOM, isDOM };

package/dist/Dom/focus.d.ts

@@ -16,4 +16,7 @@ export declare function lockFocus(element: HTMLElement, id: string): VoidFunctio
  * If multiple elements are locked, only the last locked element will be effective.
  * @returns A function to mark an element as ignored, which will temporarily allow focus on that element even if it's outside the locked area.
  */
-export declare function useLockFocus(lock: Ref<boolean>, getElement: () => HTMLElement | null): [ignoreElement: (ele: HTMLElement) => void];
+export declare function useLockFocus(lock: Ref<boolean>, getElement: () => HTMLElement | null): [
+    ignoreElement: (ele: HTMLElement) => void,
+    registerAllowedElement: (ele: HTMLElement) => VoidFunction
+];

package/dist/Dom/focus.js

@@ -2,6 +2,7 @@ import useId_default from "../hooks/useId.js";
 import { getDOM } from "./findDOMNode.js";
 import isVisible_default from "./isVisible.js";
 import { watch } from "vue";
+//#region src/Dom/focus.ts
 function focusable(node, includePositive = false) {
 	if (isVisible_default(node)) {
 		const nodeName = node.nodeName.toLowerCase();
@@ -49,21 +50,27 @@ var lastFocusElement = null;
 var focusElements = [];
 var idToElementMap = /* @__PURE__ */ new Map();
 var ignoredElementMap = /* @__PURE__ */ new Map();
+var allowedElementMap = /* @__PURE__ */ new Map();
 function getLastElement() {
 	return focusElements[focusElements.length - 1];
 }
-function isIgnoredElement(element) {
+function getLastLockId() {
 	const lastElement = getLastElement();
-	if (element && lastElement) {
-		let lockId;
-		for (const [id, ele] of idToElementMap.entries()) if (ele === lastElement) {
-			lockId = id;
-			break;
-		}
-		if (!lockId) return false;
-		const ignoredEle = ignoredElementMap.get(lockId);
-		return !!ignoredEle && (ignoredEle === element || ignoredEle.contains(element));
-	}
+	if (!lastElement) return void 0;
+	for (const [id, ele] of idToElementMap.entries()) if (ele === lastElement) return id;
+}
+function isIgnoredElement(element) {
+	const lockId = getLastLockId();
+	if (!lockId || !element) return false;
+	const ignoredEle = ignoredElementMap.get(lockId);
+	return !!ignoredEle && (ignoredEle === element || ignoredEle.contains(element));
+}
+function isAllowedElement(element) {
+	const lockId = getLastLockId();
+	if (!lockId || !element) return false;
+	const allowedElements = allowedElementMap.get(lockId);
+	if (!allowedElements?.size) return false;
+	for (const allowedElement of allowedElements) if (allowedElement === element || allowedElement.contains(element)) return true;
 	return false;
 }
 function hasFocus(element) {
@@ -73,7 +80,7 @@ function hasFocus(element) {
 function syncFocus() {
 	const lastElement = getLastElement();
 	const { activeElement } = document;
-	if (isIgnoredElement(activeElement)) return;
+	if (isIgnoredElement(activeElement) || isAllowedElement(activeElement)) return;
 	if (lastElement && !hasFocus(lastElement)) {
 		const focusableList = getFocusNodeList(lastElement);
 		(focusableList.includes(lastFocusElement) ? lastFocusElement : focusableList[0])?.focus({ preventScroll: true });
@@ -88,6 +95,11 @@ function onWindowKeyDown(e) {
 		else if (!e.shiftKey && activeElement === last) lastFocusElement = focusableList[0];
 	}
 }
+/**
+* Lock focus in the element.
+* It will force back to the first focusable element when focus leaves the element.
+* @param id - A stable ID for this lock instance
+*/
 function lockFocus(element, id) {
 	if (element) {
 		idToElementMap.set(id, element);
@@ -102,12 +114,19 @@ function lockFocus(element, id) {
 		focusElements = focusElements.filter((ele) => ele !== element);
 		idToElementMap.delete(id);
 		ignoredElementMap.delete(id);
+		allowedElementMap.delete(id);
 		if (focusElements.length === 0) {
 			window.removeEventListener("focusin", syncFocus);
 			window.removeEventListener("keydown", onWindowKeyDown, true);
 		}
 	};
 }
+/**
+* Lock focus within an element.
+* When locked, focus will be restricted to focusable elements within the specified element.
+* If multiple elements are locked, only the last locked element will be effective.
+* @returns A function to mark an element as ignored, which will temporarily allow focus on that element even if it's outside the locked area.
+*/
 function useLockFocus(lock, getElement) {
 	const id = useId_default();
 	watch([lock, () => getElement()], ([nextLock, element], _o, onCleanup) => {
@@ -120,6 +139,21 @@ function useLockFocus(lock, getElement) {
 	const ignoreElement = (ele) => {
 		if (ele) ignoredElementMap.set(id, ele);
 	};
-	return [ignoreElement];
+	const registerAllowedElement = (ele) => {
+		if (!ele) return () => {};
+		let allowedElements = allowedElementMap.get(id);
+		if (!allowedElements) {
+			allowedElements = /* @__PURE__ */ new Set();
+			allowedElementMap.set(id, allowedElements);
+		}
+		allowedElements.add(ele);
+		return () => {
+			const nextAllowedElements = allowedElementMap.get(id);
+			nextAllowedElements?.delete(ele);
+			if (!nextAllowedElements?.size) allowedElementMap.delete(id);
+		};
+	};
+	return [ignoreElement, registerAllowedElement];
 }
+//#endregion
 export { getFocusNodeList, lockFocus, triggerFocus, useLockFocus };

package/dist/Dom/focusBoundary.d.ts

@@ -0,0 +1,5 @@
+export interface FocusBoundaryContextProps {
+    registerAllowedElement: (element: HTMLElement) => VoidFunction;
+}
+export declare function useFocusBoundaryProvider(props: FocusBoundaryContextProps): void;
+export declare function useFocusBoundary(): FocusBoundaryContextProps;

package/dist/Dom/focusBoundary.js

@@ -0,0 +1,11 @@
+import { inject, provide } from "vue";
+//#region src/Dom/focusBoundary.ts
+var FocusBoundaryContextKey = Symbol("FocusBoundaryContext");
+function useFocusBoundaryProvider(props) {
+	provide(FocusBoundaryContextKey, props);
+}
+function useFocusBoundary() {
+	return inject(FocusBoundaryContextKey, null);
+}
+//#endregion
+export { useFocusBoundary, useFocusBoundaryProvider };

package/dist/Dom/isVisible.js

@@ -1,3 +1,4 @@
+//#region src/Dom/isVisible.ts
 var isVisible_default = (element) => {
 	if (!element) return false;
 	if (element instanceof Element) {
@@ -13,4 +14,5 @@ var isVisible_default = (element) => {
 	}
 	return false;
 };
+//#endregion
 export { isVisible_default as default };

package/dist/Dom/scrollLocker.js

@@ -1,5 +1,6 @@
 import getScrollBarSize from "../getScrollBarSize.js";
-import setStyle_default from "../setStyle.js";
+import setStyle from "../setStyle.js";
+//#region src/Dom/scrollLocker.ts
 var uuid = 0;
 var locks = [];
 var scrollingEffectClassName = "ant-scrolling-effect";
@@ -39,7 +40,7 @@ var ScrollLocker = class {
 			if (getComputedStyle(container).overflow !== "hidden") scrollBarSize = getScrollBarSize();
 		}
 		const containerClassName = container.className;
-		if (locks.filter(({ options }) => options?.container === this.options?.container).length === 0) cacheStyle.set(container, setStyle_default({
+		if (locks.filter(({ options }) => options?.container === this.options?.container).length === 0) cacheStyle.set(container, setStyle({
 			width: scrollBarSize !== 0 ? `calc(100% - ${scrollBarSize}px)` : void 0,
 			overflow: "hidden",
 			overflowX: "hidden",
@@ -58,9 +59,10 @@ var ScrollLocker = class {
 		const container = this.options?.container || document.body;
 		const containerClassName = container.className;
 		if (!scrollingEffectClassNameReg.test(containerClassName)) return;
-		setStyle_default(cacheStyle.get(container), { element: container });
+		setStyle(cacheStyle.get(container), { element: container });
 		cacheStyle.delete(container);
 		container.className = container.className.replace(scrollingEffectClassNameReg, "").trim();
 	};
 };
+//#endregion
 export { ScrollLocker as default };

package/dist/Dom/shadow.js

@@ -1,10 +1,18 @@
+//#region src/Dom/shadow.ts
 function getRoot(ele) {
 	return ele?.getRootNode?.();
 }
+/**
+* Check if is in shadowRoot
+*/
 function inShadow(ele) {
 	return getRoot(ele) instanceof ShadowRoot;
 }
+/**
+* Return shadowRoot if possible
+*/
 function getShadowRoot(ele) {
 	return inShadow(ele) ? getRoot(ele) : null;
 }
+//#endregion
 export { getShadowRoot, inShadow };

package/dist/Dom/styleChecker.js

@@ -1,4 +1,5 @@
 import canUseDom from "./canUseDom.js";
+//#region src/Dom/styleChecker.ts
 function isStyleNameSupport(styleName) {
 	if (canUseDom() && window.document.documentElement) {
 		const styleNameList = Array.isArray(styleName) ? styleName : [styleName];
@@ -18,4 +19,5 @@ function isStyleSupport(styleName, styleValue) {
 	if (!Array.isArray(styleName) && styleValue !== void 0) return isStyleValueSupport(styleName, styleValue);
 	return isStyleNameSupport(styleName);
 }
+//#endregion
 export { isStyleSupport };

package/dist/Dom/support.js

@@ -1,4 +1,5 @@
 import canUseDom from "./canUseDom.js";
+//#region src/Dom/support.ts
 var animationEndEventNames = {
 	WebkitAnimation: "webkitAnimationEnd",
 	OAnimation: "oAnimationEnd",
@@ -14,6 +15,7 @@ function supportEnd(names) {
 	for (const name in names) if (names.hasOwnProperty(name) && el.style[name] !== void 0) return { end: names[name] };
 	return false;
 }
-const animation = canUseDom() && supportEnd(animationEndEventNames);
-const transition = canUseDom() && supportEnd(transitionEventNames);
+var animation = canUseDom() && supportEnd(animationEndEventNames);
+var transition = canUseDom() && supportEnd(transitionEventNames);
+//#endregion
 export { animation, transition };