ropav 0.1.6 → 0.1.7

package/dist/useFloatingPosition.js

@@ -1,11 +1,142 @@
+import { i as querySelectorSafe, t as isElement } from "./query.js";
+import { t as createRafScheduler } from "./rafScheduler.js";
 import { computed, isRef, nextTick, onBeforeUnmount, onMounted, readonly, ref, shallowRef, toValue, watch } from "vue";
 import { arrow, autoUpdate, computePosition, flip, offset, shift } from "@floating-ui/dom";
+//#region src/utils/dom/ancestry.ts
+function getFrameElement(documentNode) {
+	try {
+		const frameElement = documentNode.defaultView?.frameElement;
+		return isElement(frameElement) ? frameElement : null;
+	} catch {
+		return null;
+	}
+}
+function getComposedParent(node) {
+	if (isElement(node) && node.assignedSlot) return node.assignedSlot;
+	if (node.parentNode) return node.parentNode;
+	if (node.nodeType === 9) return getFrameElement(node);
+	const host = "host" in node ? node.host : null;
+	return isElement(host) ? host : null;
+}
+function getComposedAncestry(node) {
+	const ancestry = [];
+	let current = node ?? null;
+	while (current) {
+		current = getComposedParent(current);
+		if (current) ancestry.push(current);
+	}
+	return ancestry;
+}
+function areNodeListsIdentical(left, right) {
+	return left.length === right.length && left.every((node, index) => node === right[index]);
+}
+function readComposedAncestryPaths(nodes) {
+	return nodes.map((node) => node ? [node, ...getComposedAncestry(node)] : []);
+}
+function areAncestryPathsIdentical(left, right) {
+	return left.length === right.length && left.every((path, index) => areNodeListsIdentical(path, right[index] ?? []));
+}
+function getNodeDocument(node) {
+	return node.nodeType === 9 ? node : node.ownerDocument;
+}
+function getMutationObserverConstructor(node) {
+	return getNodeDocument(node)?.defaultView?.MutationObserver ?? globalThis.MutationObserver;
+}
+function isShadowRootNode(node) {
+	return node.nodeType === 11 && "host" in node && isElement(node.host);
+}
+function hasDisconnectedAncestry(nodes) {
+	return nodes.some((node) => node != null && [node, ...getComposedAncestry(node)].some((ancestor) => !ancestor.isConnected));
+}
+function observeComposedAncestry(getNodes, onChange, options = {}) {
+	let paths = readComposedAncestryPaths(getNodes());
+	let mutationObservers = [];
+	let slotRoots = [];
+	let disposed = false;
+	const reconnectScheduler = createRafScheduler(check, getView);
+	function getView() {
+		for (const node of getNodes()) {
+			const view = node ? getNodeDocument(node)?.defaultView : null;
+			if (view) return view;
+		}
+		return null;
+	}
+	function scheduleReconnectCheck(nodes) {
+		if (!hasDisconnectedAncestry(nodes)) return;
+		if (!getView()?.requestAnimationFrame) return;
+		reconnectScheduler.schedule();
+	}
+	function disconnectTargets() {
+		for (const observer of mutationObservers) observer.disconnect();
+		mutationObservers = [];
+		for (const root of slotRoots) root.removeEventListener("slotchange", check);
+		slotRoots = [];
+	}
+	function observeTargets(nodes, nextPaths) {
+		const observedNodes = new Set(nextPaths.flat());
+		const nextSlotRoots = /* @__PURE__ */ new Set();
+		const observersByConstructor = /* @__PURE__ */ new Map();
+		for (const node of observedNodes) {
+			if (isElement(node) && node.shadowRoot) nextSlotRoots.add(node.shadowRoot);
+			if (isShadowRootNode(node)) nextSlotRoots.add(node);
+			const MutationObserverConstructor = getMutationObserverConstructor(node);
+			if (!MutationObserverConstructor) continue;
+			let observer = observersByConstructor.get(MutationObserverConstructor);
+			if (!observer) {
+				observer = new MutationObserverConstructor(check);
+				observersByConstructor.set(MutationObserverConstructor, observer);
+			}
+			if (isElement(node)) observer.observe(node, {
+				childList: true,
+				attributes: true,
+				attributeFilter: ["slot", "name"]
+			});
+			else observer.observe(node, { childList: true });
+		}
+		mutationObservers = [...observersByConstructor.values()];
+		slotRoots = [...nextSlotRoots];
+		for (const root of slotRoots) root.addEventListener("slotchange", check);
+		scheduleReconnectCheck(nodes);
+	}
+	function rebind(nodes, nextPaths) {
+		disconnectTargets();
+		paths = nextPaths;
+		observeTargets(nodes, paths);
+	}
+	function check() {
+		if (disposed) return;
+		const nodes = getNodes();
+		if (options.deferWhileDisconnected && hasDisconnectedAncestry(nodes)) {
+			scheduleReconnectCheck(nodes);
+			return;
+		}
+		reconnectScheduler.cancel();
+		const nextPaths = readComposedAncestryPaths(nodes);
+		if (areAncestryPathsIdentical(paths, nextPaths)) return;
+		rebind(nodes, nextPaths);
+		onChange();
+	}
+	const initialNodes = getNodes();
+	paths = readComposedAncestryPaths(initialNodes);
+	observeTargets(initialNodes, paths);
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		reconnectScheduler.cancel();
+		disconnectTargets();
+	};
+}
+//#endregion
 //#region src/components/floating/useFloatingPosition.ts
 var DEFAULT_ARROW_PADDING = 4;
 var DEFAULT_COLLISION_PADDING = 8;
 var DEFAULT_OFFSET = 8;
 var DEFAULT_PLACEMENT = "bottom";
 var DEFAULT_STRATEGY = "absolute";
+function getReferenceElement(reference) {
+	if (isElement(reference)) return reference;
+	return reference && isElement(reference.contextElement) ? reference.contextElement : null;
+}
 function readFloatingTarget(target) {
 	return isRef(target) ? target.value : target;
 }
@@ -13,18 +144,10 @@ function isVirtualReference(value) {
 	if (value == null || typeof value !== "object") return false;
 	return "getBoundingClientRect" in value && typeof value.getBoundingClientRect === "function";
 }
-function isElementReference(value) {
-	return typeof Element !== "undefined" && value instanceof Element;
-}
 function resolveFloatingTarget(target) {
 	if (!target) return null;
 	if (typeof target !== "string") return isVirtualReference(target) ? target : null;
-	if (typeof document === "undefined") return null;
-	try {
-		return document.querySelector(target);
-	} catch {
-		return null;
-	}
+	return querySelectorSafe(target);
 }
 function useFloatingTarget(getTarget, fallback) {
 	const resolvedTarget = shallowRef(null);
@@ -51,6 +174,7 @@ function useFloatingPosition(options) {
 	const floatingStyle = ref(getHiddenStyle());
 	const arrowStyle = ref();
 	let cleanup;
+	let cleanupPositioningAncestry;
 	let generation = 0;
 	let request = 0;
 	function getReference() {
@@ -106,9 +230,14 @@ function useFloatingPosition(options) {
 	function stop() {
 		cleanup?.();
 		cleanup = void 0;
+		cleanupPositioningAncestry?.();
+		cleanupPositioningAncestry = void 0;
 		generation += 1;
 		request += 1;
 	}
+	function observePositioningAncestry() {
+		cleanupPositioningAncestry = observeComposedAncestry(() => [getReferenceElement(getReference()), getFloating()], start, { deferWhileDisconnected: true });
+	}
 	function getMiddleware() {
 		const middleware = [offset(getOffset())];
 		const padding = getCollisionPadding();
@@ -162,6 +291,7 @@ function useFloatingPosition(options) {
 			const updatePosition = () => void update();
 			const animationFrame = getAutoUpdateAnimationFrame();
 			cleanup = animationFrame == null ? autoUpdate(reference, floating, updatePosition) : autoUpdate(reference, floating, updatePosition, { animationFrame });
+			observePositioningAncestry();
 		});
 	}
 	watch([
@@ -192,4 +322,4 @@ function useFloatingPosition(options) {
 	};
 }
 //#endregion
-export { useFloatingPosition as n, useFloatingTarget as r, isElementReference as t };
+export { useFloatingTarget as n, useFloatingPosition as t };

package/dist/useOverlayZIndex.js

@@ -1,3 +1,4 @@
+import { n as isEventWithinElement } from "./events.js";
 import { computed, inject, onBeforeUnmount, provide, readonly, ref, shallowRef, toValue, watch } from "vue";
 //#region src/internal/composables/useOverlayLayer.ts
 var overlayLayerKey = Symbol("overlay-layer");
@@ -38,11 +39,6 @@ function syncLayerZIndices(state) {
 		highestZIndex = zIndex;
 	}
 }
-function isEventWithinElement(event, element) {
-	const path = event.composedPath();
-	if (path.length > 0) return path.some((entry) => entry === element || typeof Node !== "undefined" && entry instanceof Node && element.contains(entry));
-	return typeof Node !== "undefined" && event.target instanceof Node && element.contains(event.target);
-}
 function restoreInertBackground(state) {
 	for (const [element, snapshot] of state.inertSnapshots) {
 		element.inert = snapshot.inert;

package/dist/useTeleportTarget.js

@@ -7,21 +7,14 @@ function readTeleportTarget(target) {
 function hasTarget(target) {
 	return target != null && target !== "";
 }
-function provideTeleportTarget(props, positioningKey) {
+function provideTeleportTarget(props) {
 	const parentContext = inject(teleportTargetKey, void 0);
 	const target = computed(() => {
 		const ownTarget = readTeleportTarget(props.teleportTo);
 		if (hasTarget(ownTarget)) return ownTarget;
 		return parentContext?.target.value ?? "body";
 	});
-	provide(teleportTargetKey, {
-		target,
-		positioningKey: computed(() => [
-			target.value,
-			toValue(positioningKey),
-			parentContext?.positioningKey.value
-		])
-	});
+	provide(teleportTargetKey, { target });
 	return target;
 }
 function useTeleportTarget(target) {
@@ -32,9 +25,5 @@ function useTeleportTarget(target) {
 		return providedContext?.target.value ?? "body";
 	});
 }
-function useTeleportPositioningKey() {
-	const providedContext = inject(teleportTargetKey, void 0);
-	return computed(() => providedContext?.positioningKey.value);
-}
 //#endregion
-export { useTeleportPositioningKey as n, useTeleportTarget as r, provideTeleportTarget as t };
+export { useTeleportTarget as n, provideTeleportTarget as t };

package/dist/useTypeahead.js

@@ -0,0 +1,94 @@
+import { n as normalizeTypeaheadText } from "./text.js";
+import { onBeforeUnmount } from "vue";
+//#region src/internal/composables/useTypeahead.ts
+var DEFAULT_TYPEAHEAD_TIMEOUT = 1e3;
+function isRepeatedQuery(query) {
+	const characters = [...query];
+	return characters.length > 1 && characters.every((character) => character === characters[0]);
+}
+function useTypeahead(options) {
+	let buffer = "";
+	let timer;
+	let lastMatch;
+	let currentScope = options.scopeKey?.();
+	const isDisabled = options.isDisabled ?? (() => false);
+	function clearTimer() {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+	}
+	function reset() {
+		clearTimer();
+		buffer = "";
+		lastMatch = void 0;
+		currentScope = options.scopeKey?.();
+	}
+	function scheduleReset() {
+		clearTimer();
+		timer = setTimeout(reset, options.timeout ?? DEFAULT_TYPEAHEAD_TIMEOUT);
+	}
+	function hasBuffer() {
+		return buffer.length > 0;
+	}
+	function getMatchIndex(query, startIndex, keepCurrent) {
+		const items = options.items();
+		if (items.length === 0) return -1;
+		function matches(index) {
+			const item = items[index];
+			return Boolean(item && !isDisabled(item) && normalizeTypeaheadText(options.getTextValue(item)).startsWith(query));
+		}
+		if (keepCurrent && startIndex >= 0 && matches(startIndex)) return startIndex;
+		for (let offset = 1; offset <= items.length; offset += 1) {
+			const index = (startIndex + offset + items.length) % items.length;
+			if (matches(index)) return index;
+		}
+		return -1;
+	}
+	function getLastMatchIndex(items) {
+		const match = lastMatch;
+		if (!match) return -1;
+		if (Object.is(items[match.index], match.item)) return match.index;
+		const identityIndex = items.findIndex((item) => Object.is(item, match.item));
+		if (identityIndex >= 0) return identityIndex;
+		let keyIndex = -1;
+		for (let index = 0; index < items.length; index += 1) {
+			if (!Object.is(options.getKey(items[index]), match.key)) continue;
+			if (keyIndex >= 0) return -1;
+			keyIndex = index;
+		}
+		return keyIndex;
+	}
+	function handleKey(event) {
+		const nextScope = options.scopeKey?.();
+		if (!Object.is(currentScope, nextScope)) reset();
+		currentScope = nextScope;
+		if (event.ctrlKey || event.metaKey || event.altKey || event.isComposing || [...event.key].length !== 1 || event.key === " " && !hasBuffer()) return false;
+		event.preventDefault();
+		buffer += event.key;
+		scheduleReset();
+		const normalizedBuffer = normalizeTypeaheadText(buffer);
+		if (!normalizedBuffer) return true;
+		const repeated = isRepeatedQuery(normalizedBuffer);
+		const query = repeated ? [...normalizedBuffer][0] : normalizedBuffer;
+		const items = options.items();
+		const lastMatchIndex = getLastMatchIndex(items);
+		const matchIndex = getMatchIndex(query, lastMatchIndex >= 0 ? lastMatchIndex : options.activeIndex(), !repeated && [...query].length > 1);
+		if (matchIndex < 0) return true;
+		const item = items[matchIndex];
+		if (!item) return true;
+		lastMatch = {
+			item,
+			index: matchIndex,
+			key: options.getKey(item)
+		};
+		options.onMatch(item, matchIndex);
+		return true;
+	}
+	onBeforeUnmount(clearTimer);
+	return {
+		handleKey,
+		hasBuffer,
+		reset
+	};
+}
+//#endregion
+export { useTypeahead as t };

package/dist/utils/aria.d.ts

@@ -0,0 +1,3 @@
+export declare function parseAriaIdRefs(value: string | null | undefined): string[];
+export declare function hasAriaIdRef(value: string | null | undefined, id: string): boolean;
+export declare function mergeAriaIdRefs(...values: Array<string | null | undefined>): string | undefined;

package/dist/utils/attributes.d.ts

@@ -0,0 +1,2 @@
+export declare function toPresenceAttribute(value: unknown): '' | undefined;
+export declare function toOptionalAttribute<T extends boolean | string | undefined>(value: T): T | undefined;

package/dist/utils/bem.d.ts

@@ -0,0 +1,3 @@
+type BemModifier = string | Record<string, boolean | undefined>;
+export declare function bem(block: string, ...modifiers: BemModifier[]): string[];
+export {};

package/dist/utils/collectionNavigation.d.ts

@@ -0,0 +1,2 @@
+export declare function getEnabledIndexes<T>(items: readonly T[], isDisabled: (item: T) => boolean): number[];
+export declare function getNextEnabledIndex<T>(items: readonly T[], currentIndex: number, direction: 1 | -1, isDisabled: (item: T) => boolean, loop?: boolean): number | undefined;

package/dist/utils/color.d.ts

@@ -0,0 +1,7 @@
+export interface ParsedCssColor {
+    red: number;
+    green: number;
+    blue: number;
+    opacity: number;
+}
+export declare function parseCssColor(value: string): ParsedCssColor | undefined;

package/dist/{components/color-picker/color-picker-utils.d.ts → utils/colorPicker.d.ts}

@@ -1,22 +1,23 @@
-import { ColorPickerFormat } from './types.js';
+export declare const colorPickerFormats: readonly ["hex", "hexa", "rgb", "rgba", "hsl", "hsla"];
+export type ColorPickerFormat = (typeof colorPickerFormats)[number];
 export declare const DEFAULT_HUE = 0;
 export declare const HUE_MAX = 359;
-export declare const KEYBOARD_STEP = 1;
-export declare const KEYBOARD_LARGE_STEP = 10;
 export declare const DEFAULT_OPACITY = 100;
+export declare const COLOR_PICKER_KEYBOARD_STEP = 1;
+export declare const COLOR_PICKER_KEYBOARD_LARGE_STEP = 10;
 export interface ColorPickerHsvColor {
     hue: number;
     saturation: number;
     value: number;
     opacity: number;
 }
-export declare function clamp(value: number, min: number, max: number): number;
 export declare function clampPercent(value: number | undefined): number;
 export declare function normalizeHue(value: number | undefined): number;
 export declare function normalizeHueForColor(value: number | undefined): number;
 export declare function clampHue(value: number): number;
 export declare function clampOpacity(value: number | undefined): number;
 export declare function roundPercent(value: number): number;
+export declare function getColorPickerKeyboardValue(key: string, currentValue: number, maxValue: number, step?: number): number | undefined;
 export declare function isColorPickerAlphaFormat(format: ColorPickerFormat): format is "hexa" | "rgba" | "hsla";
 export declare function parseColorPickerValue(value: string): ColorPickerHsvColor | undefined;
 export declare function formatColorPickerValue(color: ColorPickerHsvColor, format: ColorPickerFormat): string;

package/dist/utils/componentColors.d.ts

@@ -46,6 +46,12 @@ export interface ComponentVariantColorOptions extends ComponentContrastColorOpti
     variant: ComponentColorVariant | undefined;
     defaultColor?: ComponentColorValue;
 }
+export interface ComponentCheckedColorStyleOptions extends ComponentContrastColorOptions {
+    color: ComponentColorValue | undefined;
+    colorProperty: `--${string}`;
+    checkedColorProperty: `--${string}`;
+    defaultColor?: ComponentColorValue;
+}
 export type ParsedComponentColor = {
     kind: 'empty';
 } | {
@@ -68,6 +74,7 @@ export declare function isComponentPresetColor(color: ComponentColorValue | unde
 export declare function parseComponentColor(color: ComponentColorValue | undefined): ParsedComponentColor;
 export declare function getComponentColorValue(color: ComponentColorValue | undefined): string | undefined;
 export declare function getComponentContrastColor(color: ComponentColorValue | undefined, options?: ComponentContrastColorOptions): string;
+export declare function getComponentCheckedColorStyle({ color, colorProperty, checkedColorProperty, defaultColor, autoContrast, contrastColor, }: ComponentCheckedColorStyleOptions): Record<string, string> | undefined;
 export declare function getComponentContrastColorRoles(color: ComponentColorValue | undefined, options?: ComponentContrastColorOptions): ComponentContrastColorRoles;
 export declare function getComponentColorRoles(color: ComponentColorValue | undefined): ComponentColorRoles | undefined;
 export declare function getComponentVariantColorRoles({ color, variant, defaultColor, autoContrast, contrastColor, }: ComponentVariantColorOptions): ComponentVariantColorRoles | undefined;

package/dist/utils/css.d.ts

@@ -0,0 +1,3 @@
+export type CssLength = number | string | null | undefined;
+export declare function toCssLength(value: CssLength): string | undefined;
+export declare function toPositiveCssLength(value: CssLength): string | undefined;

package/dist/utils/dom/ancestry.d.ts

@@ -0,0 +1,7 @@
+export interface ObserveComposedAncestryOptions {
+    deferWhileDisconnected?: boolean;
+}
+export declare function getComposedParent(node: Node): Node | null;
+export declare function getComposedAncestry(node: Node | null | undefined): Node[];
+export declare function areNodeListsIdentical(left: readonly Node[], right: readonly Node[]): boolean;
+export declare function observeComposedAncestry(getNodes: () => readonly (Node | null | undefined)[], onChange: () => void, options?: ObserveComposedAncestryOptions): () => void;

package/dist/utils/dom/attributes.d.ts

@@ -0,0 +1,16 @@
+export type AttributeSnapshot<Name extends string = string> = ReadonlyMap<Name, string | null>;
+export interface CompatibilityAttributes {
+    class?: unknown;
+    style?: unknown;
+}
+export type EventHandler<EventType extends Event> = (event: EventType) => unknown;
+export declare function splitCompatibilityAttributes<Attributes extends CompatibilityAttributes>(attributes: Attributes): {
+    compatibilityClass: Attributes['class'];
+    compatibilityStyle: Attributes['style'];
+    forwardedAttributes: Omit<Attributes, 'class' | 'style'>;
+};
+export declare function composeEventHandlers<EventType extends Event>(...handlers: ReadonlyArray<EventHandler<EventType> | undefined>): (event: EventType) => void;
+export declare function parseAttributeTokens(value: string | null | undefined): string[];
+export declare function hasAttributeToken(value: string | null | undefined, token: string): boolean;
+export declare function snapshotAttributes<Name extends string>(element: Element, attributes: readonly Name[]): AttributeSnapshot<Name>;
+export declare function restoreAttributes(element: Element, snapshot: AttributeSnapshot): void;

package/dist/utils/dom/componentRef.d.ts

@@ -0,0 +1,4 @@
+import { ComponentPublicInstance, VaporComponentInstance } from 'vue';
+export type ComponentElementRef = Element | ComponentPublicInstance | VaporComponentInstance | null;
+export declare function toHTMLElement(value: ComponentElementRef, fallbackId?: string): HTMLElement | null;
+export declare function resolveHTMLElementRef(value: ComponentElementRef, fallbackId: string, resolve: (element: HTMLElement | null) => void): void;

package/dist/utils/dom/events.d.ts

@@ -0,0 +1,5 @@
+export declare function isNodeWithinElement(value: unknown, element: unknown): value is Node;
+export declare function isEventWithinElement(event: Event, element: Element): boolean;
+export type EventContainmentTarget = string | Element | null | undefined;
+export declare function isEventWithinTargets(event: Event, targets: readonly EventContainmentTarget[]): boolean;
+export declare function createCancelableCustomEvent<T>(type: string, detail: T, originalEvent: Event): CustomEvent<T>;

package/dist/utils/dom/focusNavigation.d.ts

@@ -0,0 +1,7 @@
+export type FocusNavigationOrientation = 'horizontal' | 'vertical';
+export interface FocusNavigationOptions {
+    itemSelector: string;
+    collectionSelector: string;
+    orientation: FocusNavigationOrientation;
+}
+export declare function getFocusNavigationTarget<ElementType extends HTMLElement>(event: Pick<KeyboardEvent, 'key' | 'target'>, collection: HTMLElement, options: FocusNavigationOptions): ElementType | undefined;

package/dist/utils/dom/interactive.d.ts

@@ -0,0 +1,2 @@
+export declare const INTERACTIVE_ELEMENT_SELECTOR: string;
+export declare function isInteractiveElement(target: unknown, ignoredSelector?: string): boolean;

package/dist/utils/dom/pointer.d.ts

@@ -0,0 +1,2 @@
+export declare function getPointerId(event: Pick<PointerEvent, 'pointerId'>): number | undefined;
+export declare function isMatchingPointer(event: Pick<PointerEvent, 'pointerId'>, pointerId: number | undefined): boolean;

package/dist/utils/dom/query.d.ts

@@ -0,0 +1,4 @@
+export declare function isElement(value: unknown): value is Element;
+export declare function matchesSelectorSafe(element: Element, selector: string): boolean;
+export declare function querySelectorSafe<ElementType extends Element = Element>(selector: string, root?: ParentNode | null): ElementType | null;
+export declare function querySelectorAllSafe<ElementType extends Element = Element>(selector: string, root?: ParentNode | null): ElementType[];

package/dist/utils/dom/scroll.d.ts

@@ -0,0 +1,23 @@
+export type ScrollAxis = 'x' | 'y';
+export type ScrollDirection = 'ltr' | 'rtl';
+export interface KeyboardScrollPositionOptions {
+    axis: ScrollAxis;
+    key: string;
+    current: number;
+    pageSize: number;
+    maxPosition: number;
+    direction: ScrollDirection;
+    lineStep: number;
+}
+export declare function getScrollDirection(element: Element): ScrollDirection;
+export declare function getLogicalHorizontalScrollPosition(scrollLeft: number, maxPosition: number, direction: ScrollDirection): number;
+export declare function getRawHorizontalScrollPosition(position: number, maxPosition: number, direction: ScrollDirection): number;
+export declare function getScrollThumbGeometry(trackSize: number, viewportSize: number, scrollSize: number, minimumSize: number): {
+    size: number;
+    offsetRatio: number;
+};
+export declare function getScrollThumbOffset(position: number, maxPosition: number, sizeRatio: number): number;
+export declare function getKeyboardScrollPosition({ axis, key, current, pageSize, maxPosition, direction, lineStep, }: KeyboardScrollPositionOptions): number | undefined;
+export declare function getWheelScrollDelta(axis: ScrollAxis, event: Pick<WheelEvent, 'deltaX' | 'deltaY'>, direction: ScrollDirection): number;
+export declare function applyFallbackScrollPosition(element: Pick<HTMLElement, 'scrollLeft' | 'scrollTop'>, options: Pick<ScrollToOptions, 'left' | 'top'>, mode: 'absolute' | 'relative'): void;
+export declare function getPointerAxisCoordinate(axis: ScrollAxis, event: Pick<PointerEvent, 'clientX' | 'clientY'>): number;

package/dist/utils/floatingOffset.d.ts

@@ -0,0 +1,10 @@
+export interface FloatingOffsetAxes {
+    mainAxis?: number;
+    crossAxis?: number;
+}
+export type FloatingOffsetValue = number | FloatingOffsetAxes;
+export interface FloatingOffsetProperties {
+    mainAxis: `--${string}`;
+    crossAxis: `--${string}`;
+}
+export declare function getFloatingOffsetStyle(offset: FloatingOffsetValue | null | undefined, properties: FloatingOffsetProperties): Record<string, string> | undefined;

package/dist/utils/geometry.d.ts

@@ -0,0 +1,14 @@
+export interface Point {
+    x: number;
+    y: number;
+}
+export type Triangle = [Point, Point, Point];
+type RectBounds = Pick<DOMRect, 'bottom' | 'height' | 'left' | 'right' | 'top' | 'width'>;
+export declare function getClientPoint(event: Pick<MouseEvent, 'clientX' | 'clientY'>): Point;
+export declare function hasMeasuredRect(rect: Pick<DOMRect, 'height' | 'width'>): boolean;
+export declare function isPointInRect(point: Point, rect: RectBounds, padding?: number): boolean;
+export declare function getTriangleArea(a: Point, b: Point, c: Point): number;
+export declare function isPointInTriangle(point: Point, triangle: Triangle, tolerance?: number): boolean;
+export declare function clampPointToRect(point: Point, rect: RectBounds): Point;
+export declare function createPointRect(point: Point): DOMRect;
+export {};

package/dist/utils/indexPath.d.ts

@@ -0,0 +1,6 @@
+export type IndexPath = number[];
+export declare function getPathKey(path: IndexPath): string;
+export declare function getParentPath(path: IndexPath): IndexPath;
+export declare function arePathsEqual(a: IndexPath, b: IndexPath): boolean;
+export declare function isPathPrefix(prefix: IndexPath, path: IndexPath): boolean;
+export declare function normalizePath(indexOrPath: number | IndexPath): IndexPath;

package/dist/utils/number.d.ts

@@ -0,0 +1,4 @@
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function getValuePercent(value: number, min: number, max: number): number;
+export declare function normalizeDelay(value: number | null | undefined, fallback?: number): number;
+export declare function roundTo(value: number, fractionDigits?: number): number;

package/dist/utils/rafScheduler.d.ts

@@ -0,0 +1,4 @@
+export declare function createRafScheduler(callback: () => void, getView: () => Window | null | undefined): {
+    cancel: () => void;
+    schedule: () => void;
+};

package/dist/utils/text.d.ts

@@ -0,0 +1,2 @@
+export declare function getNameInitials(name: string | null | undefined): string;
+export declare function normalizeTypeaheadText(value: string, locales?: Intl.LocalesArgument): string;