@wirekyt/dom 0.0.1 → 0.0.2

package/dist/dismissable-layer-BTX5EvXw.d.ts

@@ -0,0 +1,40 @@
+import { i as InteractOutsideHandlers } from "./index-C2865AJq.js";
+import { t as MaybeFunction } from "./functions-isw5Ovcx.js";
+//#region src/common/dismissable/layer-stack.d.ts
+type LayerType = "dialog" | "popover" | "menu" | "listbox" | (string & {});
+type LayerDismissEventDetail = {
+  originalLayer: HTMLElement;
+  targetLayer: HTMLElement | undefined;
+  originalIndex: number;
+  targetIndex: number;
+};
+type LayerDismissEvent = CustomEvent<LayerDismissEventDetail>;
+type LayerStyleTarget = () => HTMLElement | null;
+//#endregion
+//#region src/common/dismissable/dismissable-layer.d.ts
+type MaybeElement = HTMLElement | null;
+type Container = MaybeElement | Array<MaybeElement>;
+type NodeOrFn = MaybeFunction<MaybeElement>;
+interface DismissableElementHandlers extends InteractOutsideHandlers {
+  onEscapeKeyDown?: ((event: KeyboardEvent) => void) | undefined;
+  onRequestDismiss?: ((event: LayerDismissEvent) => void) | undefined;
+}
+interface PersistentElementOptions {
+  persistentElements?: Array<() => Element | null> | undefined;
+}
+interface DismissableElementOptions extends DismissableElementHandlers, PersistentElementOptions {
+  layerStyleTargets?: LayerStyleTarget[] | undefined;
+  debug?: boolean | undefined;
+  pointerBlocking?: boolean | undefined;
+  onDismiss: VoidFunction;
+  exclude?: MaybeFunction<Container> | undefined;
+  defer?: boolean | undefined;
+  warnOnMissingNode?: boolean | undefined;
+  type?: LayerType | undefined;
+}
+declare function trackDismissableElement(nodeOrFn: NodeOrFn, options: DismissableElementOptions): () => void;
+declare function trackDismissableBranch(nodeOrFn: NodeOrFn, options?: {
+  defer?: boolean | undefined;
+}): () => void;
+//#endregion
+export { trackDismissableElement as a, trackDismissableBranch as i, DismissableElementOptions as n, LayerStyleTarget as o, PersistentElementOptions as r, LayerType as s, DismissableElementHandlers as t };

package/dist/dismissable-layer-Ch5niVaq.d.cts

@@ -0,0 +1,40 @@
+import { i as InteractOutsideHandlers } from "./index-C2865AJq.cjs";
+import { t as MaybeFunction } from "./functions-isw5Ovcx.cjs";
+//#region src/common/dismissable/layer-stack.d.ts
+type LayerType = "dialog" | "popover" | "menu" | "listbox" | (string & {});
+type LayerDismissEventDetail = {
+  originalLayer: HTMLElement;
+  targetLayer: HTMLElement | undefined;
+  originalIndex: number;
+  targetIndex: number;
+};
+type LayerDismissEvent = CustomEvent<LayerDismissEventDetail>;
+type LayerStyleTarget = () => HTMLElement | null;
+//#endregion
+//#region src/common/dismissable/dismissable-layer.d.ts
+type MaybeElement = HTMLElement | null;
+type Container = MaybeElement | Array<MaybeElement>;
+type NodeOrFn = MaybeFunction<MaybeElement>;
+interface DismissableElementHandlers extends InteractOutsideHandlers {
+  onEscapeKeyDown?: ((event: KeyboardEvent) => void) | undefined;
+  onRequestDismiss?: ((event: LayerDismissEvent) => void) | undefined;
+}
+interface PersistentElementOptions {
+  persistentElements?: Array<() => Element | null> | undefined;
+}
+interface DismissableElementOptions extends DismissableElementHandlers, PersistentElementOptions {
+  layerStyleTargets?: LayerStyleTarget[] | undefined;
+  debug?: boolean | undefined;
+  pointerBlocking?: boolean | undefined;
+  onDismiss: VoidFunction;
+  exclude?: MaybeFunction<Container> | undefined;
+  defer?: boolean | undefined;
+  warnOnMissingNode?: boolean | undefined;
+  type?: LayerType | undefined;
+}
+declare function trackDismissableElement(nodeOrFn: NodeOrFn, options: DismissableElementOptions): () => void;
+declare function trackDismissableBranch(nodeOrFn: NodeOrFn, options?: {
+  defer?: boolean | undefined;
+}): () => void;
+//#endregion
+export { trackDismissableElement as a, trackDismissableBranch as i, DismissableElementOptions as n, LayerStyleTarget as o, PersistentElementOptions as r, LayerType as s, DismissableElementHandlers as t };

package/dist/dismissable.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_dismissable = require("./dismissable-C0bixtzl.cjs");
+exports.trackDismissableBranch = require_dismissable.trackDismissableBranch;
+exports.trackDismissableElement = require_dismissable.trackDismissableElement;

package/dist/dismissable.d.cts

@@ -0,0 +1,3 @@
+import { c as PointerDownOutsideEvent, i as InteractOutsideHandlers, n as FocusOutsideEvent, r as InteractOutsideEvent } from "./index-C2865AJq.cjs";
+import { a as trackDismissableElement, i as trackDismissableBranch, n as DismissableElementOptions, o as LayerStyleTarget, r as PersistentElementOptions, s as LayerType, t as DismissableElementHandlers } from "./dismissable-layer-Ch5niVaq.cjs";
+export { DismissableElementHandlers, DismissableElementOptions, type FocusOutsideEvent, type InteractOutsideEvent, type InteractOutsideHandlers, type LayerStyleTarget, type LayerType, PersistentElementOptions, type PointerDownOutsideEvent, trackDismissableBranch, trackDismissableElement };

package/dist/dismissable.d.ts

@@ -0,0 +1,3 @@
+import { c as PointerDownOutsideEvent, i as InteractOutsideHandlers, n as FocusOutsideEvent, r as InteractOutsideEvent } from "./index-C2865AJq.js";
+import { a as trackDismissableElement, i as trackDismissableBranch, n as DismissableElementOptions, o as LayerStyleTarget, r as PersistentElementOptions, s as LayerType, t as DismissableElementHandlers } from "./dismissable-layer-BTX5EvXw.js";
+export { DismissableElementHandlers, DismissableElementOptions, type FocusOutsideEvent, type InteractOutsideEvent, type InteractOutsideHandlers, type LayerStyleTarget, type LayerType, PersistentElementOptions, type PointerDownOutsideEvent, trackDismissableBranch, trackDismissableElement };

package/dist/dismissable.js

@@ -0,0 +1,2 @@
+import { n as trackDismissableElement, t as trackDismissableBranch } from "./dismissable-KM1jPtNQ.js";
+export { trackDismissableBranch, trackDismissableElement };

package/dist/dom-query-CQzY93XU.cjs

@@ -0,0 +1,488 @@
+//#region src/common/dom-query/shared.ts
+const clamp = (value) => Math.max(0, Math.min(1, value));
+const wrap = (v, idx) => {
+	return v.map((_, index) => v[(Math.max(idx, 0) + index) % v.length]);
+};
+const pipe = (...fns) => (arg) => fns.reduce((acc, fn) => fn(acc), arg);
+const noop = () => void 0;
+const isObject = (v) => typeof v === "object" && v !== null;
+const MAX_Z_INDEX = 2147483647;
+const dataAttr = (guard) => guard ? "" : void 0;
+const ariaAttr = (guard) => guard ? "true" : void 0;
+//#endregion
+//#region src/common/dom-query/node.ts
+const ELEMENT_NODE = 1;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_FRAGMENT_NODE = 11;
+const isElement = (el) => isObject(el) && el.nodeType === ELEMENT_NODE && typeof el.nodeName === "string";
+const isHTMLElement = (el) => isObject(el) && el.nodeType === ELEMENT_NODE && typeof el.nodeName === "string";
+const isDocument = (el) => isObject(el) && el.nodeType === DOCUMENT_NODE;
+const isWindow = (el) => isObject(el) && el === el.window;
+const isVisualViewport = (el) => isObject(el) && el.constructor.name === "VisualViewport";
+const getNodeName = (node) => {
+	if (isHTMLElement(node)) return node.localName || "";
+	return "#document";
+};
+function isRootElement(node) {
+	return [
+		"html",
+		"body",
+		"#document"
+	].includes(getNodeName(node));
+}
+const isNode = (el) => isObject(el) && el.nodeType !== void 0;
+const isShadowRoot = (el) => isNode(el) && el.nodeType === DOCUMENT_FRAGMENT_NODE && "host" in el;
+const isInputElement = (el) => isHTMLElement(el) && el.localName === "input";
+const isAnchorElement = (el) => !!el?.matches("a[href]");
+const isElementVisible = (el) => {
+	if (!isHTMLElement(el)) return false;
+	return el.offsetWidth > 0 || el.offsetHeight > 0 || el.getClientRects().length > 0;
+};
+function isActiveElement(element) {
+	if (!element) return false;
+	return getActiveElement(element.getRootNode()) === element;
+}
+const TEXTAREA_SELECT_REGEX = /(textarea|select)/;
+function isEditableElement(el) {
+	if (el == null || !isHTMLElement(el)) return false;
+	try {
+		return isInputElement(el) && el.selectionStart != null || TEXTAREA_SELECT_REGEX.test(el.localName) || el.isContentEditable || el.getAttribute("contenteditable") === "true" || el.getAttribute("contenteditable") === "";
+	} catch {
+		return false;
+	}
+}
+function getParentElement(node) {
+	const parentNode = node.parentNode;
+	if (isShadowRoot(parentNode)) return parentNode.host;
+	return parentNode;
+}
+function getAncestorElements(node) {
+	const ancestors = [];
+	while (node) {
+		ancestors.push(node);
+		node = getParentElement(node);
+	}
+	return ancestors;
+}
+function contains(parent, child) {
+	if (!parent || !child) return false;
+	if (!isHTMLElement(parent) || !isNode(child)) return false;
+	if (isHTMLElement(child) && parent === child) return true;
+	if (parent.contains(child)) return true;
+	const rootNode = child.getRootNode?.();
+	if (rootNode && isShadowRoot(rootNode)) {
+		let next = child;
+		while (next) {
+			if (parent === next) return true;
+			next = next.parentNode || next.host;
+		}
+	}
+	return false;
+}
+function getDocument(el) {
+	if (isDocument(el)) return el;
+	if (isWindow(el)) return el.document;
+	return el?.ownerDocument ?? document;
+}
+function getDocumentElement(el) {
+	return getDocument(el).documentElement;
+}
+function getWindow(el) {
+	if (isShadowRoot(el)) return getWindow(el.host);
+	if (isDocument(el)) return el.defaultView ?? window;
+	if (isHTMLElement(el)) return el.ownerDocument?.defaultView ?? window;
+	return window;
+}
+function getActiveElement(rootNode) {
+	let activeElement = rootNode.activeElement;
+	while (activeElement?.shadowRoot) {
+		const el = activeElement.shadowRoot.activeElement;
+		if (!el || el === activeElement) break;
+		else activeElement = el;
+	}
+	return activeElement;
+}
+function getParentNode(node) {
+	if (getNodeName(node) === "html") return node;
+	const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
+	return isShadowRoot(result) ? result.host : result;
+}
+function getRootNode(node) {
+	let result;
+	try {
+		result = node.getRootNode({ composed: true });
+		if (isDocument(result) || isShadowRoot(result)) return result;
+	} catch {}
+	return node.ownerDocument ?? document;
+}
+//#endregion
+//#region src/common/dom-query/query.ts
+function queryAll(root, selector) {
+	return Array.from(root?.querySelectorAll(selector) ?? []);
+}
+function query(root, selector) {
+	return root?.querySelector(selector) ?? null;
+}
+const defaultItemToId = (v) => v.id;
+function itemById(v, id, itemToId = defaultItemToId) {
+	return v.find((item) => itemToId(item) === id);
+}
+function indexOfId(v, id, itemToId = defaultItemToId) {
+	const item = itemById(v, id, itemToId);
+	return item ? v.indexOf(item) : -1;
+}
+function nextById(v, id, loop = true) {
+	let idx = indexOfId(v, id);
+	idx = loop ? (idx + 1) % v.length : Math.min(idx + 1, v.length - 1);
+	return v[idx];
+}
+function prevById(v, id, loop = true) {
+	let idx = indexOfId(v, id);
+	if (idx === -1) return loop ? v[v.length - 1] : null;
+	idx = loop ? (idx - 1 + v.length) % v.length : Math.max(0, idx - 1);
+	return v[idx];
+}
+//#endregion
+//#region src/common/dom-query/resize-observer.ts
+function createSharedResizeObserver(options) {
+	const listeners = /* @__PURE__ */ new WeakMap();
+	let observer;
+	const entries = /* @__PURE__ */ new WeakMap();
+	const getObserver = (win) => {
+		if (observer) return observer;
+		observer = new win.ResizeObserver((observedEntries) => {
+			for (const entry of observedEntries) {
+				entries.set(entry.target, entry);
+				const elementListeners = listeners.get(entry.target);
+				if (elementListeners) for (const listener of elementListeners) listener(entry);
+			}
+		});
+		return observer;
+	};
+	const observe = (element, listener) => {
+		let elementListeners = listeners.get(element) || /* @__PURE__ */ new Set();
+		elementListeners.add(listener);
+		listeners.set(element, elementListeners);
+		const win = getWindow(element);
+		getObserver(win).observe(element, options);
+		return () => {
+			const elementListeners = listeners.get(element);
+			if (!elementListeners) return;
+			elementListeners.delete(listener);
+			if (elementListeners.size === 0) {
+				listeners.delete(element);
+				getObserver(win).unobserve(element);
+			}
+		};
+	};
+	const unobserve = (element) => {
+		listeners.delete(element);
+		observer?.unobserve(element);
+	};
+	return {
+		observe,
+		unobserve
+	};
+}
+const resizeObserverContentBox = createSharedResizeObserver({ box: "content-box" });
+const resizeObserverBorderBox = createSharedResizeObserver({ box: "border-box" });
+const resizeObserverDevicePixelContentBox = createSharedResizeObserver({ box: "device-pixel-content-box" });
+//#endregion
+//#region src/common/dom-query/searchable.ts
+const sanitize = (str) => str.split("").map((char) => {
+	const code = char.charCodeAt(0);
+	if (code > 0 && code < 128) return char;
+	if (code >= 128 && code <= 255) return `/x${code.toString(16)}`.replace("/", "\\");
+	return "";
+}).join("").trim();
+const getValueText = (el) => {
+	return sanitize(el.dataset?.valuetext ?? el.textContent ?? "");
+};
+const match = (valueText, query) => {
+	return valueText.trim().toLowerCase().startsWith(query.toLowerCase());
+};
+function getByText(v, text, currentId, itemToId = defaultItemToId) {
+	const index = currentId ? indexOfId(v, currentId, itemToId) : -1;
+	let items = currentId ? wrap(v, index) : v;
+	if (text.length === 1) items = items.filter((item) => itemToId(item) !== currentId);
+	return items.find((item) => match(getValueText(item), text));
+}
+//#endregion
+//#region src/common/dom-query/typeahead.ts
+function getByTypeaheadImpl(baseItems, options) {
+	const { state, activeId, key, timeout = 350, itemToId } = options;
+	const search = state.keysSoFar + key;
+	const query = search.length > 1 && Array.from(search).every((char) => char === search[0]) ? search[0] : search;
+	const next = getByText(baseItems.slice(), query, activeId, itemToId);
+	function cleanup() {
+		clearTimeout(state.timer);
+		state.timer = -1;
+	}
+	function update(value) {
+		state.keysSoFar = value;
+		cleanup();
+		if (value !== "") state.timer = +setTimeout(() => {
+			update("");
+			cleanup();
+		}, timeout);
+	}
+	update(search);
+	return next;
+}
+const getByTypeahead = Object.assign(getByTypeaheadImpl, {
+	defaultOptions: {
+		keysSoFar: "",
+		timer: -1
+	},
+	isValidEvent: isValidTypeaheadEvent
+});
+function isValidTypeaheadEvent(event) {
+	return event.key.length === 1 && !event.ctrlKey && !event.metaKey;
+}
+//#endregion
+Object.defineProperty(exports, "MAX_Z_INDEX", {
+	enumerable: true,
+	get: function() {
+		return MAX_Z_INDEX;
+	}
+});
+Object.defineProperty(exports, "ariaAttr", {
+	enumerable: true,
+	get: function() {
+		return ariaAttr;
+	}
+});
+Object.defineProperty(exports, "clamp", {
+	enumerable: true,
+	get: function() {
+		return clamp;
+	}
+});
+Object.defineProperty(exports, "contains", {
+	enumerable: true,
+	get: function() {
+		return contains;
+	}
+});
+Object.defineProperty(exports, "dataAttr", {
+	enumerable: true,
+	get: function() {
+		return dataAttr;
+	}
+});
+Object.defineProperty(exports, "defaultItemToId", {
+	enumerable: true,
+	get: function() {
+		return defaultItemToId;
+	}
+});
+Object.defineProperty(exports, "getActiveElement", {
+	enumerable: true,
+	get: function() {
+		return getActiveElement;
+	}
+});
+Object.defineProperty(exports, "getAncestorElements", {
+	enumerable: true,
+	get: function() {
+		return getAncestorElements;
+	}
+});
+Object.defineProperty(exports, "getByText", {
+	enumerable: true,
+	get: function() {
+		return getByText;
+	}
+});
+Object.defineProperty(exports, "getByTypeahead", {
+	enumerable: true,
+	get: function() {
+		return getByTypeahead;
+	}
+});
+Object.defineProperty(exports, "getDocument", {
+	enumerable: true,
+	get: function() {
+		return getDocument;
+	}
+});
+Object.defineProperty(exports, "getDocumentElement", {
+	enumerable: true,
+	get: function() {
+		return getDocumentElement;
+	}
+});
+Object.defineProperty(exports, "getNodeName", {
+	enumerable: true,
+	get: function() {
+		return getNodeName;
+	}
+});
+Object.defineProperty(exports, "getParentElement", {
+	enumerable: true,
+	get: function() {
+		return getParentElement;
+	}
+});
+Object.defineProperty(exports, "getParentNode", {
+	enumerable: true,
+	get: function() {
+		return getParentNode;
+	}
+});
+Object.defineProperty(exports, "getRootNode", {
+	enumerable: true,
+	get: function() {
+		return getRootNode;
+	}
+});
+Object.defineProperty(exports, "getWindow", {
+	enumerable: true,
+	get: function() {
+		return getWindow;
+	}
+});
+Object.defineProperty(exports, "indexOfId", {
+	enumerable: true,
+	get: function() {
+		return indexOfId;
+	}
+});
+Object.defineProperty(exports, "isActiveElement", {
+	enumerable: true,
+	get: function() {
+		return isActiveElement;
+	}
+});
+Object.defineProperty(exports, "isAnchorElement", {
+	enumerable: true,
+	get: function() {
+		return isAnchorElement;
+	}
+});
+Object.defineProperty(exports, "isDocument", {
+	enumerable: true,
+	get: function() {
+		return isDocument;
+	}
+});
+Object.defineProperty(exports, "isEditableElement", {
+	enumerable: true,
+	get: function() {
+		return isEditableElement;
+	}
+});
+Object.defineProperty(exports, "isElement", {
+	enumerable: true,
+	get: function() {
+		return isElement;
+	}
+});
+Object.defineProperty(exports, "isElementVisible", {
+	enumerable: true,
+	get: function() {
+		return isElementVisible;
+	}
+});
+Object.defineProperty(exports, "isHTMLElement", {
+	enumerable: true,
+	get: function() {
+		return isHTMLElement;
+	}
+});
+Object.defineProperty(exports, "isInputElement", {
+	enumerable: true,
+	get: function() {
+		return isInputElement;
+	}
+});
+Object.defineProperty(exports, "isNode", {
+	enumerable: true,
+	get: function() {
+		return isNode;
+	}
+});
+Object.defineProperty(exports, "isRootElement", {
+	enumerable: true,
+	get: function() {
+		return isRootElement;
+	}
+});
+Object.defineProperty(exports, "isShadowRoot", {
+	enumerable: true,
+	get: function() {
+		return isShadowRoot;
+	}
+});
+Object.defineProperty(exports, "isVisualViewport", {
+	enumerable: true,
+	get: function() {
+		return isVisualViewport;
+	}
+});
+Object.defineProperty(exports, "isWindow", {
+	enumerable: true,
+	get: function() {
+		return isWindow;
+	}
+});
+Object.defineProperty(exports, "itemById", {
+	enumerable: true,
+	get: function() {
+		return itemById;
+	}
+});
+Object.defineProperty(exports, "nextById", {
+	enumerable: true,
+	get: function() {
+		return nextById;
+	}
+});
+Object.defineProperty(exports, "noop", {
+	enumerable: true,
+	get: function() {
+		return noop;
+	}
+});
+Object.defineProperty(exports, "pipe", {
+	enumerable: true,
+	get: function() {
+		return pipe;
+	}
+});
+Object.defineProperty(exports, "prevById", {
+	enumerable: true,
+	get: function() {
+		return prevById;
+	}
+});
+Object.defineProperty(exports, "query", {
+	enumerable: true,
+	get: function() {
+		return query;
+	}
+});
+Object.defineProperty(exports, "queryAll", {
+	enumerable: true,
+	get: function() {
+		return queryAll;
+	}
+});
+Object.defineProperty(exports, "resizeObserverBorderBox", {
+	enumerable: true,
+	get: function() {
+		return resizeObserverBorderBox;
+	}
+});
+Object.defineProperty(exports, "resizeObserverContentBox", {
+	enumerable: true,
+	get: function() {
+		return resizeObserverContentBox;
+	}
+});
+Object.defineProperty(exports, "resizeObserverDevicePixelContentBox", {
+	enumerable: true,
+	get: function() {
+		return resizeObserverDevicePixelContentBox;
+	}
+});