@oscarpalmer/oui 0.19.0 → 0.21.0

package/dist/js/sortable.mjs

@@ -0,0 +1,243 @@
+import { attributable } from "./internal/attributable.mjs";
+import { Draggable, addDraggable, removeDraggable } from "./internal/draggable.mjs";
+import { getPosition } from "@oscarpalmer/toretto/event";
+import { findAncestor, getElementFromPosition } from "@oscarpalmer/toretto/find";
+import { createElement } from "@oscarpalmer/toretto/create";
+//#region src/js/sortable.ts
+var Sortable = class extends Draggable {
+	connections;
+	origin;
+	get dragged() {
+		return getDragPlaceholder();
+	}
+	constructor(element) {
+		super("sort", element, {
+			container: {
+				attribute: ATTRIBUTE_CONTAINER,
+				map: CONTAINERS
+			},
+			direction: { attribute: ATTRIBUTE_DIRECTION },
+			drag: {
+				onBegin,
+				onCancel,
+				onEnd,
+				onMove
+			},
+			position: {
+				getOffset: getOffsetPosition,
+				getOriginal: getOriginalPosition
+			}
+		});
+		this.connections = this.element.getAttribute(ATTRIBUTE_CONNECTIONS);
+	}
+};
+function afterEnd(insert, from, events, elements, position, valid) {
+	elements.origin?.removeAttribute(ATTRIBUTE_ORIGIN);
+	from.origin = void 0;
+	resetPlaceholders();
+	if (!valid || events.some((event) => event.defaultPrevented)) return;
+	if (insert !== "insert") {
+		elements.target.append(elements.origin);
+		return;
+	}
+	if (position == null) return;
+	const { height, top } = elements.target.getBoundingClientRect();
+	let insertion;
+	if (position.y < top + height / 2) insertion = INSERT_BEFORE;
+	else insertion = INSERT_AFTER;
+	elements.target?.insertAdjacentElement(insertion, elements.origin);
+	document.body.removeAttribute(ATTRIBUTE_ACTIVE);
+}
+function getDragPlaceholder() {
+	placeholder.drag.default ??= createElement("div");
+	return placeholder.drag.custom ?? placeholder.drag.default;
+}
+function getOffsetPosition(_, draggable, element, position) {
+	const rectangle = element.getBoundingClientRect();
+	return {
+		x: draggable.horizontal ? 0 : position.x - rectangle.left,
+		y: draggable.vertical ? 0 : position.y - rectangle.top
+	};
+}
+function getOriginalPosition(_, __, position) {
+	return position;
+}
+function getPositionPlaceholder(sortable) {
+	placeholder.position ??= createElement("div");
+	placeholder.position.setAttribute(ATTRIBUTE_PLACEHOLDER_POSITION, "");
+	if (sortable.origin != null) placeholder.position.style.setProperty("--placeholder-height", `${sortable.origin.getBoundingClientRect().height}px`);
+	return placeholder.position;
+}
+function onBegin(_, state, draggable, element) {
+	const sortable = draggable;
+	sortable.origin = element;
+	setPlaceholder(state, sortable, element);
+	element.setAttribute(ATTRIBUTE_ORIGIN, "");
+	document.body.setAttribute(ATTRIBUTE_ACTIVE, "");
+}
+function onCancel(_, draggable) {
+	const sortable = draggable;
+	const { origin } = sortable;
+	origin?.removeAttribute(ATTRIBUTE_ORIGIN);
+	document.body.removeAttribute(ATTRIBUTE_ACTIVE);
+	resetPlaceholders();
+	sortable.origin = void 0;
+}
+function onEnd(event, state, draggable, reset) {
+	const from = draggable;
+	const { origin } = from;
+	const position = getPosition(event) ?? {
+		x: 0,
+		y: 0
+	};
+	const target = getElementFromPosition(position)[0];
+	let element = findAncestor(target, SELECTOR_ITEM);
+	if (element?.hasAttribute(ATTRIBUTE_PLACEHOLDER_POSITION)) if (element.getAttribute(ATTRIBUTE_PLACEHOLDER_POSITION) === "after") element = element.previousElementSibling;
+	else element = element.nextElementSibling;
+	let insert = "insert";
+	let to;
+	if (element == null) {
+		element = findAncestor(target, SELECTOR);
+		to = state.instances.get(element)?.sortable;
+		insert = element == null ? void 0 : element.children.length === 0 ? "append" : "prepend";
+	} else to = state.instances.get(element.parentElement)?.sortable;
+	const valid = insert != null && validatePosition(state, from, to, position);
+	const options = {
+		detail: valid ? {
+			from: {
+				element: origin,
+				position: { ...state.original }
+			},
+			to: {
+				element,
+				position: { ...position }
+			}
+		} : void 0,
+		bubbles: false,
+		cancelable: true
+	};
+	const fromEvent = new CustomEvent(EVENT_END, options);
+	const toEvent = new CustomEvent(EVENT_END, options);
+	from.element.dispatchEvent(fromEvent);
+	if (from !== to) to?.element.dispatchEvent(toEvent);
+	setTimeout(() => {
+		afterEnd(insert, from, [fromEvent, toEvent], {
+			origin,
+			target: element
+		}, position, valid);
+		reset();
+	});
+}
+function onMove(event, state, draggable, position) {
+	const from = draggable;
+	const fromElement = from.origin;
+	const toElement = findAncestor(event, SELECTOR_ITEM);
+	let to;
+	if (toElement == null) to = state.instances.get(findAncestor(event, SELECTOR))?.sortable;
+	else to = state.instances.get(toElement.parentElement)?.sortable;
+	if (!validatePosition(state, from, to, position.original)) return;
+	const placeholder = getPositionPlaceholder(from);
+	if (toElement != null && toElement !== fromElement) {
+		const { height, top } = toElement.getBoundingClientRect();
+		let place;
+		if (position.calculated.y < top + height / 2) {
+			place = "before";
+			toElement.insertAdjacentElement(INSERT_BEFORE, placeholder);
+		} else {
+			place = "after";
+			toElement.insertAdjacentElement(INSERT_AFTER, placeholder);
+		}
+		placeholder.setAttribute(ATTRIBUTE_PLACEHOLDER_POSITION, place);
+	} else placeholder.remove();
+	return {
+		from: {
+			element: fromElement,
+			position: { ...state.original }
+		},
+		to: {
+			element: toElement,
+			position: { ...position.calculated }
+		}
+	};
+}
+function resetPlaceholders() {
+	placeholder.drag.custom?.remove();
+	placeholder.drag.default?.remove();
+	placeholder.position?.remove();
+	placeholder.drag.custom = void 0;
+}
+function setPlaceholder(state, sortable, origin) {
+	const element = getDragPlaceholder();
+	placeholder.drag.default.innerHTML = "";
+	updatePlaceholder(sortable, element);
+	const event = new CustomEvent(EVENT_PLACEHOLDER, {
+		cancelable: true,
+		detail: {
+			origin,
+			parent: sortable.element,
+			placeholder: element,
+			create: (value) => {
+				if (!(value instanceof HTMLElement)) return;
+				placeholder.drag.custom = value;
+				updatePlaceholder(sortable, value);
+				state.element = {
+					rectangle: value.getBoundingClientRect(),
+					node: value
+				};
+			}
+		}
+	});
+	sortable.element.dispatchEvent(event);
+	setTimeout(() => {
+		if (!event.defaultPrevented && placeholder.drag.custom == null) placeholder.drag.default?.append(element.cloneNode(true));
+		document.body.append(placeholder.drag.custom ?? placeholder.drag.default ?? "");
+	});
+}
+function updatePlaceholder(sortable, element) {
+	element.style.position = "fixed";
+	element.setAttribute(ATTRIBUTE_PLACEHOLDER_DRAG, "");
+	if (sortable.horizontal) element.setAttribute(ATTRIBUTE_HORIZONTAL, "");
+	else element.removeAttribute(ATTRIBUTE_HORIZONTAL);
+	if (sortable.vertical) element.setAttribute(ATTRIBUTE_VERTICAL, "");
+	else element.removeAttribute(ATTRIBUTE_VERTICAL);
+}
+function validatePosition(_, from, to, position) {
+	let valid = true;
+	const rectangle = from.origin?.getBoundingClientRect();
+	if (rectangle != null && !from.horizontal) valid = position.x >= rectangle.left && position.x <= rectangle.right;
+	if (valid && rectangle != null && !from.vertical) valid = position.y >= rectangle.top && position.y <= rectangle.bottom;
+	if (valid && from.connections != null) valid = to?.element.matches(from.connections) ?? true;
+	if (valid && to?.connections != null) valid = from.element.matches(to.connections);
+	return valid;
+}
+const ATTRIBUTE = "oui-sortable";
+const ATTRIBUTE_ACTIVE = `${ATTRIBUTE}-active`;
+const ATTRIBUTE_CONNECTIONS = `${ATTRIBUTE}-connections`;
+const ATTRIBUTE_CONTAINER = `${ATTRIBUTE}-container`;
+const ATTRIBUTE_DIRECTION = `${ATTRIBUTE}-direction`;
+const ATTRIBUTE_HORIZONTAL = `${ATTRIBUTE}-horizontal`;
+const ATTRIBUTE_ORIGIN = `${ATTRIBUTE}-origin`;
+const ATTRIBUTE_PLACEHOLDER_DRAG = `${ATTRIBUTE}-placeholder-drag`;
+const ATTRIBUTE_PLACEHOLDER_POSITION = `${ATTRIBUTE}-placeholder-position`;
+const ATTRIBUTE_VERTICAL = `${ATTRIBUTE}-vertical`;
+const CONTAINERS = /* @__PURE__ */ new Map();
+const EVENT_END = "sort:end";
+const EVENT_PLACEHOLDER = "sort:placeholder";
+const INSERT_AFTER = "afterend";
+const INSERT_BEFORE = "beforebegin";
+const SELECTOR = `[${ATTRIBUTE}]`;
+const SELECTOR_ITEM = `[${ATTRIBUTE}] > *`;
+const bound = {
+	constructor: Sortable,
+	property: "sortable"
+};
+const placeholder = {
+	drag: {
+		custom: void 0,
+		default: void 0
+	},
+	position: void 0
+};
+attributable(ATTRIBUTE, addDraggable.bind(bound), removeDraggable.bind(bound));
+//#endregion
+export { Sortable };

package/dist/js/splitter.d.mts

@@ -0,0 +1,25 @@
+//#region src/js/splitter.d.ts
+declare global {
+  interface HTMLElementTagNameMap {
+    [SELECTOR]: OuiSplitterElement;
+  }
+}
+declare class OuiSplitterElement extends HTMLElement {
+  #private;
+  static readonly observedAttributes: string[];
+  get max(): number;
+  set max(value: number);
+  get min(): number;
+  set min(value: number);
+  get size(): number;
+  set size(value: number);
+  get type(): string;
+  set type(value: string);
+  constructor();
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  attributeChangedCallback(name: string): void;
+}
+declare const SELECTOR = "oui-splitter";
+//#endregion
+export { OuiSplitterElement };

package/dist/js/{splitter.js → splitter.mjs}

@@ -1,10 +1,11 @@
+import { clamp } from "@oscarpalmer/atoms/number";
 import { getPosition, on } from "@oscarpalmer/toretto/event";
 import { findAncestor } from "@oscarpalmer/toretto/find";
-import { clamp } from "@oscarpalmer/atoms/number";
-import { isNullableOrWhitespace } from "@oscarpalmer/atoms/is";
-import { round } from "@oscarpalmer/atoms/math";
 import { toggleStyles } from "@oscarpalmer/toretto/style";
 import supportsTouch from "@oscarpalmer/toretto/touch";
+import { isNullableOrWhitespace } from "@oscarpalmer/atoms/is";
+import { round } from "@oscarpalmer/atoms/math";
+//#region src/js/splitter.ts
 var OuiSplitterElement = class extends HTMLElement {
 	static observedAttributes = [
 		"max",
@@ -63,7 +64,7 @@ var OuiSplitterElement = class extends HTMLElement {
 		}
 	}
 };
-var index = 0;
+let index = 0;
 var Splitter = class {
 	element;
 	handle;
@@ -114,11 +115,11 @@ function createHandle() {
 	handle.setAttribute(ATTRIBUTE_HANDLE, "");
 	return handle;
 }
-function createSeparator(splitter$1) {
+function createSeparator(splitter) {
 	const separator = document.createElement("div");
 	separator.role = "separator";
 	separator.tabIndex = 0;
-	separator.setAttribute("aria-controls", splitter$1.element.id);
+	separator.setAttribute("aria-controls", splitter.element.id);
 	separator.setAttribute("aria-label", "Resize panels");
 	separator.setAttribute(ATTRIBUTE_SEPARATOR, "");
 	return separator;
@@ -126,20 +127,20 @@ function createSeparator(splitter$1) {
 function getContained(min, value, max) {
 	return round(clamp(value, min, max), VALUE_DECIMALS);
 }
-function getSize(splitter$1, value) {
-	const { height, left, top, width } = splitter$1.rectangle;
-	const fraction = (value - (splitter$1.types.horizontal ? top : left)) / (splitter$1.types.horizontal ? height : width);
-	return getContained(splitter$1.values.min, fraction, splitter$1.values.max);
+function getSize(splitter, value) {
+	const { height, left, top, width } = splitter.rectangle;
+	const fraction = (value - (splitter.types.horizontal ? top : left)) / (splitter.types.horizontal ? height : width);
+	return getContained(splitter.values.min, fraction, splitter.values.max);
 }
-function getTypes(splitter$1, width, height) {
-	const type = splitter$1.element.getAttribute("type")?.trim() ?? "";
+function getTypes(splitter, width, height) {
+	const type = splitter.element.getAttribute("type")?.trim() ?? "";
 	if (type === "horizontal") return {
 		auto: false,
 		horizontal: true
 	};
 	if (type === "auto") return {
 		auto: true,
-		horizontal: (height ?? splitter$1.rectangle.height) > (width ?? splitter$1.rectangle.width)
+		horizontal: (height ?? splitter.rectangle.height) > (width ?? splitter.rectangle.width)
 	};
 	return {
 		auto: false,
@@ -189,34 +190,34 @@ function onKeydown(event) {
 	}
 }
 function onNavigate(event) {
-	const splitter$1 = MAPPED_ELEMENTS.get(findAncestor(event.target, "[oui-splitter-separator]"));
-	if (splitter$1 == null) return;
-	const { types, values } = splitter$1;
+	const splitter = MAPPED_ELEMENTS.get(findAncestor(event, "[oui-splitter-separator]"));
+	if (splitter == null) return;
+	const { types, values } = splitter;
 	if (KEYS_ABSOLUTE.has(event.key)) {
-		setSize(splitter$1, event.key === "End" ? values.max : values.min, true);
+		setSize(splitter, event.key === "End" ? values.max : values.min, true);
 		return;
 	}
 	if (types.horizontal && !KEYS_HORIZONTAL.has(event.key) || !(types.horizontal || KEYS_VERTICAL.has(event.key))) return;
 	const offset = KEYS_NEGATIVE.has(event.key) ? -1 : 1;
-	setSize(splitter$1, getContained(values.min, values.now.current + offset * NAVIGATION_MODIFIER, values.max), true);
+	setSize(splitter, getContained(values.min, values.now.current + offset * NAVIGATION_MODIFIER, values.max), true);
 }
 function onObservation(entries) {
 	if (frame != null) cancelAnimationFrame(frame);
 	frame = requestAnimationFrame(() => {
 		for (const entry of entries) {
-			const splitter$1 = MAPPED_ELEMENTS.get(entry.target);
-			if (splitter$1 == null) return;
-			splitter$1.types = getTypes(splitter$1, entry.contentRect.width, entry.contentRect.height);
-			if (splitter$1.types.horizontal) splitter$1.element.setAttribute(ATTRIBUTE_HORIZONTAL, "");
-			else splitter$1.element.removeAttribute(ATTRIBUTE_HORIZONTAL);
-			setAriaOrientation(splitter$1);
+			const splitter = MAPPED_ELEMENTS.get(entry.target);
+			if (splitter == null) return;
+			splitter.types = getTypes(splitter, entry.contentRect.width, entry.contentRect.height);
+			if (splitter.types.horizontal) splitter.element.setAttribute(ATTRIBUTE_HORIZONTAL, "");
+			else splitter.element.removeAttribute(ATTRIBUTE_HORIZONTAL);
+			setAriaOrientation(splitter);
 		}
 		frame = void 0;
 	});
 }
 function onPointerdown(event) {
-	if (event.type === "mousedown" && supportsTouch.value || event.type === "touchstart" && !supportsTouch.value) return;
-	splitter = MAPPED_ELEMENTS.get(findAncestor(event.target, SELECTOR_HANDLE));
+	if (supportsTouch.value ? event.type === "mousedown" : event.type === "touchstart") return;
+	splitter = MAPPED_ELEMENTS.get(findAncestor(event, SELECTOR_HANDLE));
 	if (splitter == null) return;
 	if (supportsTouch.value) event.preventDefault();
 	splitter.handle.setAttribute(ATTRIBUTE_ACTIVE, "");
@@ -235,51 +236,51 @@ function onPointermove(event) {
 function onPointerup() {
 	if (splitter != null) onEnd(false);
 }
-function setAriaOrientation(splitter$1) {
-	splitter$1.separator.setAttribute("aria-orientation", splitter$1.types.horizontal ? "horizontal" : "vertical");
+function setAriaOrientation(splitter) {
+	splitter.separator.setAttribute("aria-orientation", splitter.types.horizontal ? "horizontal" : "vertical");
 }
-function setAriaValue(splitter$1) {
-	splitter$1.separator.setAttribute("aria-valuemax", String(splitter$1.values.max));
-	splitter$1.separator.setAttribute("aria-valuemin", String(splitter$1.values.min));
-	splitter$1.separator.setAttribute("aria-valuenow", String(splitter$1.values.now.current));
+function setAriaValue(splitter) {
+	splitter.separator.setAttribute("aria-valuemax", String(splitter.values.max));
+	splitter.separator.setAttribute("aria-valuemin", String(splitter.values.min));
+	splitter.separator.setAttribute("aria-valuenow", String(splitter.values.now.current));
 }
-function setSize(splitter$1, size, previous) {
-	splitter$1.values.now.current = size;
-	if (previous) splitter$1.values.now.previous = size;
-	splitter$1.element.style.setProperty("--oui-splitter-size", `${size}`);
-	setAriaValue(splitter$1);
+function setSize(splitter, size, previous) {
+	splitter.values.now.current = size;
+	if (previous) splitter.values.now.previous = size;
+	splitter.element.style.setProperty("--oui-splitter-size", `${size}`);
+	setAriaValue(splitter);
 }
-var SELECTOR = "oui-splitter";
-var ATTRIBUTE_ACTIVE = `${SELECTOR}-active`;
-var ATTRIBUTE_HANDLE = `${SELECTOR}-handle`;
-var ATTRIBUTE_HORIZONTAL = `${SELECTOR}-horizontal`;
-var ATTRIBUTE_SEPARATOR = `${SELECTOR}-separator`;
-var KEYS_ABSOLUTE = new Set(["End", "Home"]);
-var KEYS_HORIZONTAL = new Set(["ArrowDown", "ArrowUp"]);
-var KEYS_NEGATIVE = new Set(["ArrowLeft", "ArrowUp"]);
-var KEYS_VERTICAL = new Set(["ArrowLeft", "ArrowRight"]);
-var KEYS_ALL = new Set([
+const SELECTOR = "oui-splitter";
+const ATTRIBUTE_ACTIVE = `${SELECTOR}-active`;
+const ATTRIBUTE_HANDLE = `${SELECTOR}-handle`;
+const ATTRIBUTE_HORIZONTAL = `${SELECTOR}-horizontal`;
+const ATTRIBUTE_SEPARATOR = `${SELECTOR}-separator`;
+const KEYS_ABSOLUTE = new Set(["End", "Home"]);
+const KEYS_HORIZONTAL = new Set(["ArrowDown", "ArrowUp"]);
+const KEYS_NEGATIVE = new Set(["ArrowLeft", "ArrowUp"]);
+const KEYS_VERTICAL = new Set(["ArrowLeft", "ArrowRight"]);
+const KEYS_ALL = new Set([
 	...KEYS_ABSOLUTE,
 	...KEYS_HORIZONTAL,
 	...KEYS_VERTICAL
 ]);
-var MAPPED_ELEMENTS = /* @__PURE__ */ new WeakMap();
-var METHODS_CONNECT = ["delete", "set"];
-var METHODS_OBSERVE = ["unobserve", "observe"];
-var NAVIGATION_MAXIMUM_PERCENTAGE = .9;
-var NAVIGATION_MAXIMUM_TOTAL = 100;
-var NAVIGATION_MINIMUM_PERCENTAGE = .1;
-var NAVIGATION_MODIFIER = .05;
-var RESIZE_OBSERVER = new ResizeObserver(onObservation);
-var SELECTOR_HANDLE = `[${ATTRIBUTE_HANDLE}]`;
-var STYLING_TOGGLER = toggleStyles(document.body, {
+const MAPPED_ELEMENTS = /* @__PURE__ */ new WeakMap();
+const METHODS_CONNECT = ["delete", "set"];
+const METHODS_OBSERVE = ["unobserve", "observe"];
+const NAVIGATION_MAXIMUM_PERCENTAGE = .9;
+const NAVIGATION_MAXIMUM_TOTAL = 100;
+const NAVIGATION_MINIMUM_PERCENTAGE = .1;
+const NAVIGATION_MODIFIER = .05;
+const RESIZE_OBSERVER = new ResizeObserver(onObservation);
+const SELECTOR_HANDLE = `[${ATTRIBUTE_HANDLE}]`;
+const STYLING_TOGGLER = toggleStyles(document.body, {
 	touchAction: "none",
 	userSelect: "none",
 	webkitUserSelect: "none"
 });
-var VALUE_DECIMALS = 6;
-var frame;
-var splitter;
+const VALUE_DECIMALS = 6;
+let frame;
+let splitter;
 customElements.define(SELECTOR, OuiSplitterElement);
 on(document, "keydown", onKeydown);
 on(document, "mousedown", onPointerdown);
@@ -287,4 +288,5 @@ on(document, "pointermove", onPointermove);
 on(document, "pointerup", onPointerup);
 on(document, "touchcancel", onPointerup, { passive: false });
 on(document, "touchstart", onPointerdown, { passive: false });
+//#endregion
 export { OuiSplitterElement };

package/dist/js/tooltip.d.mts

@@ -0,0 +1,4 @@
+//#region src/js/tooltip.d.ts
+declare function setTooltipDelay(value: number): void;
+//#endregion
+export { setTooltipDelay };

package/dist/js/{tooltip.js → tooltip.mjs}

@@ -1,8 +1,9 @@
-import { attributable } from "./attributable.js";
-import { Floatable } from "./floatable.js";
+import { attributable } from "./internal/attributable.mjs";
+import { Floatable } from "./internal/floatable.mjs";
 import { on } from "@oscarpalmer/toretto/event";
 import { findAncestor } from "@oscarpalmer/toretto/find";
 import { isNullableOrWhitespace } from "@oscarpalmer/atoms/is";
+//#region src/js/tooltip.ts
 var Tooltip = class {
 	attributes;
 	floatable;
@@ -42,11 +43,11 @@ function closeTooltips(next) {
 	for (const active of tooltips) {
 		if (active === next) continue;
 		if (active.timer != null) clearTimeout(active.timer);
-		active.floatable.options.content.removeAttribute("oui-tooltip-content-active");
+		active.floatable?.options.content.removeAttribute("oui-tooltip-content-active");
 		requestAnimationFrame(() => {
 			active.timer = setTimeout(() => {
 				TOOLTIPS_ACTIVE.delete(active);
-				active.floatable.toggle(false);
+				active.floatable?.toggle(false);
 			}, delay);
 		});
 	}
@@ -114,7 +115,7 @@ function onActivate(event) {
 	onToggle(event, true);
 }
 function onClick(event) {
-	if (findAncestor(event.target, SELECTOR_CONTENT) != null) event.stopPropagation();
+	if (findAncestor(event, SELECTOR_CONTENT) != null) event.stopPropagation();
 }
 function onDeactivate(event) {
 	onToggle(event, false);
@@ -123,7 +124,7 @@ function onToggle(event, activate) {
 	if (toggle != null) cancelAnimationFrame(toggle);
 	toggle = requestAnimationFrame(() => {
 		toggle = void 0;
-		const element = findAncestor(event.target, SELECTOR_FULL);
+		const element = findAncestor(event, SELECTOR_FULL);
 		const tooltip = TOOLTIPS_ALL.get(element);
 		if (TOOLTIPS_ACTIVE.size > 0) closeTooltips(tooltip);
 		if (tooltip == null || tooltip.floatable.options.content.hasAttribute("oui-tooltip-content-active") === activate) return;
@@ -150,25 +151,26 @@ function reset(anchor, attributes) {
 	if (attributes.ariaDescribedby == null) anchor.removeAttribute("aria-describedby");
 	else anchor.setAttribute("aria-describedby", attributes.ariaDescribedby);
 }
-function setDelay(value) {
+function setTooltipDelay(value) {
 	delay = typeof value === "number" && value >= 0 ? value : delay;
 }
-var SELECTOR = "oui-tooltip";
-var ATTRIBUTE_CLASS = `${SELECTOR}-class`;
-var ATTRIBUTE_CONTENT = `${SELECTOR}-content`;
-var ATTRIBUTE_POSITION = `${SELECTOR}-position`;
-var SELECTOR_CONTENT = `[${ATTRIBUTE_CONTENT}]`;
-var SELECTOR_FULL = `[${SELECTOR}], [${ATTRIBUTE_CONTENT}]`;
-var EXPRESSION_WHITESPACE = /\s+/;
-var TOOLTIPS_ACTIVE = /* @__PURE__ */ new Set();
-var TOOLTIPS_ALL = /* @__PURE__ */ new WeakMap();
-var delay = 250;
-var index = 0;
-var toggle;
+const SELECTOR = "oui-tooltip";
+const ATTRIBUTE_CLASS = `${SELECTOR}-class`;
+const ATTRIBUTE_CONTENT = `${SELECTOR}-content`;
+const ATTRIBUTE_POSITION = `${SELECTOR}-position`;
+const SELECTOR_CONTENT = `[${ATTRIBUTE_CONTENT}]`;
+const SELECTOR_FULL = `[${SELECTOR}], [${ATTRIBUTE_CONTENT}]`;
+const EXPRESSION_WHITESPACE = /\s+/;
+const TOOLTIPS_ACTIVE = /* @__PURE__ */ new Set();
+const TOOLTIPS_ALL = /* @__PURE__ */ new WeakMap();
+let delay = 500;
+let index = 0;
+let toggle;
 attributable(SELECTOR, addTooltip, removeTooltip);
 on(document, "click", onClick, { capture: true });
 on(document, "focusin", onActivate);
 on(document, "focusout", onDeactivate);
 on(document, "mousemove", onActivate);
 on(document, "touchstart", onActivate);
-export { setDelay };
+//#endregion
+export { setTooltipDelay };