ropav 0.1.6 → 0.1.8

package/dist/useOverlayZIndex.js

@@ -1,12 +1,40 @@
+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,
@@ -28,6 +56,24 @@ function isDescendantLayer(layer, ancestor) {
 	}
 	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) {
@@ -38,10 +84,64 @@ 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 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) {
@@ -127,11 +227,41 @@ function syncModalEffects(document, state) {
 	}
 }
 function removeLayer(layer, document, state) {
-	const index = state.layers.indexOf(layer);
-	if (index >= 0) state.layers.splice(index, 1);
+	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)));
@@ -142,14 +272,26 @@ function useOverlayLayer(options) {
 	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 = {}) {
@@ -170,6 +312,36 @@ function useOverlayLayer(options) {
 		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,
@@ -192,49 +364,100 @@ function useOverlayLayer(options) {
 				...additional
 			].some((element) => element != null && isEventWithinElement(event, element));
 		},
-		registerBranch
+		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() {
-		replaceParentBranch(null);
 		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) {
-				replaceParentBranch(element);
 				registeredElement = element;
+				syncOwnInteractionDocuments();
+				replaceParentBranch(element);
 				syncModalEffects(document, getState(document));
 			}
 			return;
 		}
-		unregister();
+		if (registeredDocument) {
+			moveRegistration(element);
+			return;
+		}
 		const state = getState(document);
-		const currentIndex = state.layers.indexOf(context);
-		if (currentIndex >= 0) state.layers.splice(currentIndex, 1);
-		const descendantIndex = state.layers.findIndex((layer) => isDescendantLayer(layer, context));
-		if (descendantIndex >= 0) state.layers.splice(descendantIndex, 0, context);
-		else state.layers.push(context);
 		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);
 	}
-	watch([active, options.element], ([isActive, element]) => {
-		if (isActive && element?.isConnected) register(element);
-		else unregister();
+	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
@@ -246,7 +469,11 @@ function useOverlayLayer(options) {
 		if (registeredDocument) syncLayerZIndices(getState(registeredDocument));
 		else zIndex.value = value;
 	});
-	onBeforeUnmount(unregister);
+	onBeforeUnmount(() => {
+		ancestryObserver.dispose();
+		unregister();
+		interactions.clear();
+	});
 	provide(overlayLayerKey, context);
 	return context;
 }

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/date.d.ts

@@ -0,0 +1,13 @@
+export declare function isValidDate(value: unknown): value is Date;
+export declare function toLocalDate(value: Date): Date;
+export declare function normalizeDate(value: Date | null | undefined): Date | null;
+export declare function toDateKey(value: Date): string;
+export declare function parseDateKey(value: string): Date | null;
+export declare function compareDates(left: Date, right: Date): number;
+export declare function isSameDate(left: Date | null | undefined, right: Date | null | undefined): boolean;
+export declare function isSameMonth(left: Date, right: Date): boolean;
+export declare function startOfMonth(value: Date): Date;
+export declare function endOfMonth(value: Date): Date;
+export declare function addCalendarDays(value: Date, amount: number): Date;
+export declare function addCalendarMonths(value: Date, amount: number): Date;
+export declare function addCalendarYears(value: Date, amount: number): Date;

package/dist/utils/dateAvailability.d.ts

@@ -0,0 +1,7 @@
+export type DisabledDateRule = readonly Date[] | ((date: Date) => boolean);
+export interface DateAvailabilityOptions {
+    min?: Date;
+    max?: Date;
+    disabledDates?: DisabledDateRule;
+}
+export declare function isDateUnavailable(date: Date, options: DateAvailabilityOptions): boolean;

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

@@ -0,0 +1,8 @@
+export interface ObserveComposedAncestryOptions {
+    deferWhileDisconnected?: boolean;
+    notifyOnDisconnect?: 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/direction.d.ts

@@ -0,0 +1,2 @@
+export type ElementDirection = 'ltr' | 'rtl';
+export declare function getElementDirection(element: Element): ElementDirection;

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/files.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeSelectedFiles(files: Iterable<File>, multiple: boolean): File[];
+export declare function haveSameFiles(fileList: FileList | null, files: readonly File[]): boolean;
+export declare function replaceInputFiles(input: HTMLInputElement, files: readonly File[]): boolean;

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;