ropav 0.2.0 → 0.3.0

package/dist/useOverlayZIndex.js

@@ -1,514 +0,0 @@
-import { n as isEventWithinElement } from "./events.js";
-import { n as observeComposedAncestry } from "./ancestry.js";
-import { computed, inject, onBeforeUnmount, provide, readonly, ref, shallowRef, toValue, watch } from "vue";
-//#region src/internal/composables/useOverlayLayer.ts
-var overlayLayerKey = Symbol("overlay-layer");
-var documentStates = /* @__PURE__ */ new WeakMap();
-var activeInteractionLayers = [];
-var interactionListenerDefinitions = {
-	escapeKeyDown: {
-		capture: false,
-		eventName: "keydown",
-		outside: false,
-		matches: (event) => event.key === "Escape"
-	},
-	pointerDownOutside: {
-		capture: true,
-		eventName: "pointerdown",
-		outside: true
-	},
-	focusOutside: {
-		capture: true,
-		eventName: "focusin",
-		outside: true
-	},
-	clickOutside: {
-		capture: true,
-		eventName: "click",
-		outside: true
-	}
-};
-var layerMetadata = /* @__PURE__ */ new WeakMap();
-function createState() {
-	return {
-		layers: [],
-		interactionLayers: [],
-		inertSnapshots: /* @__PURE__ */ new Map(),
-		interactionListeners: {},
-		originalBodyOverflow: "",
-		scrollLocked: false,
-		observer: null,
-		syncQueued: false
-	};
-}
-function getState(document) {
-	const existing = documentStates.get(document);
-	if (existing) return existing;
-	const state = createState();
-	documentStates.set(document, state);
-	return state;
-}
-function isDescendantLayer(layer, ancestor) {
-	let parent = layerMetadata.get(layer)?.parent ?? null;
-	while (parent) {
-		if (parent === ancestor) return true;
-		parent = layerMetadata.get(parent)?.parent ?? null;
-	}
-	return false;
-}
-function insertLayer(layers, layer) {
-	const currentIndex = layers.indexOf(layer);
-	if (currentIndex >= 0) layers.splice(currentIndex, 1);
-	const descendantIndex = layers.findIndex((candidate) => isDescendantLayer(candidate, layer));
-	if (descendantIndex >= 0) layers.splice(descendantIndex, 0, layer);
-	else layers.push(layer);
-}
-function insertPhysicalLayer(layers, layer) {
-	removeLayerFromStack(layers, layer);
-	const layerIndex = activeInteractionLayers.indexOf(layer);
-	const nextIndex = layers.findIndex((candidate) => activeInteractionLayers.indexOf(candidate) > layerIndex);
-	if (nextIndex >= 0) layers.splice(nextIndex, 0, layer);
-	else layers.push(layer);
-}
-function removeLayerFromStack(layers, layer) {
-	const index = layers.indexOf(layer);
-	if (index >= 0) layers.splice(index, 1);
-}
-function syncLayerZIndices(state) {
-	let highestZIndex = Number.NEGATIVE_INFINITY;
-	for (const layer of state.layers) {
-		const metadata = layerMetadata.get(layer);
-		if (!metadata) continue;
-		const zIndex = Math.max(metadata.baseZIndex.value, highestZIndex + 2);
-		metadata.setZIndex(zIndex);
-		highestZIndex = zIndex;
-	}
-}
-function syncDocumentInteractionLayers(document) {
-	const state = getState(document);
-	state.interactionLayers = activeInteractionLayers.filter((layer) => layerMetadata.get(layer)?.interactionDocuments.has(document));
-	syncInteractionListeners(document, state);
-}
-function reconcileInteractionDocuments(layer) {
-	const affectedDocuments = /* @__PURE__ */ new Set();
-	const layers = activeInteractionLayers.filter((candidate) => candidate === layer || isDescendantLayer(candidate, layer));
-	if (!layers.includes(layer)) layers.unshift(layer);
-	for (const candidate of layers) {
-		const metadata = layerMetadata.get(candidate);
-		if (!metadata) continue;
-		for (const document of metadata.interactionDocuments) affectedDocuments.add(document);
-		const nextDocuments = metadata.registered ? new Set(metadata.ownInteractionDocuments) : /* @__PURE__ */ new Set();
-		const parentDocuments = metadata.parent ? layerMetadata.get(metadata.parent)?.interactionDocuments : void 0;
-		if (metadata.registered && parentDocuments) for (const document of parentDocuments) nextDocuments.add(document);
-		metadata.interactionDocuments = nextDocuments;
-		for (const document of nextDocuments) affectedDocuments.add(document);
-	}
-	for (const document of affectedDocuments) syncDocumentInteractionLayers(document);
-}
-function hasInteractionHandler(state, name) {
-	return state.interactionLayers.some((layer) => [...layerMetadata.get(layer)?.interactions ?? []].some((interaction) => typeof interaction[name] === "function"));
-}
-function routeLayerInteraction(state, name, event) {
-	const layer = state.interactionLayers[state.interactionLayers.length - 1];
-	if (!layer) return;
-	const definition = interactionListenerDefinitions[name];
-	if (definition.matches && !definition.matches(event)) return;
-	const interactions = [...layerMetadata.get(layer)?.interactions ?? []];
-	for (const interaction of interactions) {
-		const handler = interaction[name];
-		if (!handler) continue;
-		const additionalInside = interaction.inside ? toValue(interaction.inside) : [];
-		if (definition.outside && layer.isInside(event, additionalInside)) continue;
-		handler(event);
-	}
-}
-function syncInteractionListeners(document, state) {
-	for (const name of Object.keys(interactionListenerDefinitions)) {
-		const existing = state.interactionListeners[name];
-		if (!hasInteractionHandler(state, name)) {
-			if (existing) {
-				document.removeEventListener(existing.eventName, existing.listener, existing.capture);
-				delete state.interactionListeners[name];
-			}
-			continue;
-		}
-		if (existing) continue;
-		const definition = interactionListenerDefinitions[name];
-		const listener = (event) => routeLayerInteraction(state, name, event);
-		document.addEventListener(definition.eventName, listener, definition.capture);
-		state.interactionListeners[name] = {
-			capture: definition.capture,
-			eventName: definition.eventName,
-			listener
-		};
-	}
-}
-function restoreInertBackground(state) {
-	for (const [element, snapshot] of state.inertSnapshots) {
-		element.inert = snapshot.inert;
-		if (snapshot.ariaHidden == null) element.removeAttribute("aria-hidden");
-		else element.setAttribute("aria-hidden", snapshot.ariaHidden);
-	}
-	state.inertSnapshots.clear();
-}
-function inertElement(state, element) {
-	if (!state.inertSnapshots.has(element)) state.inertSnapshots.set(element, {
-		ariaHidden: element.getAttribute("aria-hidden"),
-		inert: Boolean(element.inert)
-	});
-	element.inert = true;
-	element.setAttribute("aria-hidden", "true");
-}
-function inertUnprotectedBranches(state, parent, protectedRoots) {
-	for (const child of parent.children) {
-		if (!(child instanceof HTMLElement)) continue;
-		if (!protectedRoots.some((root) => child === root || child.contains(root))) {
-			inertElement(state, child);
-			continue;
-		}
-		if (!protectedRoots.includes(child)) inertUnprotectedBranches(state, child, protectedRoots);
-	}
-}
-function stopObserver(state) {
-	state.observer?.disconnect();
-	state.observer = null;
-	state.syncQueued = false;
-}
-function unlockScroll(document, state) {
-	if (!state.scrollLocked) return;
-	document.body.style.overflow = state.originalBodyOverflow;
-	state.scrollLocked = false;
-}
-function queueModalEffects(document, state) {
-	if (state.syncQueued) return;
-	state.syncQueued = true;
-	queueMicrotask(() => {
-		state.syncQueued = false;
-		syncModalEffects(document, state);
-	});
-}
-function startObserver(document, state) {
-	if (state.observer || typeof MutationObserver === "undefined") return;
-	state.observer = new MutationObserver(() => queueModalEffects(document, state));
-	state.observer.observe(document.body, {
-		childList: true,
-		subtree: true
-	});
-}
-function syncModalEffects(document, state) {
-	restoreInertBackground(state);
-	let modalIndex = -1;
-	for (let index = state.layers.length - 1; index >= 0; index -= 1) {
-		const layer = state.layers[index];
-		if (layer?.modalEffects && layer.modal.value) {
-			modalIndex = index;
-			break;
-		}
-	}
-	const shouldLock = state.layers.some((layer) => layer.modalEffects && layer.modal.value && layer.preventScroll.value);
-	if (shouldLock && !state.scrollLocked) {
-		state.originalBodyOverflow = document.body.style.overflow;
-		document.body.style.overflow = "hidden";
-		state.scrollLocked = true;
-	} else if (!shouldLock) unlockScroll(document, state);
-	if (modalIndex < 0) {
-		stopObserver(state);
-		return;
-	}
-	const protectedRoots = [];
-	for (const layer of state.layers.slice(modalIndex)) {
-		const element = layer.element.value;
-		if (element?.isConnected) protectedRoots.push(element);
-		for (const branch of layer.branches.value) if (branch.isConnected) protectedRoots.push(branch);
-	}
-	if (protectedRoots.length > 0) {
-		inertUnprotectedBranches(state, document.body, protectedRoots);
-		startObserver(document, state);
-	}
-}
-function removeLayer(layer, document, state) {
-	removeLayerFromStack(state.layers, layer);
-	syncLayerZIndices(state);
-	syncModalEffects(document, state);
-}
-function createOverlayLayerAncestryObserver(options) {
-	let cleanups = [];
-	let disposed = false;
-	function stop() {
-		for (const cleanup of cleanups) cleanup();
-		cleanups = [];
-	}
-	function reset() {
-		stop();
-		if (disposed || !options.active.value) return;
-		const content = options.element.value;
-		if (content) cleanups.push(observeComposedAncestry(() => [content], options.onContentChange, { deferWhileDisconnected: true }));
-		const auxiliaryElements = new Set(options.branches);
-		for (const interaction of options.interactions) {
-			if (!interaction.inside) continue;
-			for (const element of toValue(interaction.inside)) if (element) auxiliaryElements.add(element);
-		}
-		if (content) auxiliaryElements.delete(content);
-		for (const element of auxiliaryElements) cleanups.push(observeComposedAncestry(() => [element], options.onAuxiliaryChange, {
-			deferWhileDisconnected: true,
-			notifyOnDisconnect: true
-		}));
-	}
-	return {
-		reset,
-		dispose() {
-			disposed = true;
-			stop();
-		}
-	};
-}
-function useOverlayLayer(options) {
-	const parent = inject(overlayLayerKey, null);
-	const active = computed(() => Boolean(toValue(options.active)));
-	const modal = computed(() => Boolean(toValue(options.modal ?? false)));
-	const preventScroll = computed(() => Boolean(toValue(options.preventScroll ?? true)));
-	const branches = shallowRef([]);
-	const focusBranches = shallowRef([]);
-	const branchSet = /* @__PURE__ */ new Set();
-	const focusBranchSet = /* @__PURE__ */ new Set();
-	const insideBranchSet = /* @__PURE__ */ new Set();
-	const interactions = /* @__PURE__ */ new Set();
-	const interactionSetRevision = ref(0);
-	const baseZIndex = computed(() => toValue(options.baseZIndex ?? 100));
-	const zIndex = ref(baseZIndex.value);
-	let registeredDocument = null;
-	let registeredElement = null;
-	let parentBranchCleanup;
-	const ancestryObserver = createOverlayLayerAncestryObserver({
-		active,
-		element: options.element,
-		branches: branchSet,
-		interactions,
-		onContentChange: syncObservedAncestry,
-		onAuxiliaryChange: syncObservedAuxiliaryAncestry
-	});
-	function syncBranches() {
-		branches.value = [...branchSet];
-		focusBranches.value = [...focusBranchSet];
-		syncOwnInteractionDocuments();
-		ancestryObserver.reset();
-		if (registeredDocument) syncModalEffects(registeredDocument, getState(registeredDocument));
-	}
-	function registerBranch(element, branchOptions = {}) {
-		branchSet.add(element);
-		if (branchOptions.focus !== false) focusBranchSet.add(element);
-		if (branchOptions.inside !== false) insideBranchSet.add(element);
-		const parentCleanup = parent?.registerBranch(element, branchOptions);
-		syncBranches();
-		return () => {
-			branchSet.delete(element);
-			focusBranchSet.delete(element);
-			insideBranchSet.delete(element);
-			parentCleanup?.();
-			syncBranches();
-		};
-	}
-	function replaceParentBranch(element) {
-		parentBranchCleanup?.();
-		parentBranchCleanup = element ? parent?.registerBranch(element) : void 0;
-	}
-	function connectInteraction(interaction) {
-		interactions.add(interaction);
-		interactionSetRevision.value += 1;
-		let connected = true;
-		return Object.assign(() => {
-			if (!connected) return;
-			connected = false;
-			interactions.delete(interaction);
-			interactionSetRevision.value += 1;
-		}, { refresh() {
-			if (!connected) return;
-			syncOwnInteractionDocuments();
-			ancestryObserver.reset();
-		} });
-	}
-	function readOwnInteractionDocuments() {
-		const documents = /* @__PURE__ */ new Set();
-		if (registeredElement) documents.add(registeredElement.ownerDocument);
-		for (const branch of branchSet) if (branch.isConnected) documents.add(branch.ownerDocument);
-		for (const interaction of interactions) if (interaction.inside) {
-			for (const element of toValue(interaction.inside)) if (element?.isConnected) documents.add(element.ownerDocument);
-		}
-		return [...documents];
-	}
-	function syncOwnInteractionDocuments(documents = readOwnInteractionDocuments()) {
-		const metadata = layerMetadata.get(context);
-		if (!metadata) return;
-		metadata.ownInteractionDocuments = new Set(documents);
-		reconcileInteractionDocuments(context);
-	}
-	const context = {
-		id: Symbol("overlay-layer"),
-		element: options.element,
-		active,
-		modal,
-		modalEffects: options.modalEffects === true,
-		preventScroll,
-		branches,
-		focusBranches,
-		zIndex: readonly(zIndex),
-		isTopLayer() {
-			if (!registeredDocument) return false;
-			const layers = getState(registeredDocument).layers;
-			return layers[layers.length - 1] === context;
-		},
-		isInside(event, additional = []) {
-			return [
-				options.element.value,
-				...insideBranchSet,
-				...additional
-			].some((element) => element != null && isEventWithinElement(event, element));
-		},
-		registerBranch,
-		connectInteraction
-	};
-	layerMetadata.set(context, {
-		baseZIndex,
-		interactions,
-		interactionDocuments: /* @__PURE__ */ new Set(),
-		ownInteractionDocuments: /* @__PURE__ */ new Set(),
-		parent,
-		registered: false,
-		setZIndex(value) {
-			zIndex.value = value;
-		}
-	});
-	watch(() => {
-		interactionSetRevision.value;
-		return readOwnInteractionDocuments();
-	}, (documents) => {
-		syncOwnInteractionDocuments(documents);
-		ancestryObserver.reset();
-	}, {
-		flush: "sync",
-		immediate: true
-	});
-	function unregister() {
-		if (!registeredDocument) return;
-		const document = registeredDocument;
-		registeredDocument = null;
-		registeredElement = null;
-		const metadata = layerMetadata.get(context);
-		if (metadata) metadata.registered = false;
-		removeLayerFromStack(activeInteractionLayers, context);
-		syncOwnInteractionDocuments();
-		replaceParentBranch(null);
-		removeLayer(context, document, getState(document));
-	}
-	function moveRegistration(element) {
-		const previousDocument = registeredDocument;
-		if (!previousDocument) return;
-		registeredDocument = element.ownerDocument;
-		registeredElement = element;
-		removeLayer(context, previousDocument, getState(previousDocument));
-		const state = getState(registeredDocument);
-		insertPhysicalLayer(state.layers, context);
-		syncOwnInteractionDocuments();
-		replaceParentBranch(element);
-		syncLayerZIndices(state);
-		syncModalEffects(registeredDocument, state);
-	}
-	function register(element) {
-		const document = element.ownerDocument;
-		if (registeredDocument === document) {
-			if (registeredElement !== element) {
-				registeredElement = element;
-				syncOwnInteractionDocuments();
-				replaceParentBranch(element);
-				syncModalEffects(document, getState(document));
-			}
-			return;
-		}
-		if (registeredDocument) {
-			moveRegistration(element);
-			return;
-		}
-		const state = getState(document);
-		registeredDocument = document;
-		registeredElement = element;
-		const metadata = layerMetadata.get(context);
-		if (metadata) metadata.registered = true;
-		insertLayer(activeInteractionLayers, context);
-		insertPhysicalLayer(state.layers, context);
-		syncOwnInteractionDocuments();
-		replaceParentBranch(element);
-		syncLayerZIndices(state);
-		syncModalEffects(document, state);
-	}
-	function syncRegistration() {
-		const element = options.element.value;
-		if (active.value && element?.isConnected) {
-			register(element);
-			syncOwnInteractionDocuments();
-		} else unregister();
-	}
-	function syncObservedAncestry() {
-		syncRegistration();
-		if (registeredDocument) syncModalEffects(registeredDocument, getState(registeredDocument));
-	}
-	function syncObservedAuxiliaryAncestry() {
-		syncOwnInteractionDocuments();
-		if (registeredDocument) syncModalEffects(registeredDocument, getState(registeredDocument));
-	}
-	watch([active, options.element], () => {
-		syncRegistration();
-		ancestryObserver.reset();
-	}, {
-		flush: "post",
-		immediate: true
-	});
-	watch([modal, preventScroll], () => {
-		if (registeredDocument) syncModalEffects(registeredDocument, getState(registeredDocument));
-	});
-	watch(baseZIndex, (value) => {
-		if (registeredDocument) syncLayerZIndices(getState(registeredDocument));
-		else zIndex.value = value;
-	});
-	onBeforeUnmount(() => {
-		ancestryObserver.dispose();
-		unregister();
-		interactions.clear();
-	});
-	provide(overlayLayerKey, context);
-	return context;
-}
-function useOverlayLayerBranch(element, options = {}) {
-	const layer = inject(overlayLayerKey, null);
-	let cleanup;
-	watch(element, (nextElement) => {
-		cleanup?.();
-		cleanup = nextElement ? layer?.registerBranch(nextElement, options) : void 0;
-	}, {
-		flush: "post",
-		immediate: true
-	});
-	onBeforeUnmount(() => cleanup?.());
-	return layer;
-}
-function useParentOverlayLayer() {
-	return inject(overlayLayerKey, null);
-}
-//#endregion
-//#region src/components/overlay/useOverlayZIndex.ts
-var overlayZIndexKey = Symbol("overlay-z-index");
-function provideOverlayZIndex(baseZIndex) {
-	const resolvedBaseZIndex = computed(() => toValue(baseZIndex));
-	provide(overlayZIndexKey, { baseZIndex: resolvedBaseZIndex });
-	return resolvedBaseZIndex;
-}
-function useOverlayZIndex(options = {}) {
-	const provided = inject(overlayZIndexKey, null);
-	const parentLayer = useParentOverlayLayer();
-	return computed(() => {
-		const resolvedZIndex = (toValue(options.baseZIndex) ?? provided?.baseZIndex.value ?? options.defaultBaseZIndex ?? 1e3) + (toValue(options.offset) ?? 0);
-		if (toValue(options.aboveParent) === false || !parentLayer) return resolvedZIndex;
-		return Math.max(resolvedZIndex, parentLayer.zIndex.value + 1);
-	});
-}
-//#endregion
-export { useOverlayLayerBranch as i, useOverlayZIndex as n, useOverlayLayer as r, provideOverlayZIndex as t };

package/dist/useRequiredInject.js

@@ -1,9 +0,0 @@
-import { inject } from "vue";
-//#region src/internal/composables/useRequiredInject.ts
-function useRequiredInject(key, componentName) {
-	const value = inject(key);
-	if (value == null) throw new Error(`[Ropav] <${componentName}> must be used inside its parent provider component.`);
-	return value;
-}
-//#endregion
-export { useRequiredInject as t };

package/dist/useTeleportTarget.js

@@ -1,29 +0,0 @@
-import { computed, inject, isRef, provide, toValue } from "vue";
-//#region src/components/teleport-provider/useTeleportTarget.ts
-var teleportTargetKey = Symbol("teleport-target");
-function readTeleportTarget(target) {
-	return isRef(target) ? target.value : target;
-}
-function hasTarget(target) {
-	return target != null && target !== "";
-}
-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 });
-	return target;
-}
-function useTeleportTarget(target) {
-	const providedContext = inject(teleportTargetKey, void 0);
-	return computed(() => {
-		const ownTarget = readTeleportTarget(toValue(target));
-		if (hasTarget(ownTarget)) return ownTarget;
-		return providedContext?.target.value ?? "body";
-	});
-}
-//#endregion
-export { useTeleportTarget as n, provideTeleportTarget as t };

package/dist/useTypeahead.js

@@ -1,94 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

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

package/dist/utils/collectionNavigation.d.ts

@@ -1,2 +0,0 @@
-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/colorPicker.d.ts

@@ -1,24 +0,0 @@
-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 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 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;
-export declare function getHsvCssColor(hue: number, saturation: number, value: number): string;