vft 0.0.524 → 0.0.525

package/es/components/dropdown-item/style/css.js

@@ -1,2 +1,2 @@
-import "vft/theme-style/base.css";
+import "../../base/style/css.js";
 import "vft/theme-style/vft-dropdown-item.css";

package/es/components/dropdown-item/style/index.js

@@ -1,2 +1,2 @@
-import "vft/theme-style/src/base.scss";
+import "../../base/style/index.js";
 import "vft/theme-style/src/dropdown-item.scss";

package/es/components/dropdown-menu/style/css.js

@@ -1,2 +1,2 @@
-import "vft/theme-style/base.css";
+import "../../base/style/css.js";
 import "vft/theme-style/vft-dropdown-menu.css";

package/es/components/dropdown-menu/style/index.js

@@ -1,2 +1,2 @@
-import "vft/theme-style/src/base.scss";
+import "../../base/style/index.js";
 import "vft/theme-style/src/dropdown-menu.scss";

package/es/components/empty/constants.js

@@ -1,12 +1,12 @@
-const o = {
-  NotFound: "icon-not-found",
-  NoFilter: "icon-no-filter",
-  NoSearch: "icon-no-search",
-  NetworkDisconnect: "icon-network-disconnect",
-  Delete: "icon-delete",
-  NoData: "icon-no-data",
-  PageError: "icon-page-error"
-};
-export {
-  o as EmptyEnum
+//#region ../../packages/components/empty/constants.ts
+const EmptyEnum = {
+	NotFound: "icon-not-found",
+	NoFilter: "icon-no-filter",
+	NoSearch: "icon-no-search",
+	NetworkDisconnect: "icon-network-disconnect",
+	Delete: "icon-delete",
+	NoData: "icon-no-data",
+	PageError: "icon-page-error"
 };
+//#endregion
+export { EmptyEnum };

package/es/components/empty/empty.js

@@ -0,0 +1,5 @@
+import empty_vue_vue_type_script_setup_true_lang_default from "./empty.vue_vue_type_script_setup_true_lang.js";
+//#region ../../packages/components/empty/empty.vue
+var empty_default = empty_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { empty_default as default };

package/es/components/empty/empty.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,73 @@
+import { useNamespace } from "../../hooks/use-namespace/index.js";
+import { addUnit as addUnit$1 } from "../../utils/helper.js";
+import { VftIcon } from "../icon/index.js";
+import { EmptyEnum } from "./constants.js";
+import { VNode, renderTNode, singleAttrToObj } from "@vft/utils";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, getCurrentInstance, mergeProps, normalizeClass, normalizeProps, openBlock, renderSlot, unref } from "vue";
+var empty_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	...defineComponent({ name: "vft-empty" }),
+	props: {
+		icon: {
+			type: [Object, String],
+			required: false
+		},
+		type: {
+			type: null,
+			required: false,
+			default: () => EmptyEnum.NoData
+		},
+		size: {
+			type: [Number, String],
+			required: false,
+			default: "default"
+		},
+		desc: {
+			type: String,
+			required: false
+		}
+	},
+	setup(__props) {
+		const ns = useNamespace("empty");
+		const instance = getCurrentInstance();
+		const imgTypeMap = /* @__PURE__ */ new Map([
+			[EmptyEnum.NotFound, { text: "页面不存在" }],
+			[EmptyEnum.Delete, { text: "已删除" }],
+			[EmptyEnum.NetworkDisconnect, { text: "网络已断开" }],
+			[EmptyEnum.NoData, { text: "暂无数据" }],
+			[EmptyEnum.PageError, { text: "系统异常" }],
+			[EmptyEnum.NoFilter, { text: "此筛选条件下无结果" }],
+			[EmptyEnum.NoSearch, { text: "没有搜索结果" }]
+		]);
+		const imgInfos = computed(() => imgTypeMap.get(__props.type));
+		const _size = computed(() => {
+			switch (__props.size) {
+				case "large": return 120;
+				case "default": return 80;
+				case "small": return 60;
+				default: return __props.size || 80;
+			}
+		});
+		const _icon = computed(() => {
+			return singleAttrToObj(__props.icon, "icon", {
+				size: addUnit$1(_size.value),
+				icon: __props.type
+			});
+		});
+		const descContent = computed(() => renderTNode(instance, "desc", { defaultNode: imgInfos.value?.text }));
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass([unref(ns).b()]) }, [
+				createElementVNode("div", { class: normalizeClass(unref(ns).e("image")) }, [_ctx.$slots.img ? renderSlot(_ctx.$slots, "img", { key: 0 }) : (openBlock(), createBlock(unref(VftIcon), normalizeProps(mergeProps({ key: 1 }, _icon.value)), null, 16))], 2),
+				descContent.value ? (openBlock(), createElementBlock("span", {
+					key: 0,
+					class: normalizeClass(unref(ns).e("desc"))
+				}, [createVNode(unref(VNode), { content: descContent.value }, null, 8, ["content"])], 2)) : createCommentVNode("v-if", true),
+				_ctx.$slots.default ? (openBlock(), createElementBlock("div", {
+					key: 1,
+					class: normalizeClass(unref(ns).e("bottom"))
+				}, [renderSlot(_ctx.$slots, "default")], 2)) : createCommentVNode("v-if", true)
+			], 2);
+		};
+	}
+});
+//#endregion
+export { empty_vue_vue_type_script_setup_true_lang_default as default };

package/es/components/empty/index.js

@@ -1,15 +1,7 @@
-import "@vueuse/core";
-import "@vft/utils";
-import "../config-provider/hooks/use-global-config.js";
-import "vue";
-import { withInstall as t } from "../../utils/vue/install.js";
-import "lodash-es";
-import "../form/index.js";
-import m from "./empty.vue2.js";
-import { EmptyEnum as c } from "./constants.js";
-const e = t(m);
-export {
-  c as EmptyEnum,
-  e as VftEmpty,
-  e as default
-};
+import { withInstall } from "../../utils/vue/install.js";
+import { EmptyEnum } from "./constants.js";
+import empty_default from "./empty.js";
+//#region ../../packages/components/empty/index.ts
+const VftEmpty = withInstall(empty_default);
+//#endregion
+export { EmptyEnum, VftEmpty, VftEmpty as default };

package/es/components/empty/style/css.js

@@ -1,3 +1,3 @@
-import "vft/theme-style/base.css";
-import "vft/theme-style/vft-icon.css";
+import "../../base/style/css.js";
+import "../../icon/style/css.js";
 import "vft/theme-style/vft-empty.css";

package/es/components/empty/style/index.js

@@ -1,3 +1,3 @@
-import "vft/theme-style/src/base.scss";
-import "vft/theme-style/src/icon.scss";
+import "../../base/style/index.js";
+import "../../icon/style/index.js";
 import "vft/theme-style/src/empty.scss";

package/es/components/empty/types.js

@@ -1 +0,0 @@
-

package/es/components/focus-trap/focus-trap.js

@@ -0,0 +1,10 @@
+import focus_trap_vue_vue_type_script_lang_default from "./focus-trap.vue_vue_type_script_lang.js";
+import _plugin_vue_export_helper_default from "../../_virtual/_plugin-vue_export-helper.js";
+import { renderSlot } from "vue";
+//#region ../../packages/components/focus-trap/focus-trap.vue
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	return renderSlot(_ctx.$slots, "default", { handleKeydown: _ctx.onKeydown });
+}
+var focus_trap_default = /* @__PURE__ */ _plugin_vue_export_helper_default(focus_trap_vue_vue_type_script_lang_default, [["render", _sfc_render]]);
+//#endregion
+export { focus_trap_default as default };

package/es/components/focus-trap/focus-trap.vue_vue_type_script_lang.js

@@ -0,0 +1,191 @@
+import { FOCUS_AFTER_RELEASED, FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS, FOCUS_TRAP_INJECTION_KEY, ON_RELEASE_FOCUS_EVT, ON_TRAP_FOCUS_EVT } from "./tokens.js";
+import { createFocusOutPreventedEvent, focusFirstDescendant, focusableStack, getEdges, isFocusCausedByUserEvent, obtainAllFocusableElements, tryFocus, useFocusReason } from "./utils.js";
+import { isString } from "@vft/utils";
+import { isNil } from "lodash-es";
+import { defineComponent, nextTick, onBeforeUnmount, onMounted, provide, ref, unref, watch } from "vue";
+import { useEscapeKeydown } from "@vft/use";
+import { EVENT_CODE } from "@vft/constants";
+//#region ../../packages/components/focus-trap/focus-trap.vue?vue&type=script&lang.ts
+var focus_trap_vue_vue_type_script_lang_default = defineComponent({
+	name: "VftFocusTrap",
+	inheritAttrs: false,
+	props: {
+		loop: Boolean,
+		trapped: Boolean,
+		focusTrapEl: Object,
+		focusStartEl: {
+			type: [Object, String],
+			default: "first"
+		}
+	},
+	emits: [
+		ON_TRAP_FOCUS_EVT,
+		ON_RELEASE_FOCUS_EVT,
+		"focusin",
+		"focusout",
+		"focusout-prevented",
+		"release-requested"
+	],
+	setup(props, { emit }) {
+		const forwardRef = ref();
+		let lastFocusBeforeTrapped;
+		let lastFocusAfterTrapped;
+		const { focusReason } = useFocusReason();
+		useEscapeKeydown((event) => {
+			if (props.trapped && !focusLayer.paused) emit("release-requested", event);
+		});
+		const focusLayer = {
+			paused: false,
+			pause() {
+				this.paused = true;
+			},
+			resume() {
+				this.paused = false;
+			}
+		};
+		const onKeydown = (e) => {
+			if (!props.loop && !props.trapped) return;
+			if (focusLayer.paused) return;
+			const { code, altKey, ctrlKey, metaKey, currentTarget, shiftKey } = e;
+			const { loop } = props;
+			const isTabbing = code === EVENT_CODE.tab && !altKey && !ctrlKey && !metaKey;
+			const currentFocusingEl = document.activeElement;
+			if (isTabbing && currentFocusingEl) {
+				const container = currentTarget;
+				const [first, last] = getEdges(container);
+				if (!(first && last)) {
+					if (currentFocusingEl === container) {
+						const focusoutPreventedEvent = createFocusOutPreventedEvent({ focusReason: focusReason.value });
+						emit("focusout-prevented", focusoutPreventedEvent);
+						if (!focusoutPreventedEvent.defaultPrevented) e.preventDefault();
+					}
+				} else if (!shiftKey && currentFocusingEl === last) {
+					const focusoutPreventedEvent = createFocusOutPreventedEvent({ focusReason: focusReason.value });
+					emit("focusout-prevented", focusoutPreventedEvent);
+					if (!focusoutPreventedEvent.defaultPrevented) {
+						e.preventDefault();
+						if (loop) tryFocus(first, true);
+					}
+				} else if (shiftKey && [first, container].includes(currentFocusingEl)) {
+					const focusoutPreventedEvent = createFocusOutPreventedEvent({ focusReason: focusReason.value });
+					emit("focusout-prevented", focusoutPreventedEvent);
+					if (!focusoutPreventedEvent.defaultPrevented) {
+						e.preventDefault();
+						if (loop) tryFocus(last, true);
+					}
+				}
+			}
+		};
+		provide(FOCUS_TRAP_INJECTION_KEY, {
+			focusTrapRef: forwardRef,
+			onKeydown
+		});
+		watch(() => props.focusTrapEl, (focusTrapEl) => {
+			if (focusTrapEl) forwardRef.value = focusTrapEl;
+		}, { immediate: true });
+		watch([forwardRef], ([forwardRef], [oldForwardRef]) => {
+			if (forwardRef) {
+				forwardRef.addEventListener("keydown", onKeydown);
+				forwardRef.addEventListener("focusin", onFocusIn);
+				forwardRef.addEventListener("focusout", onFocusOut);
+			}
+			if (oldForwardRef) {
+				oldForwardRef.removeEventListener("keydown", onKeydown);
+				oldForwardRef.removeEventListener("focusin", onFocusIn);
+				oldForwardRef.removeEventListener("focusout", onFocusOut);
+			}
+		});
+		const trapOnFocus = (e) => {
+			emit(ON_TRAP_FOCUS_EVT, e);
+		};
+		const releaseOnFocus = (e) => emit(ON_RELEASE_FOCUS_EVT, e);
+		const onFocusIn = (e) => {
+			const trapContainer = unref(forwardRef);
+			if (!trapContainer) return;
+			const target = e.target;
+			const relatedTarget = e.relatedTarget;
+			const isFocusedInTrap = target && trapContainer.contains(target);
+			if (!props.trapped) {
+				if (!(relatedTarget && trapContainer.contains(relatedTarget))) lastFocusBeforeTrapped = relatedTarget;
+			}
+			if (isFocusedInTrap) emit("focusin", e);
+			if (focusLayer.paused) return;
+			if (props.trapped) if (isFocusedInTrap) lastFocusAfterTrapped = target;
+			else tryFocus(lastFocusAfterTrapped, true);
+		};
+		const onFocusOut = (e) => {
+			const trapContainer = unref(forwardRef);
+			if (focusLayer.paused || !trapContainer) return;
+			if (props.trapped) {
+				const relatedTarget = e.relatedTarget;
+				if (!isNil(relatedTarget) && !trapContainer.contains(relatedTarget)) setTimeout(() => {
+					if (!focusLayer.paused && props.trapped) {
+						const focusoutPreventedEvent = createFocusOutPreventedEvent({ focusReason: focusReason.value });
+						emit("focusout-prevented", focusoutPreventedEvent);
+						if (!focusoutPreventedEvent.defaultPrevented) tryFocus(lastFocusAfterTrapped, true);
+					}
+				}, 0);
+			} else {
+				const target = e.target;
+				if (!(target && trapContainer.contains(target))) emit("focusout", e);
+			}
+		};
+		async function startTrap() {
+			await nextTick();
+			const trapContainer = unref(forwardRef);
+			if (trapContainer) {
+				focusableStack.push(focusLayer);
+				const prevFocusedElement = trapContainer.contains(document.activeElement) ? lastFocusBeforeTrapped : document.activeElement;
+				lastFocusBeforeTrapped = prevFocusedElement;
+				if (!trapContainer.contains(prevFocusedElement)) {
+					const focusEvent = new Event(FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS);
+					trapContainer.addEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
+					trapContainer.dispatchEvent(focusEvent);
+					if (!focusEvent.defaultPrevented) nextTick(() => {
+						let focusStartEl = props.focusStartEl;
+						if (!isString(focusStartEl)) {
+							tryFocus(focusStartEl);
+							if (document.activeElement !== focusStartEl) focusStartEl = "first";
+						}
+						if (focusStartEl === "first") focusFirstDescendant(obtainAllFocusableElements(trapContainer), true);
+						if (document.activeElement === prevFocusedElement || focusStartEl === "container") tryFocus(trapContainer);
+					});
+				}
+			}
+		}
+		function stopTrap() {
+			const trapContainer = unref(forwardRef);
+			if (trapContainer) {
+				trapContainer.removeEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
+				const releasedEvent = new CustomEvent(FOCUS_AFTER_RELEASED, {
+					...FOCUS_AFTER_TRAPPED_OPTS,
+					detail: { focusReason: focusReason.value }
+				});
+				trapContainer.addEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
+				trapContainer.dispatchEvent(releasedEvent);
+				if (!releasedEvent.defaultPrevented && (focusReason.value == "keyboard" || !isFocusCausedByUserEvent() || trapContainer.contains(document.activeElement))) tryFocus(lastFocusBeforeTrapped ?? document.body);
+				trapContainer.removeEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
+				focusableStack.remove(focusLayer);
+			}
+		}
+		onMounted(() => {
+			if (props.trapped) startTrap();
+			watch(() => props.trapped, (trapped) => {
+				if (trapped) startTrap();
+				else stopTrap();
+			});
+		});
+		onBeforeUnmount(() => {
+			if (props.trapped) stopTrap();
+			if (forwardRef.value) {
+				forwardRef.value.removeEventListener("keydown", onKeydown);
+				forwardRef.value.removeEventListener("focusin", onFocusIn);
+				forwardRef.value.removeEventListener("focusout", onFocusOut);
+				forwardRef.value = void 0;
+			}
+		});
+		return { onKeydown };
+	}
+});
+//#endregion
+export { focus_trap_vue_vue_type_script_lang_default as default };

package/es/components/focus-trap/index.js

@@ -1,25 +1,7 @@
-import E from "./focus-trap.vue.js";
-import { FOCUSOUT_PREVENTED as _, FOCUSOUT_PREVENTED_OPTS as F, FOCUS_AFTER_RELEASED as o, FOCUS_AFTER_TRAPPED as T, FOCUS_AFTER_TRAPPED_OPTS as O, FOCUS_TRAP_INJECTION_KEY as r, ON_RELEASE_FOCUS_EVT as S, ON_TRAP_FOCUS_EVT as u } from "./tokens.js";
-import { createFocusOutPreventedEvent as a, focusFirstDescendant as c, focusableStack as P, getEdges as U, getVisibleElement as n, isFocusCausedByUserEvent as A, isHidden as C, obtainAllFocusableElements as i, tryFocus as l, useFocusReason as d } from "./utils.js";
-export {
-  _ as FOCUSOUT_PREVENTED,
-  F as FOCUSOUT_PREVENTED_OPTS,
-  o as FOCUS_AFTER_RELEASED,
-  T as FOCUS_AFTER_TRAPPED,
-  O as FOCUS_AFTER_TRAPPED_OPTS,
-  r as FOCUS_TRAP_INJECTION_KEY,
-  S as ON_RELEASE_FOCUS_EVT,
-  u as ON_TRAP_FOCUS_EVT,
-  E as VftFocusTrap,
-  a as createFocusOutPreventedEvent,
-  E as default,
-  c as focusFirstDescendant,
-  P as focusableStack,
-  U as getEdges,
-  n as getVisibleElement,
-  A as isFocusCausedByUserEvent,
-  C as isHidden,
-  i as obtainAllFocusableElements,
-  l as tryFocus,
-  d as useFocusReason
-};
+import { FOCUSOUT_PREVENTED, FOCUSOUT_PREVENTED_OPTS, FOCUS_AFTER_RELEASED, FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS, FOCUS_TRAP_INJECTION_KEY, ON_RELEASE_FOCUS_EVT, ON_TRAP_FOCUS_EVT } from "./tokens.js";
+import { createFocusOutPreventedEvent, focusFirstDescendant, focusableStack, getEdges, getVisibleElement, isFocusCausedByUserEvent, isHidden, obtainAllFocusableElements, tryFocus, useFocusReason } from "./utils.js";
+import focus_trap_default from "./focus-trap.js";
+//#region ../../packages/components/focus-trap/index.ts
+var focus_trap_default$1 = focus_trap_default;
+//#endregion
+export { FOCUSOUT_PREVENTED, FOCUSOUT_PREVENTED_OPTS, FOCUS_AFTER_RELEASED, FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS, FOCUS_TRAP_INJECTION_KEY, ON_RELEASE_FOCUS_EVT, ON_TRAP_FOCUS_EVT, focus_trap_default as VftFocusTrap, createFocusOutPreventedEvent, focus_trap_default$1 as default, focusFirstDescendant, focusableStack, getEdges, getVisibleElement, isFocusCausedByUserEvent, isHidden, obtainAllFocusableElements, tryFocus, useFocusReason };

package/es/components/focus-trap/tokens.js

@@ -1,17 +1,17 @@
-const e = "focus-trap.focus-after-trapped", s = "focus-trap.focus-after-released", t = "focus-trap.focusout-prevented", c = {
-  cancelable: !0,
-  bubbles: !1
-}, E = {
-  cancelable: !0,
-  bubbles: !1
-}, o = "focusAfterTrapped", _ = "focusAfterReleased", T = Symbol("vftFocusTrap");
-export {
-  t as FOCUSOUT_PREVENTED,
-  E as FOCUSOUT_PREVENTED_OPTS,
-  s as FOCUS_AFTER_RELEASED,
-  e as FOCUS_AFTER_TRAPPED,
-  c as FOCUS_AFTER_TRAPPED_OPTS,
-  T as FOCUS_TRAP_INJECTION_KEY,
-  _ as ON_RELEASE_FOCUS_EVT,
-  o as ON_TRAP_FOCUS_EVT
+//#region ../../packages/components/focus-trap/tokens.ts
+const FOCUS_AFTER_TRAPPED = "focus-trap.focus-after-trapped";
+const FOCUS_AFTER_RELEASED = "focus-trap.focus-after-released";
+const FOCUSOUT_PREVENTED = "focus-trap.focusout-prevented";
+const FOCUS_AFTER_TRAPPED_OPTS = {
+	cancelable: true,
+	bubbles: false
 };
+const FOCUSOUT_PREVENTED_OPTS = {
+	cancelable: true,
+	bubbles: false
+};
+const ON_TRAP_FOCUS_EVT = "focusAfterTrapped";
+const ON_RELEASE_FOCUS_EVT = "focusAfterReleased";
+const FOCUS_TRAP_INJECTION_KEY = Symbol("vftFocusTrap");
+//#endregion
+export { FOCUSOUT_PREVENTED, FOCUSOUT_PREVENTED_OPTS, FOCUS_AFTER_RELEASED, FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS, FOCUS_TRAP_INJECTION_KEY, ON_RELEASE_FOCUS_EVT, ON_TRAP_FOCUS_EVT };

package/es/components/focus-trap/utils.js

@@ -1,88 +1,125 @@
-import { isFocusable as p } from "../../utils/dom/aria.js";
-import "@vueuse/core";
-import { isElement as f } from "@vft/utils";
-import "../config-provider/hooks/use-global-config.js";
-import { ref as i, onMounted as v, onBeforeUnmount as F } from "vue";
-import "lodash-es";
-import "../form/index.js";
-import { FOCUSOUT_PREVENTED as b, FOCUSOUT_PREVENTED_OPTS as w } from "./tokens.js";
-const a = i(), u = i(0), d = i(0);
-let r = 0;
-const T = (e) => {
-  const o = [], n = document.createTreeWalker(e, NodeFilter.SHOW_ELEMENT, {
-    acceptNode: (t) => {
-      const s = t.tagName === "INPUT" && t.type === "hidden";
-      return t.disabled || t.hidden || s ? NodeFilter.FILTER_SKIP : t.tabIndex >= 0 || t === document.activeElement ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
-    }
-  });
-  for (; n.nextNode(); ) o.push(n.currentNode);
-  return o;
-}, m = (e, o) => {
-  for (const n of e)
-    if (!N(n, o)) return n;
-}, N = (e, o) => {
-  if (process.env.NODE_ENV === "test") return !1;
-  if (getComputedStyle(e).visibility === "hidden") return !0;
-  for (; e; ) {
-    if (o && e === o) return !1;
-    if (getComputedStyle(e).display === "none") return !0;
-    e = e.parentElement;
-  }
-  return !1;
-}, x = (e) => {
-  const o = T(e), n = m(o, e), t = m(o.reverse(), e);
-  return [n, t];
-}, y = (e) => e instanceof HTMLInputElement && "select" in e, S = (e, o) => {
-  if (e && e.focus) {
-    const n = document.activeElement;
-    let t = !1;
-    f(e) && !p(e) && !e.getAttribute("tabindex") && (e.setAttribute("tabindex", "-1"), t = !0), e.focus({ preventScroll: !0 }), d.value = window.performance.now(), e !== n && y(e) && o && e.select(), f(e) && t && e.removeAttribute("tabindex");
-  }
+import { isFocusable } from "../../utils/dom/aria.js";
+import { FOCUSOUT_PREVENTED, FOCUSOUT_PREVENTED_OPTS } from "./tokens.js";
+import { isElement } from "@vft/utils";
+import { onBeforeUnmount, onMounted, ref } from "vue";
+//#region ../../packages/components/focus-trap/utils.ts
+const focusReason = ref();
+const lastUserFocusTimestamp = ref(0);
+const lastAutomatedFocusTimestamp = ref(0);
+let focusReasonUserCount = 0;
+const obtainAllFocusableElements = (element) => {
+	const nodes = [];
+	const walker = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT, { acceptNode: (node) => {
+		const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
+		if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
+		return node.tabIndex >= 0 || node === document.activeElement ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+	} });
+	while (walker.nextNode()) nodes.push(walker.currentNode);
+	return nodes;
 };
-function l(e, o) {
-  const n = [...e], t = e.indexOf(o);
-  return t !== -1 && n.splice(t, 1), n;
+const getVisibleElement = (elements, container) => {
+	for (const element of elements) if (!isHidden(element, container)) return element;
+};
+const isHidden = (element, container) => {
+	if (getComputedStyle(element).visibility === "hidden") return true;
+	while (element) {
+		if (container && element === container) return false;
+		if (getComputedStyle(element).display === "none") return true;
+		element = element.parentElement;
+	}
+	return false;
+};
+const getEdges = (container) => {
+	const focusable = obtainAllFocusableElements(container);
+	return [getVisibleElement(focusable, container), getVisibleElement(focusable.reverse(), container)];
+};
+const isSelectable = (element) => {
+	return element instanceof HTMLInputElement && "select" in element;
+};
+const tryFocus = (element, shouldSelect) => {
+	if (element && element.focus) {
+		const prevFocusedElement = document.activeElement;
+		let cleanup = false;
+		if (isElement(element) && !isFocusable(element) && !element.getAttribute("tabindex")) {
+			element.setAttribute("tabindex", "-1");
+			cleanup = true;
+		}
+		element.focus({ preventScroll: true });
+		lastAutomatedFocusTimestamp.value = window.performance.now();
+		if (element !== prevFocusedElement && isSelectable(element) && shouldSelect) element.select();
+		if (isElement(element) && cleanup) element.removeAttribute("tabindex");
+	}
+};
+function removeFromStack(list, item) {
+	const copy = [...list];
+	const idx = list.indexOf(item);
+	if (idx !== -1) copy.splice(idx, 1);
+	return copy;
 }
-const L = () => {
-  let e = [];
-  return {
-    push: (t) => {
-      const s = e[0];
-      s && t !== s && s.pause(), e = l(e, t), e.unshift(t);
-    },
-    remove: (t) => {
-      e = l(e, t), e[0]?.resume?.();
-    }
-  };
-}, _ = (e, o = !1) => {
-  const n = document.activeElement;
-  for (const t of e)
-    if (S(t, o), document.activeElement !== n) return;
-}, g = L(), A = () => u.value > d.value, c = () => {
-  a.value = "pointer", u.value = window.performance.now();
-}, E = () => {
-  a.value = "keyboard", u.value = window.performance.now();
-}, D = () => (v(() => {
-  r === 0 && (document.addEventListener("mousedown", c), document.addEventListener("touchstart", c), document.addEventListener("keydown", E)), r++;
-}), F(() => {
-  r--, r <= 0 && (document.removeEventListener("mousedown", c), document.removeEventListener("touchstart", c), document.removeEventListener("keydown", E));
-}), {
-  focusReason: a,
-  lastUserFocusTimestamp: u,
-  lastAutomatedFocusTimestamp: d
-}), H = (e) => new CustomEvent(b, {
-  ...w,
-  detail: e
-});
-export {
-  H as createFocusOutPreventedEvent,
-  _ as focusFirstDescendant,
-  g as focusableStack,
-  x as getEdges,
-  m as getVisibleElement,
-  A as isFocusCausedByUserEvent,
-  N as isHidden,
-  T as obtainAllFocusableElements,
-  S as tryFocus,
-  D as useFocusReason
+const createFocusableStack = () => {
+	let stack = [];
+	const push = (layer) => {
+		const currentLayer = stack[0];
+		if (currentLayer && layer !== currentLayer) currentLayer.pause();
+		stack = removeFromStack(stack, layer);
+		stack.unshift(layer);
+	};
+	const remove = (layer) => {
+		stack = removeFromStack(stack, layer);
+		stack[0]?.resume?.();
+	};
+	return {
+		push,
+		remove
+	};
+};
+const focusFirstDescendant = (elements, shouldSelect = false) => {
+	const prevFocusedElement = document.activeElement;
+	for (const element of elements) {
+		tryFocus(element, shouldSelect);
+		if (document.activeElement !== prevFocusedElement) return;
+	}
+};
+const focusableStack = createFocusableStack();
+const isFocusCausedByUserEvent = () => {
+	return lastUserFocusTimestamp.value > lastAutomatedFocusTimestamp.value;
+};
+const notifyFocusReasonPointer = () => {
+	focusReason.value = "pointer";
+	lastUserFocusTimestamp.value = window.performance.now();
+};
+const notifyFocusReasonKeydown = () => {
+	focusReason.value = "keyboard";
+	lastUserFocusTimestamp.value = window.performance.now();
+};
+const useFocusReason = () => {
+	onMounted(() => {
+		if (focusReasonUserCount === 0) {
+			document.addEventListener("mousedown", notifyFocusReasonPointer);
+			document.addEventListener("touchstart", notifyFocusReasonPointer);
+			document.addEventListener("keydown", notifyFocusReasonKeydown);
+		}
+		focusReasonUserCount++;
+	});
+	onBeforeUnmount(() => {
+		focusReasonUserCount--;
+		if (focusReasonUserCount <= 0) {
+			document.removeEventListener("mousedown", notifyFocusReasonPointer);
+			document.removeEventListener("touchstart", notifyFocusReasonPointer);
+			document.removeEventListener("keydown", notifyFocusReasonKeydown);
+		}
+	});
+	return {
+		focusReason,
+		lastUserFocusTimestamp,
+		lastAutomatedFocusTimestamp
+	};
+};
+const createFocusOutPreventedEvent = (detail) => {
+	return new CustomEvent(FOCUSOUT_PREVENTED, {
+		...FOCUSOUT_PREVENTED_OPTS,
+		detail
+	});
 };
+//#endregion
+export { createFocusOutPreventedEvent, focusFirstDescendant, focusableStack, getEdges, getVisibleElement, isFocusCausedByUserEvent, isHidden, obtainAllFocusableElements, tryFocus, useFocusReason };