@oscarpalmer/oui 0.25.0 → 0.26.1

package/src/js/splitter.ts

@@ -20,6 +20,83 @@ const ATTRIBUTE_SIZE = 'size';
 
 const ATTRIBUTE_TYPE = 'type';
 
+class OuiSplitter {
+	element: OuiSplitterElement;
+
+	handle: HTMLSpanElement;
+
+	panels: HTMLElement[];
+
+	rectangle: DOMRect;
+
+	separator: HTMLDivElement;
+
+	types!: OuiSplitterTypes;
+
+	values: OuiSplitterValues;
+
+	constructor(element: OuiSplitterElement, panels: HTMLElement[]) {
+		this.element = element;
+		this.panels = panels;
+
+		if (isNullableOrWhitespace(element.id)) {
+			element.id = `oui_splitter_${++index}`;
+		}
+
+		this.values = getValues(element);
+
+		this.handle = createHandle();
+		this.rectangle = element.getBoundingClientRect();
+		this.separator = createSeparator(this);
+
+		this.separator.append(this.handle);
+
+		panels[0].insertAdjacentElement('afterend', this.separator);
+
+		this.updateOrientation();
+		this.updateValues();
+	}
+
+	updateConnections(add: 0 | 1): void {
+		const method = METHODS_CONNECT[add];
+
+		MAPPED_ELEMENTS[method](this.element, this);
+		MAPPED_ELEMENTS[method](this.handle, this);
+		MAPPED_ELEMENTS[method](this.separator, this);
+
+		if (this.types.auto) {
+			RESIZE_OBSERVER[METHODS_OBSERVE[add]](this.element);
+		}
+	}
+
+	updateOrientation(): void {
+		this.types = getTypes(this);
+
+		if (this.types.auto) {
+			RESIZE_OBSERVER.observe(this.element);
+		} else {
+			RESIZE_OBSERVER.unobserve(this.element);
+		}
+
+		if (this.types.horizontal) {
+			this.element.setAttribute(ATTRIBUTE_HORIZONTAL, '');
+		} else {
+			this.element.removeAttribute(ATTRIBUTE_HORIZONTAL);
+		}
+
+		setAriaOrientation(this);
+	}
+
+	updateValues(): void {
+		this.values = getValues(this.element);
+
+		requestAnimationFrame(() => {
+			setSize(this, this.values.now.current);
+			setAriaValue(this);
+		});
+	}
+}
+
 export class OuiSplitterElement extends HTMLElement {
 	static readonly observedAttributes = [
 		ATTRIBUTE_MAX,
@@ -28,40 +105,64 @@ export class OuiSplitterElement extends HTMLElement {
 		ATTRIBUTE_TYPE,
 	];
 
-	readonly #splitter: Splitter;
+	readonly #splitter: OuiSplitter;
 
 	// Getters and setters
 
+	/**
+	 * Maximum size for the first panel
+	 */
 	get max(): number {
 		return this.#splitter.values.max;
 	}
 
+	/**
+	 * Maximum size for the first panel
+	 */
 	set max(value: number) {
 		this.setAttribute(ATTRIBUTE_MAX, String(value));
 	}
 
+	/**
+	 * Minimum size for the first panel
+	 */
 	get min(): number {
 		return this.#splitter.values.min;
 	}
 
+	/**
+	 * Minimum size for the first panel
+	 */
 	set min(value: number) {
-		this.setAttribute('min', String(value));
+		this.setAttribute(ATTRIBUTE_MIN, String(value));
 	}
 
+	/**
+	 * Current size for the first panel
+	 */
 	get size(): number {
 		return this.#splitter.values.now.current;
 	}
 
+	/**
+	 * Current size for the first panel
+	 */
 	set size(value: number) {
-		this.setAttribute('size', String(value));
+		this.setAttribute(ATTRIBUTE_SIZE, String(value));
 	}
 
+	/**
+	 * Orientation of the splitter
+	 */
 	get type(): string {
-		return this.getAttribute('type') ?? 'vertical';
+		return this.getAttribute(ATTRIBUTE_TYPE) ?? 'vertical';
 	}
 
+	/**
+	 * Orientation of the splitter
+	 */
 	set type(value: string) {
-		this.setAttribute('type', value);
+		this.setAttribute(ATTRIBUTE_TYPE, value);
 	}
 
 	// Constructor
@@ -72,10 +173,10 @@ export class OuiSplitterElement extends HTMLElement {
 		const panels = [...this.children].filter(child => child instanceof HTMLElement);
 
 		if (panels.length !== 2) {
-			throw new Error(`${SELECTOR} must have exactly two panels.`);
+			throw new Error(MESSAGE);
 		}
 
-		this.#splitter = new Splitter(this, panels);
+		this.#splitter = new OuiSplitter(this, panels);
 	}
 
 	// Methods
@@ -106,97 +207,18 @@ export class OuiSplitterElement extends HTMLElement {
 	}
 }
 
-let index = 0;
-
-class Splitter {
-	element: OuiSplitterElement;
-
-	handle: HTMLSpanElement;
-
-	panels: HTMLElement[];
-
-	rectangle: DOMRect;
-
-	separator: HTMLDivElement;
-
-	types!: Types;
-
-	values: Values;
-
-	constructor(element: OuiSplitterElement, panels: HTMLElement[]) {
-		this.element = element;
-		this.panels = panels;
-
-		if (isNullableOrWhitespace(element.id)) {
-			element.id = `oui_splitter_${++index}`;
-		}
-
-		this.values = getValues(element);
-
-		this.handle = createHandle();
-		this.rectangle = element.getBoundingClientRect();
-		this.separator = createSeparator(this);
-
-		this.separator.append(this.handle);
-
-		panels[0].insertAdjacentElement('afterend', this.separator);
-
-		this.updateOrientation();
-		this.updateValues();
-	}
-
-	updateConnections(add: 0 | 1): void {
-		const method = METHODS_CONNECT[add];
-
-		MAPPED_ELEMENTS[method](this.element, this);
-		MAPPED_ELEMENTS[method](this.handle, this);
-		MAPPED_ELEMENTS[method](this.separator, this);
-
-		if (this.types.auto) {
-			RESIZE_OBSERVER[METHODS_OBSERVE[add]](this.element);
-		}
-	}
-
-	updateOrientation(): void {
-		this.types = getTypes(this);
-
-		if (this.types.auto) {
-			RESIZE_OBSERVER.observe(this.element);
-		} else {
-			RESIZE_OBSERVER.unobserve(this.element);
-		}
-
-		if (this.types.horizontal) {
-			this.element.setAttribute(ATTRIBUTE_HORIZONTAL, '');
-		} else {
-			this.element.removeAttribute(ATTRIBUTE_HORIZONTAL);
-		}
-
-		setAriaOrientation(this);
-	}
-
-	updateValues(): void {
-		this.values = getValues(this.element);
-
-		requestAnimationFrame(() => {
-			setSize(this, this.values.now.current);
-			setAriaValue(this);
-		});
-	}
-}
-
-type Types = {
+type OuiSplitterTypes = {
 	auto: boolean;
 	horizontal: boolean;
 };
 
-type Values = {
+type OuiSplitterValues = {
 	max: number;
 	min: number;
-	now: ValuesNow;
+	now: OuiSplitterValuesNow;
 };
 
-type ValuesNow = {
+type OuiSplitterValuesNow = {
 	current: number;
 	previous: number;
 };
@@ -212,7 +234,7 @@ function createHandle(): HTMLSpanElement {
 	return handle;
 }
 
-function createSeparator(splitter: Splitter): HTMLDivElement {
+function createSeparator(splitter: OuiSplitter): HTMLDivElement {
 	const separator = document.createElement('div');
 
 	separator.role = 'separator';
@@ -229,7 +251,7 @@ function getContained(min: number, value: number, max: number): number {
 	return round(clamp(value, min, max), VALUE_DECIMALS);
 }
 
-function getSize(splitter: Splitter, value: number): number {
+function getSize(splitter: OuiSplitter, value: number): number {
 	const {height, left, top, width} = splitter.rectangle;
 
 	const offset = value - (splitter.types.horizontal ? top : left);
@@ -239,7 +261,7 @@ function getSize(splitter: Splitter, value: number): number {
 	return getContained(splitter.values.min, fraction, splitter.values.max);
 }
 
-function getTypes(splitter: Splitter, width?: number, height?: number): Types {
+function getTypes(splitter: OuiSplitter, width?: number, height?: number): OuiSplitterTypes {
 	const type = splitter.element.getAttribute('type')?.trim() ?? '';
 
 	if (type === 'horizontal') {
@@ -282,8 +304,8 @@ function getValue(element: HTMLElement, name: string, defaultValue: number): num
 	return parsed > 1 ? parsed / NAVIGATION_MAXIMUM_TOTAL : parsed;
 }
 
-function getValues(element: OuiSplitterElement): Values {
-	const values: Values = {
+function getValues(element: OuiSplitterElement): OuiSplitterValues {
+	const values: OuiSplitterValues = {
 		max: getValue(element, ATTRIBUTE_MAX, NAVIGATION_MAXIMUM_PERCENTAGE),
 		min: getValue(element, ATTRIBUTE_MIN, NAVIGATION_MINIMUM_PERCENTAGE),
 		now: {
@@ -445,21 +467,21 @@ function onPointerup(): void {
 	}
 }
 
-function setAriaOrientation(splitter: Splitter): void {
+function setAriaOrientation(splitter: OuiSplitter): void {
 	splitter.separator.setAttribute(
 		'aria-orientation',
 		splitter.types.horizontal ? 'horizontal' : 'vertical',
 	);
 }
 
-function setAriaValue(splitter: Splitter): void {
+function setAriaValue(splitter: OuiSplitter): void {
 	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: Splitter, size: number, previous?: boolean): void {
+function setSize(splitter: OuiSplitter, size: number, previous?: boolean): void {
 	splitter.values.now.current = size;
 
 	if (previous) {
@@ -493,7 +515,9 @@ const KEYS_VERTICAL: Set<string> = new Set(['ArrowLeft', 'ArrowRight']);
 
 const KEYS_ALL: Set<string> = new Set([...KEYS_ABSOLUTE, ...KEYS_HORIZONTAL, ...KEYS_VERTICAL]);
 
-const MAPPED_ELEMENTS: WeakMap<HTMLElement, Splitter> = new WeakMap();
+const MAPPED_ELEMENTS: WeakMap<HTMLElement, OuiSplitter> = new WeakMap();
+
+const MESSAGE = `<${SELECTOR}> must have exactly two panels.`;
 
 const METHODS_CONNECT = ['delete', 'set'] as const;
 
@@ -519,9 +543,11 @@ const STYLING_TOGGLER: StyleToggler = toggleStyles(document.body, {
 
 const VALUE_DECIMALS = 6;
 
+let index = 0;
+
 let frame: DOMHighResTimeStamp | undefined;
 
-let splitter: Splitter | undefined;
+let splitter: OuiSplitter | undefined;
 
 //
 

package/src/js/toolbar.ts

@@ -0,0 +1,214 @@
+import {clamp} from '@oscarpalmer/atoms/number';
+import {on} from '@oscarpalmer/toretto/event';
+import {findAncestor} from '@oscarpalmer/toretto/find';
+import {isHTMLOrSVGElement} from '@oscarpalmer/toretto/is';
+import type {RemovableEventListener} from '@oscarpalmer/toretto/models';
+import {attributable} from './internal/attributable';
+
+class OuiToolbar {
+	readonly #state: OuiToolbarState;
+
+	constructor(state: OuiToolbarState) {
+		this.#state = state;
+
+		updateFocus(this.#state, false);
+	}
+
+	destroy(): void {
+		for (const listener of this.#state.listeners) {
+			listener();
+		}
+
+		this.#state.active = undefined as never;
+		this.#state.element = undefined as never;
+		this.#state.listeners = undefined as never;
+	}
+}
+
+type OuiToolbarOrientation = 'horizontal' | 'vertical';
+
+type OuiToolbarState = {
+	active: OuiToolbarStateActive;
+	element: HTMLElement;
+	listeners: RemovableEventListener[];
+	orientation: OuiToolbarOrientation;
+};
+
+type OuiToolbarStateActive = {
+	element?: HTMLElement;
+	index: number;
+};
+
+function addToolbar(element: HTMLElement): void {
+	if (!instances.has(element)) {
+		instances.set(element, new OuiToolbar(getState(element)));
+	}
+}
+
+function getItems(element: HTMLElement): HTMLElement[] {
+	return [...element.querySelectorAll<HTMLElement>(SELECTOR)].filter(isValidItem);
+}
+
+function getOrientation(element: HTMLElement): OuiToolbarOrientation {
+	const attribute = element.getAttribute(ARIA_ORIENTATION);
+
+	return ORIENTATIONS.has(attribute as OuiToolbarOrientation)
+		? (attribute as OuiToolbarOrientation)
+		: ORIENTATION_HORIZONTAL;
+}
+
+function getState(element: HTMLElement): OuiToolbarState {
+	const state: OuiToolbarState = {
+		element,
+		active: {
+			index: 0,
+		},
+		listeners: [
+			on(element, EVENT_FOCUSIN, event => {
+				onFocusin(state, event);
+			}),
+			on(
+				element,
+				EVENT_KEYDOWN,
+				event => {
+					onKeydown(state, event);
+				},
+				{
+					passive: false,
+				},
+			),
+		],
+		orientation: getOrientation(element),
+	};
+
+	return state;
+}
+
+function isValidItem(element: HTMLElement): boolean {
+	return PROPERTY_DISABLED in element ? element.disabled !== true : true;
+}
+
+function onKeydown(state: OuiToolbarState, event: KeyboardEvent): void {
+	if (!KEYS_ALL.has(event.key)) {
+		return;
+	}
+
+	const items = getItems(state.element);
+
+	if (items.length === 0) {
+		return;
+	}
+
+	let index: number | undefined;
+
+	if (KEYS_ABSOLUTE.has(event.key)) {
+		index = event.key === KEY_HOME ? 0 : items.length - 1;
+	} else if (
+		state.orientation === ORIENTATION_HORIZONTAL
+			? KEYS_HORIZONTAL.has(event.key)
+			: KEYS_VERTICAL.has(event.key)
+	) {
+		if (state.active.element instanceof HTMLSelectElement) {
+			event.preventDefault();
+		}
+
+		index = clamp(
+			state.active.index + (KEYS_NEXT.has(event.key) ? 1 : -1),
+			0,
+			items.length - 1,
+			true,
+		);
+	}
+
+	if (index == null || index === state.active.index) {
+		return;
+	}
+
+	state.active.element = items[index];
+	state.active.index = index;
+
+	updateFocus(state, true, items);
+}
+
+function onFocusin(state: OuiToolbarState, event: FocusEvent): void {
+	const item = findAncestor(event, SELECTOR);
+
+	if (!isHTMLOrSVGElement(item) || !isValidItem(item)) {
+		return;
+	}
+
+	const items = getItems(state.element);
+	const index = items.indexOf(item);
+
+	if (index === -1) {
+		return;
+	}
+
+	state.active.element = item;
+	state.active.index = index;
+
+	updateFocus(state, false, items);
+}
+
+function removeToolbar(element: HTMLElement): void {
+	instances.get(element)?.destroy();
+
+	instances.delete(element);
+}
+
+function updateFocus(state: OuiToolbarState, focus: boolean, items?: HTMLElement[]): void {
+	const updated = items ?? getItems(state.element);
+	const {length} = updated;
+
+	if (length === 0) {
+		return;
+	}
+
+	for (let index = 0; index < length; index += 1) {
+		updated[index].tabIndex = index === state.active.index ? 0 : -1;
+	}
+
+	state.active.element ??= updated[state.active.index];
+
+	if (focus) {
+		state.active.element?.focus();
+	}
+}
+
+const ARIA_ORIENTATION = 'aria-orientation';
+
+const ATTRIBUTE = 'oui-toolbar';
+
+const EVENT_KEYDOWN = 'keydown';
+
+const EVENT_FOCUSIN = 'focusin';
+
+const KEY_ARROW_DOWN = 'ArrowDown';
+
+const KEY_ARROW_RIGHT = 'ArrowRight';
+
+const KEY_END = 'End';
+
+const KEY_HOME = 'Home';
+
+const KEYS_ABSOLUTE = new Set([KEY_END, KEY_HOME]);
+
+const KEYS_HORIZONTAL = new Set([KEY_ARROW_RIGHT, 'ArrowLeft']);
+
+const KEYS_VERTICAL = new Set([KEY_ARROW_DOWN, 'ArrowUp']);
+
+const KEYS_ALL = new Set([...KEYS_ABSOLUTE, ...KEYS_HORIZONTAL, ...KEYS_VERTICAL]);
+
+const KEYS_NEXT = new Set([KEY_ARROW_DOWN, KEY_ARROW_RIGHT]);
+
+const ORIENTATION_HORIZONTAL: OuiToolbarOrientation = 'horizontal';
+
+const ORIENTATIONS = new Set<OuiToolbarOrientation>([ORIENTATION_HORIZONTAL, 'vertical']);
+
+const PROPERTY_DISABLED = 'disabled';
+
+const SELECTOR = `[${ATTRIBUTE}-item]`;
+
+const instances = new WeakMap<HTMLElement, OuiToolbar>();
+
+attributable(ATTRIBUTE, addToolbar, removeToolbar);

package/src/js/tooltip.ts

@@ -3,7 +3,11 @@ import {createElement} from '@oscarpalmer/toretto/create';
 import {on} from '@oscarpalmer/toretto/event';
 import {findAncestor} from '@oscarpalmer/toretto/find';
 import {isHTMLOrSVGElement} from '@oscarpalmer/toretto/is';
-import {createFloatable, type OuiFloatable, type OuiFloatableOptions} from './floatable/embedded';
+import {
+	createEmbeddedFloatable,
+	type OuiFloatable,
+	type OuiFloatableOptions,
+} from './floatable/embedded';
 import {attributable} from './internal/attributable';
 
 // #region Types
@@ -18,6 +22,17 @@ class OuiTooltip {
 		return this.#state.content.checkVisibility();
 	}
 
+	/**
+	 * Open or close the tooltip
+	 */
+	set open(value: boolean) {
+		if (value === true) {
+			this.show();
+		} else if (value === false) {
+			this.hide();
+		}
+	}
+
 	constructor(state: OuiTooltipState) {
 		this.#state = state;
 
@@ -97,6 +112,12 @@ function activate(event: Event, focus: boolean): void {
 	);
 }
 
+function addTooltip(element: HTMLElement): void {
+	if (!states.has(element)) {
+		createTooltip(element);
+	}
+}
+
 function closeTooltip(state?: OuiTooltipState): void {
 	if (state == null) {
 		return;
@@ -211,7 +232,7 @@ function getState(anchor: HTMLElement, content: HTMLElement): OuiTooltipState {
 	const state: OuiTooltipState = {
 		anchor,
 		content,
-		floatable: createFloatable(anchor, content, options, false),
+		floatable: createEmbeddedFloatable(anchor, content, options),
 		tooltip: null as never,
 	};
 
@@ -220,16 +241,16 @@ function getState(anchor: HTMLElement, content: HTMLElement): OuiTooltipState {
 	return state;
 }
 
+/**
+ * Get the _OuiTooltip_ for an element
+ *
+ * @param element Element to get _OuiTooltip_ for
+ * @returns _OuiTooltip_ instance
+ */
 function getTooltip(element: HTMLElement): OuiTooltip | undefined {
 	return states.get(element)?.tooltip;
 }
 
-function onAdd(element: HTMLElement): void {
-	if (!states.has(element)) {
-		createTooltip(element);
-	}
-}
-
 function onFocusin(event: Event): void {
 	activate(event, true);
 }
@@ -263,7 +284,7 @@ function onPointermove(event: Event): void {
 	activate(event, false);
 }
 
-function onRemove(element: HTMLElement): void {
+function removeTooltip(element: HTMLElement): void {
 	const state = states.get(element);
 
 	if (state == null) {
@@ -338,7 +359,7 @@ on(document, 'focusin', onFocusin);
 on(document, 'focusout', onFocusout);
 on(document, 'pointermove', onPointermove);
 
-attributable(ATTRIBUTE, onAdd, onRemove);
+attributable(ATTRIBUTE, addTooltip, removeTooltip);
 
 // #endregion
 

package/dist/js/embedded-BpwzMSEF.d.mts

@@ -1,26 +0,0 @@
-//#region src/js/focus-trap/embedded.d.ts
-declare class FocusTrap {
-  disabled: boolean;
-  connected: boolean;
-  element: HTMLElement;
-  embedded: boolean;
-  get contain(): boolean;
-  get noescape(): boolean;
-  constructor(element: HTMLElement, options?: Options);
-  connect(): void;
-  destroy(): void;
-  disable(): void;
-  disconnect(): void;
-  enable(): void;
-  focus(last: boolean): void;
-}
-type Options = {
-  noescape: boolean;
-};
-declare function createFocusTrap(element: HTMLElement, options?: Options): FocusTrap;
-declare function removeFocusTrap(element: HTMLElement): void;
-declare const FOCUS_TRAP_SELECTOR = "oui-focus-trap";
-declare const FOCUS_TRAP_CONTAIN = "oui-focus-trap-contain";
-declare const FOCUS_TRAP_NOESCAPE = "oui-focus-trap-noescape";
-//#endregion
-export { createFocusTrap as a, FocusTrap as i, FOCUS_TRAP_NOESCAPE as n, removeFocusTrap as o, FOCUS_TRAP_SELECTOR as r, FOCUS_TRAP_CONTAIN as t };