@oscarpalmer/oui 0.24.0 → 0.26.0

package/dist/js/focus-trap/embedded.mjs

@@ -1,67 +1,144 @@
-import { clamp } from "@oscarpalmer/atoms/number";
 import { on } from "@oscarpalmer/toretto/event";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+import { isHTMLOrSVGElement } from "@oscarpalmer/toretto/is";
+import { clamp } from "@oscarpalmer/atoms/number";
 import { findAncestor } from "@oscarpalmer/toretto/find";
 import { getFocusable } from "@oscarpalmer/toretto/focusable";
 //#region src/js/focus-trap/embedded.ts
-var FocusTrap = class {
-	disabled = false;
-	connected = true;
-	element;
-	embedded;
+var OuiFocusTrap = class {
+	#destroyed = false;
+	#tabIndex;
+	#state;
+	/**
+	* Is focused maintained within the _FocusTrap_ when clicking outside of it?
+	*/
 	get contain() {
-		return this.element.hasAttribute(FOCUS_TRAP_CONTAIN);
-	}
+		return this.#state.element.hasAttribute(ATTRIBUTE_FOCUSTRAP_CONTAIN);
+	}
+	/**
+	* Should focus be maintained within the _FocusTrap_ when clicking outside of it?
+	*/
+	set contain(value) {
+		if (value === true) this.#state.element.setAttribute(ATTRIBUTE_FOCUSTRAP_CONTAIN, "");
+		else if (value === false) this.#state.element.removeAttribute(ATTRIBUTE_FOCUSTRAP_CONTAIN);
+	}
+	/**
+	* Is the _FocusTrap_ disabled?
+	*/
+	get disabled() {
+		return this.#state.disabled;
+	}
+	/**
+	* Should the _FocusTrap_ be disabled?
+	*/
+	set disabled(value) {
+		if (value === true) this.disable();
+		else if (value === false) this.enable();
+	}
+	/**
+	* Is focus allowed to escape when pressing _Escape_ within the _FocusTrap_?
+	*/
 	get noescape() {
-		return this.element.hasAttribute(FOCUS_TRAP_NOESCAPE);
-	}
-	constructor(element, options) {
-		this.element = element;
-		this.embedded = options != null;
-		element.setAttribute("tabindex", "-1");
-		if (options != null) element.setAttribute(FOCUS_TRAP_SELECTOR, "");
-		if (options?.noescape) element.setAttribute(FOCUS_TRAP_NOESCAPE, "");
-	}
-	connect() {
-		setConnected(this, true);
-	}
+		return this.#state.element.hasAttribute(ATTRIBUTE_FOCUSTRAP_NOESCAPE);
+	}
+	/**
+	* Should the _FocusTrap_ allow focus to escape when pressing _Escape_?
+	*/
+	set noescape(value) {
+		if (value === true) this.#state.element.setAttribute(ATTRIBUTE_FOCUSTRAP_NOESCAPE, "");
+		else if (value === false) this.#state.element.removeAttribute(ATTRIBUTE_FOCUSTRAP_NOESCAPE);
+	}
+	constructor(state) {
+		this.#state = state;
+		this.#tabIndex = state.element.tabIndex;
+		state.element.tabIndex = -1;
+		state.element.setAttribute(ATTRIBUTE_FOCUSTRAP, "");
+		this.contain = state.options.contain;
+		this.noescape = state.options.noescape;
+		states.set(this, state);
+	}
+	/**
+	* Destroys the _FocusTrap_
+	*/
 	destroy() {
-		this.element = void 0;
-	}
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		disabled.delete(this);
+		instances.delete(this.#state.element);
+		states.delete(this);
+		this.#state.element.tabIndex = this.#tabIndex;
+		this.#state.element.removeAttribute(ATTRIBUTE_FOCUSTRAP);
+		this.#state.element.removeAttribute(ATTRIBUTE_FOCUSTRAP_CONTAIN);
+		this.#state.element.removeAttribute(ATTRIBUTE_FOCUSTRAP_NOESCAPE);
+		this.#state.element = void 0;
+	}
+	/**
+	* Disables the _FocusTrap_
+	*/
 	disable() {
-		if (!(this.disabled || this.noescape)) setDisabled(this, true);
-	}
-	disconnect() {
-		setConnected(this, false);
+		if (!this.#destroyed && !(this.disabled || this.#state.options.noescape)) setDisabled(this, this.#state, true);
 	}
+	/**
+	* Enables the _FocusTrap_
+	*/
 	enable() {
-		if (this.disabled) setDisabled(this, false);
+		if (!this.#destroyed && this.disabled) setDisabled(this, this.#state, false);
 	}
+	/**
+	* Focuses the _FocusTrap_
+	*
+	* @param last When `true`, focuses the last focusable element within the _FocusTrap_ instead of the first
+	*/
 	focus(last) {
-		tabToTrap(this, getFocusable(this.element), this.element, last ? -1 : 0);
+		if (!this.#destroyed && !this.disabled) tabToTrap(this, getFocusable(this.#state.element), this.#state.element, last ? -1 : 0);
 	}
 };
+/**
+* Creates _(or retrieves)_ a _FocusTrap_ for an element
+*
+* @param element Element to trap focus within
+* @param options _FocusTrap_ options
+* @returns _FocusTrap_ instance
+*/
 function createFocusTrap(element, options) {
-	let focusTrap = FOCUSTRAPS_ALL.get(element);
-	if (focusTrap == null) {
-		focusTrap = new FocusTrap(element, options);
-		FOCUSTRAPS_ALL.set(element, focusTrap);
+	if (!isHTMLOrSVGElement(element)) throw new TypeError(MESSAGE);
+	let instance = instances.get(element);
+	if (instance == null) {
+		instance = new OuiFocusTrap(getState(element, options));
+		instances.set(element, instance);
 	}
-	return focusTrap;
+	return instance;
+}
+function getOptions(element, input) {
+	const options = isPlainObject(input) ? input : {};
+	return {
+		contain: typeof options.contain === "boolean" ? options.contain : element.hasAttribute(ATTRIBUTE_FOCUSTRAP_CONTAIN),
+		noescape: typeof options.noescape === "boolean" ? options.noescape : element.hasAttribute(ATTRIBUTE_FOCUSTRAP_NOESCAPE)
+	};
+}
+function getState(element, options) {
+	return {
+		element,
+		disabled: false,
+		options: getOptions(element, options)
+	};
 }
 function onEscape(event) {
-	let element = findAncestor(event, ATTRIBUTE_SELECTOR);
-	let focusTrap = FOCUSTRAPS_ALL.get(element);
-	if (element == null || focusTrap == null) return;
-	while (focusTrap.disabled) {
-		element = findAncestor(focusTrap.element.parentElement, ATTRIBUTE_SELECTOR);
-		focusTrap = FOCUSTRAPS_ALL.get(element);
-		if (element == null || focusTrap == null) return;
-		if (!focusTrap.disabled) break;
-	}
-	focusTrap?.disable();
+	let element = findAncestor(event, SELECTOR);
+	let instance = instances.get(element);
+	let state = states.get(instance);
+	if (element == null || instance == null || state == null) return;
+	while (state.disabled) {
+		element = findAncestor(state.element.parentElement, SELECTOR);
+		instance = instances.get(element);
+		state = states.get(instance);
+		if (element == null || instance == null || state == null) return;
+		if (!state.disabled) break;
+	}
+	instance?.disable();
 }
 function onFocusIn(event) {
-	lastTarget = FOCUSTRAPS_ALL.get(findAncestor(event, ATTRIBUTE_SELECTOR)) == null ? void 0 : event.target;
+	lastTarget = instances.get(findAncestor(event, SELECTOR)) == null ? void 0 : event.target;
 }
 function onKeydown(event) {
 	switch (event.key) {
@@ -75,82 +152,83 @@ function onKeydown(event) {
 	}
 }
 function onPointerdown(event) {
-	const lastFocusTrap = findAncestor(lastTarget, ATTRIBUTE_SELECTOR);
-	const nextFocusTrap = findAncestor(event, ATTRIBUTE_SELECTOR);
-	if (lastFocusTrap != null && nextFocusTrap !== lastFocusTrap) {
-		if (FOCUSTRAPS_ALL.get(lastFocusTrap)?.contain ?? false) {
+	const last = findAncestor(lastTarget, SELECTOR);
+	const next = findAncestor(event, SELECTOR);
+	if (last != null && next !== last) {
+		if (states.get(instances.get(last))?.options.contain ?? false) {
 			event.preventDefault();
 			lastTarget?.focus();
 		}
 	}
-	if (FOCUSTRAPS_DISABLED.size === 0) return;
-	for (const focusTrap of FOCUSTRAPS_DISABLED) if (focusTrap.element !== nextFocusTrap) focusTrap.enable();
+	if (disabled.size === 0) return;
+	for (const focusTrap of disabled) {
+		const state = states.get(focusTrap);
+		if (state != null && state.element !== next) focusTrap.enable();
+	}
 }
 function onTab(event) {
-	const element = findAncestor(event, ATTRIBUTE_SELECTOR);
-	const focusTrap = FOCUSTRAPS_ALL.get(element);
-	if (focusTrap == null) return;
-	if (!focusTrap.disabled) event.preventDefault();
+	const element = findAncestor(event, SELECTOR);
+	const instance = instances.get(element);
+	if (instance == null) return;
+	if (!instance.disabled) event.preventDefault();
 	const elements = getFocusable(element);
 	const index = elements.indexOf(event.target);
-	if (index === -1 || elements.length === 0) tabToTrap(focusTrap, elements, element);
-	else tabToElement(focusTrap, elements, index, event.shiftKey ? -1 : 1);
+	if (index === -1 || elements.length === 0) tabToTrap(instance, elements, element);
+	else tabToElement(instance, elements, index, event.shiftKey ? -1 : 1);
 }
 function removeFocusTrap(element) {
-	FOCUSTRAPS_ALL.get(element)?.destroy();
-	FOCUSTRAPS_ALL.delete(element);
-}
-function setConnected(focusTrap, value) {
-	if (!focusTrap.embedded || focusTrap.connected === value) return;
-	focusTrap.connected = value;
+	instances.get(element)?.destroy();
+	instances.delete(element);
 }
-function setDisabled(focusTrap, value) {
-	focusTrap.disabled = value;
-	if (value) FOCUSTRAPS_DISABLED.add(focusTrap);
-	else FOCUSTRAPS_DISABLED.delete(focusTrap);
+function setDisabled(focusTrap, state, value) {
+	state.disabled = value;
+	if (value) disabled.add(focusTrap);
+	else disabled.delete(focusTrap);
 }
-function tabToElement(focusTrap, elements, index, modifier) {
+function tabToElement(instance, elements, index, modifier) {
 	const { length } = elements;
 	const next = clamp(index + modifier, 0, length - 1, true);
-	if (focusTrap.disabled) {
+	if (instance.disabled) {
 		if (index === length - 1 && next === 0 || index === 0 && next === length - 1) {
 			lastTarget = void 0;
-			focusTrap.enable();
+			instance.enable();
 		}
 		return;
 	}
 	const element = elements[next];
-	const elementFocusTrap = FOCUSTRAPS_ALL.get(element);
+	const elementFocusTrap = instances.get(element);
 	if (elementFocusTrap != null) elementFocusTrap.focus(modifier === -1);
 	else {
 		elements[next].focus();
 		lastTarget = elements[next];
 	}
 }
-function tabToTrap(focusTrap, elements, element, index) {
-	if (focusTrap.disabled) {
+function tabToTrap(instance, elements, element, index) {
+	if (instance.disabled) {
 		lastTarget = void 0;
-		focusTrap.enable();
+		instance.enable();
 	} else {
 		const next = elements.length === 0 ? element : elements.at(index ?? 0);
 		next.focus();
 		lastTarget = next;
 	}
 }
-const FOCUS_TRAP_SELECTOR = "oui-focus-trap";
-const ATTRIBUTE_SELECTOR = `[${FOCUS_TRAP_SELECTOR}]`;
+const ATTRIBUTE_FOCUSTRAP = "oui-focus-trap";
+const ATTRIBUTE_FOCUSTRAP_CONTAIN = `${ATTRIBUTE_FOCUSTRAP}-contain`;
+const ATTRIBUTE_FOCUSTRAP_NOESCAPE = `${ATTRIBUTE_FOCUSTRAP}-noescape`;
 const EVENT_OPTIONS = {
 	capture: true,
 	passive: false
 };
-const FOCUS_TRAP_CONTAIN = `${FOCUS_TRAP_SELECTOR}-contain`;
-const FOCUS_TRAP_NOESCAPE = `${FOCUS_TRAP_SELECTOR}-noescape`;
-const FOCUSTRAPS_ALL = /* @__PURE__ */ new WeakMap();
-const FOCUSTRAPS_DISABLED = /* @__PURE__ */ new Set();
+const MESSAGE = "Element must be an HTMLElement or SVGElement";
+const SELECTOR = `[${ATTRIBUTE_FOCUSTRAP}]`;
+const disabled = /* @__PURE__ */ new Set();
+const instances = /* @__PURE__ */ new WeakMap();
+const states = /* @__PURE__ */ new WeakMap();
 let lastTarget;
 on(document, "focusin", onFocusIn, EVENT_OPTIONS);
 on(document, "keydown", onKeydown, EVENT_OPTIONS);
 on(document, "mousedown", onPointerdown, EVENT_OPTIONS);
 on(document, "touchstart", onPointerdown, EVENT_OPTIONS);
 //#endregion
-export { FOCUS_TRAP_CONTAIN, FOCUS_TRAP_NOESCAPE, FOCUS_TRAP_SELECTOR, FocusTrap, createFocusTrap, removeFocusTrap };
+export { ATTRIBUTE_FOCUSTRAP, ATTRIBUTE_FOCUSTRAP_CONTAIN, ATTRIBUTE_FOCUSTRAP_NOESCAPE, OuiFocusTrap, createFocusTrap, removeFocusTrap };

package/dist/js/focus-trap/standalone.d.mts

@@ -1 +1,2 @@
-export { };
+import { a as createFocusTrap, i as OuiFocusTrap } from "../embedded-CHK82Uh5.mjs";
+export { type OuiFocusTrap, createFocusTrap };

package/dist/js/focus-trap/standalone.mjs

@@ -1,6 +1,6 @@
 import { attributable } from "../internal/attributable.mjs";
-import { FOCUS_TRAP_SELECTOR, createFocusTrap, removeFocusTrap } from "./embedded.mjs";
+import { ATTRIBUTE_FOCUSTRAP, createFocusTrap, removeFocusTrap } from "./embedded.mjs";
 //#region src/js/focus-trap/standalone.ts
-attributable(FOCUS_TRAP_SELECTOR, createFocusTrap, removeFocusTrap);
+attributable(ATTRIBUTE_FOCUSTRAP, createFocusTrap, removeFocusTrap);
 //#endregion
-export {};
+export { createFocusTrap };

package/dist/js/index.d.mts

@@ -1,4 +1,7 @@
-import { getFloatable } from "./floatable.mjs";
+import { OuiDialog, getDialog } from "./dialog.mjs";
+import { i as OuiFloatablePosition, n as OuiFloatable, o as createFloatable } from "./embedded-ai6cqURc.mjs";
+import { a as createFocusTrap, i as OuiFocusTrap } from "./embedded-CHK82Uh5.mjs";
+import { OuiPopover, getPopover } from "./popover.mjs";
 import { OuiSplitterElement } from "./splitter.mjs";
-import { setTooltipDelay } from "./tooltip.mjs";
-export { OuiSplitterElement, getFloatable, setTooltipDelay };
+import { OuiTooltip, getTooltip, setTooltipDelay } from "./tooltip.mjs";
+export { type OuiDialog, type OuiFloatable, type OuiFloatablePosition, type OuiFocusTrap, type OuiPopover, OuiSplitterElement, type OuiTooltip, createFloatable, createFocusTrap, getDialog, getPopover, getTooltip, setTooltipDelay };

package/dist/js/index.mjs

@@ -1,8 +1,12 @@
-import { getFloatable } from "./floatable.mjs";
-import "./focus-trap/standalone.mjs";
+import { createFloatable } from "./floatable/embedded.mjs";
+import { getDialog } from "./dialog.mjs";
 import "./movable.mjs";
-import "./popover.mjs";
 import "./sortable.mjs";
+import "./toolbar.mjs";
+import "./floatable/standalone.mjs";
+import { createFocusTrap } from "./focus-trap/embedded.mjs";
+import "./focus-trap/standalone.mjs";
+import { getPopover } from "./popover.mjs";
 import { OuiSplitterElement } from "./splitter.mjs";
-import { setTooltipDelay } from "./tooltip.mjs";
-export { OuiSplitterElement, getFloatable, setTooltipDelay };
+import { getTooltip, setTooltipDelay } from "./tooltip.mjs";
+export { OuiSplitterElement, createFloatable, createFocusTrap, getDialog, getPopover, getTooltip, setTooltipDelay };

package/dist/js/internal/draggable.d.mts

@@ -1,2 +1,2 @@
-import { a as DraggableState, i as DraggableBound, n as DragMovePosition, o as addDraggable, r as Draggable, s as removeDraggable } from "../movable-BKFgoaOl.mjs";
-export { DragMovePosition, Draggable, DraggableBound, DraggableState, addDraggable, removeDraggable };
+import { a as OuiDraggable, i as DraggableState, n as DragMovePosition, o as addDraggable, r as DraggableBound, s as removeDraggable } from "../movable-dNqBctx3.mjs";
+export { DragMovePosition, DraggableBound, DraggableState, OuiDraggable, addDraggable, removeDraggable };

package/dist/js/internal/draggable.mjs

@@ -1,10 +1,10 @@
-import { clamp } from "@oscarpalmer/atoms/number";
 import { getPosition, on } from "@oscarpalmer/toretto/event";
+import { clamp } from "@oscarpalmer/atoms/number";
 import { findAncestor } from "@oscarpalmer/toretto/find";
 import { toggleStyles } from "@oscarpalmer/toretto/style";
 import supportsTouch from "@oscarpalmer/toretto/touch";
 //#region src/js/internal/draggable.ts
-var Draggable = class {
+var OuiDraggable = class {
 	prefix;
 	element;
 	options;
@@ -212,4 +212,4 @@ on(document, "pointerup", onPointerup);
 on(document, "touchcancel", onPointerup, { passive: false });
 on(document, "touchstart", onPointerdown, { passive: false });
 //#endregion
-export { Draggable, addDraggable, removeDraggable };
+export { OuiDraggable, addDraggable, removeDraggable };

package/dist/js/{movable-BKFgoaOl.d.mts → movable-dNqBctx3.d.mts}

@@ -1,7 +1,7 @@
 import { EventPosition, PlainObject } from "@oscarpalmer/atoms/models";
 
 //#region src/js/sortable.d.ts
-declare class Sortable extends Draggable {
+declare class OuiSortable extends OuiDraggable {
   connections: string | null;
   origin: HTMLElement | undefined;
   get dragged(): HTMLElement;
@@ -9,7 +9,7 @@ declare class Sortable extends Draggable {
 }
 //#endregion
 //#region src/js/internal/draggable.d.ts
-declare abstract class Draggable {
+declare abstract class OuiDraggable {
   prefix: string;
   element: HTMLElement;
   options: DraggableOptions;
@@ -22,10 +22,10 @@ declare abstract class Draggable {
   constructor(prefix: string, element: HTMLElement, options: DraggableOptions);
   destroy(): void;
 }
-type DragBegin = (event: MouseEvent | TouchEvent, state: DraggableState, draggable: Draggable, element: HTMLElement, handle: HTMLElement, position: EventPosition) => void;
-type DragCancel = (state: DraggableState, draggable: Draggable) => void;
-type DragEnd = (event: MouseEvent | TouchEvent, state: DraggableState, draggable: Draggable, reset: () => void) => void;
-type DragMove = (event: MouseEvent | TouchEvent, state: DraggableState, draggable: Draggable, position: DragMovePosition) => PlainObject | undefined;
+type DragBegin = (event: MouseEvent | TouchEvent, state: DraggableState, draggable: OuiDraggable, element: HTMLElement, handle: HTMLElement, position: EventPosition) => void;
+type DragCancel = (state: DraggableState, draggable: OuiDraggable) => void;
+type DragEnd = (event: MouseEvent | TouchEvent, state: DraggableState, draggable: OuiDraggable, reset: () => void) => void;
+type DragMove = (event: MouseEvent | TouchEvent, state: DraggableState, draggable: OuiDraggable, position: DragMovePosition) => PlainObject | undefined;
 type DragMovePosition = {
   calculated: EventPosition;
   original: EventPosition;
@@ -35,8 +35,8 @@ type DraggableBound<Property extends keyof DraggableInstances = keyof DraggableI
   property: Property;
 };
 type DraggableInstances = {
-  movable?: Movable;
-  sortable?: Sortable;
+  movable?: OuiMovable;
+  sortable?: OuiSortable;
 };
 type DraggableOptions = {
   container: DraggableOptionsContainer;
@@ -46,17 +46,17 @@ type DraggableOptions = {
 };
 type DraggableOptionsContainer = {
   attribute: string;
-  map: Map<HTMLElement, Set<Draggable>>;
+  map: Map<HTMLElement, Set<OuiDraggable>>;
   onDestroy?: DraggableOptionsContainerOnDestroy;
   onInitialize?: DraggableOptionsContainerOnInitialize;
 };
-type DraggableOptionsContainerOnDestroy = (draggable: Draggable, container: HTMLElement, empty: boolean) => void;
-type DraggableOptionsContainerOnInitialize = (draggable: Draggable) => void;
+type DraggableOptionsContainerOnDestroy = (draggable: OuiDraggable, container: HTMLElement, empty: boolean) => void;
+type DraggableOptionsContainerOnInitialize = (draggable: OuiDraggable) => void;
 type DraggableOptionsDirection = {
   attribute: string;
   onAfter?: DraggableOptionsDirectionOnAfter;
 };
-type DraggableOptionsDirectionOnAfter = (draggable: Draggable) => void;
+type DraggableOptionsDirectionOnAfter = (draggable: OuiDraggable) => void;
 type DraggableOptionsDrag = {
   onBegin: DragBegin;
   onCancel: DragCancel;
@@ -67,8 +67,8 @@ type DraggableOptionsPosition = {
   getOffset: DraggableOptionsPositionGetOffset;
   getOriginal: DraggableOptionsPositionGetOriginal;
 };
-type DraggableOptionsPositionGetOffset = (state: DraggableState, draggable: Draggable, element: HTMLElement, position: EventPosition) => EventPosition;
-type DraggableOptionsPositionGetOriginal = (state: DraggableState, draggable: Draggable, position: EventPosition) => EventPosition;
+type DraggableOptionsPositionGetOffset = (state: DraggableState, draggable: OuiDraggable, element: HTMLElement, position: EventPosition) => EventPosition;
+type DraggableOptionsPositionGetOriginal = (state: DraggableState, draggable: OuiDraggable, position: EventPosition) => EventPosition;
 type DraggableState = {
   container: DOMRect | undefined;
   element: DraggableStateElement | undefined;
@@ -87,7 +87,7 @@ declare function removeDraggable<Property extends keyof DraggableInstances, Inst
 }, element: HTMLElement): void;
 //#endregion
 //#region src/js/movable.d.ts
-declare class Movable extends Draggable {
+declare class OuiMovable extends OuiDraggable {
   inset: string;
   moved: boolean;
   offset: Partial<EventPosition> | undefined;
@@ -98,4 +98,4 @@ declare class Movable extends Draggable {
   destroy(): void;
 }
 //#endregion
-export { DraggableState as a, Sortable as c, DraggableBound as i, DragMovePosition as n, addDraggable as o, Draggable as r, removeDraggable as s, Movable as t };
+export { OuiDraggable as a, OuiSortable as c, DraggableState as i, DragMovePosition as n, addDraggable as o, DraggableBound as r, removeDraggable as s, OuiMovable as t };

package/dist/js/movable.d.mts

@@ -1,2 +1,2 @@
-import { t as Movable } from "./movable-BKFgoaOl.mjs";
-export { Movable };
+import { t as OuiMovable } from "./movable-dNqBctx3.mjs";
+export { OuiMovable };

package/dist/js/movable.mjs

@@ -1,8 +1,8 @@
 import { attributable } from "./internal/attributable.mjs";
-import { Draggable, addDraggable, removeDraggable } from "./internal/draggable.mjs";
+import { OuiDraggable, addDraggable, removeDraggable } from "./internal/draggable.mjs";
 import { getPosition, on } from "@oscarpalmer/toretto/event";
 //#region src/js/movable.ts
-var Movable = class extends Draggable {
+var OuiMovable = class extends OuiDraggable {
 	inset;
 	moved = false;
 	offset;
@@ -142,11 +142,11 @@ const EVENT_END = "move:end";
 const MOVED = /* @__PURE__ */ new Set();
 const SELECTOR_HANDLE = `[${ATTRIBUTE}-handle]`;
 const bound = {
-	constructor: Movable,
+	constructor: OuiMovable,
 	property: "movable"
 };
 const resizer = new ResizeObserver(onResize);
 attributable(ATTRIBUTE, addDraggable.bind(bound), removeDraggable.bind(bound));
 on(document, "scroll", onScroll);
 //#endregion
-export { Movable };
+export { OuiMovable };

package/dist/js/popover.d.mts

@@ -1 +1,38 @@
-export { };
+import { n as OuiFloatable } from "./embedded-ai6cqURc.mjs";
+import { i as OuiFocusTrap } from "./embedded-CHK82Uh5.mjs";
+import { RemovableEventListener } from "@oscarpalmer/toretto/models";
+
+//#region src/js/popover.d.ts
+declare class OuiPopover {
+  #private;
+  /**
+   * Is the popover open?
+   */
+  get open(): boolean;
+  constructor(state: OuiPopoverState);
+  /**
+   * Closes the popover
+   */
+  hide(): void;
+  /**
+   * Opens the popover
+   */
+  show(): void;
+}
+type OuiPopoverState = {
+  anchor: HTMLElement;
+  content: HTMLElement;
+  floatable: OuiFloatable;
+  focusTrap?: OuiFocusTrap;
+  listeners: RemovableEventListener[];
+  popover: OuiPopover;
+};
+/**
+ * Get the _OuiPopover_ for an element
+ *
+ * @param element Element to get _OuiPopover_ for
+ * @returns _OuiPopover_ instance
+ */
+declare function getPopover(element: HTMLElement): OuiPopover | undefined;
+//#endregion
+export { type OuiPopover, getPopover };