@vizejs/ui 0.345.0 → 0.350.2

package/dist/composite-navigation-Skx3LZsv.mjs

@@ -0,0 +1,354 @@
+import { t as createTypeahead } from "./typeahead-B7KDxE_u.mjs";
+import { getCurrentScope, onScopeDispose, toValue } from "vue";
+//#region src/composite-navigation-internal.ts
+const optionDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_OPTION";
+function capture(errors, callback) {
+	try {
+		callback();
+	} catch (error) {
+		errors.push(error);
+	}
+}
+function surfaceErrors(errors, message) {
+	if (errors.length === 1) throw errors[0];
+	if (errors.length < 2) return;
+	const Aggregate = globalThis.AggregateError;
+	if (typeof Aggregate === "function") throw new Aggregate(errors, message);
+	const fallback = Object.assign(new Error(message), { errors: [...errors] });
+	fallback.name = "AggregateError";
+	throw fallback;
+}
+function readBoolean(source, name) {
+	const value = toValue(source);
+	if (value === void 0) return false;
+	if (typeof value !== "boolean") throw new TypeError(`${optionDiagnostic}: ${name} must resolve to a boolean`);
+	return value;
+}
+function readOrientation(source) {
+	const value = toValue(source) ?? "vertical";
+	if (value !== "both" && value !== "horizontal" && value !== "vertical") throw new TypeError(`${optionDiagnostic}: orientation must resolve to both, horizontal, or vertical`);
+	return value;
+}
+function readDirection(source) {
+	const value = toValue(source) ?? "ltr";
+	if (value !== "ltr" && value !== "rtl") throw new TypeError(`${optionDiagnostic}: direction must resolve to ltr or rtl`);
+	return value;
+}
+function readPageSize(source) {
+	const value = toValue(source) ?? 10;
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) throw new TypeError(`${optionDiagnostic}: pageSize must resolve to a positive safe integer`);
+	return value;
+}
+function readStrategy(value) {
+	const strategy = value ?? "roving";
+	if (strategy !== "roving" && strategy !== "active-descendant") throw new TypeError(`${optionDiagnostic}: focusStrategy must be roving or active-descendant`);
+	return strategy;
+}
+function keyIntent(event, orientation, direction) {
+	if (event.isComposing || event.altKey || event.ctrlKey || event.metaKey) return null;
+	if (event.key === "Home") return "first";
+	if (event.key === "End") return "last";
+	if (event.key === "PageDown") return "page-next";
+	if (event.key === "PageUp") return "page-previous";
+	if ((orientation === "vertical" || orientation === "both") && event.key === "ArrowDown") return "next";
+	if ((orientation === "vertical" || orientation === "both") && event.key === "ArrowUp") return "previous";
+	if (orientation === "horizontal" || orientation === "both") {
+		if (event.key === "ArrowRight") return direction === "rtl" ? "previous" : "next";
+		if (event.key === "ArrowLeft") return direction === "rtl" ? "next" : "previous";
+	}
+	return null;
+}
+function validateId(value) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError("VIZE_UI_COMPOSITE_NAVIGATION_ID: an item ID must be non-empty and contain no ASCII whitespace or controls");
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code <= 32 || code === 127) throw new TypeError("VIZE_UI_COMPOSITE_NAVIGATION_ID: an item ID must be non-empty and contain no ASCII whitespace or controls");
+	}
+	return value;
+}
+function validateOptions(options) {
+	if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError(`${optionDiagnostic}: options must be an object`);
+	const registry = options.registry;
+	if (!registry || typeof registry.getNavigationKey !== "function" || !registry.activeKey) throw new TypeError(`${optionDiagnostic}: registry must be a CollectionRegistry`);
+	const strategy = readStrategy(options.focusStrategy);
+	if (strategy === "active-descendant" && typeof options.getItemId !== "function") throw new TypeError(`${optionDiagnostic}: active-descendant requires a getItemId function`);
+	for (const name of [
+		"getItemId",
+		"onNavigate",
+		"scrollIntoView"
+	]) {
+		const callback = options[name];
+		if (callback !== void 0 && typeof callback !== "function") throw new TypeError(`${optionDiagnostic}: ${name} must be a function`);
+	}
+	readOrientation(options.orientation);
+	readDirection(options.direction);
+	readBoolean(options.loop, "loop");
+	readBoolean(options.isDisabled, "isDisabled");
+	readPageSize(options.pageSize);
+	if (strategy === "roving") readBoolean(options.preventScroll, "preventScroll");
+	if (options.typeahead !== void 0 && options.typeahead !== false && (!options.typeahead || typeof options.typeahead !== "object" || Array.isArray(options.typeahead))) throw new TypeError(`${optionDiagnostic}: typeahead must be false or an options object`);
+	return strategy;
+}
+const nonTextInputType = /^(?:button|checkbox|color|file|image|radio|range|reset|submit)$/iu;
+function isEditableDescendant(event) {
+	const path = typeof event.composedPath === "function" ? event.composedPath() : [event.target];
+	for (const candidate of path) {
+		if (candidate === event.currentTarget) break;
+		const target = candidate;
+		const name = target?.localName;
+		if (name === "input") {
+			if (!nonTextInputType.test(target?.type ?? "text")) return true;
+			continue;
+		}
+		if (name === "select" || name === "textarea" || target?.isContentEditable === true) return true;
+	}
+	return false;
+}
+function validateCommand(value) {
+	if (value !== "first" && value !== "last" && value !== "next" && value !== "page-next" && value !== "page-previous" && value !== "previous") throw new TypeError(`${optionDiagnostic}: navigation intent is invalid`);
+	return value;
+}
+//#endregion
+//#region src/composite-navigation-dom.ts
+function eventElement(value) {
+	const candidate = value;
+	return candidate?.nodeType === 1 && typeof candidate.getRootNode === "function" ? candidate : null;
+}
+function focusItem(element, preventScroll, errors) {
+	const focusable = element;
+	if (typeof focusable?.focus !== "function") {
+		errors.push(/* @__PURE__ */ new Error("VIZE_UI_COMPOSITE_NAVIGATION_FOCUS: active roving item is not focusable"));
+		return;
+	}
+	capture(errors, () => {
+		try {
+			focusable.focus?.({ preventScroll });
+		} catch {
+			focusable.focus?.();
+		}
+	});
+}
+function revealItem(item, custom, event, errors) {
+	if (custom) {
+		capture(errors, () => custom(item, event));
+		return;
+	}
+	const reveal = item.element?.scrollIntoView;
+	if (typeof reveal === "function") capture(errors, () => reveal.call(item.element, {
+		block: "nearest",
+		inline: "nearest"
+	}));
+}
+function tokenIncludes(value, token) {
+	return value?.split(/\s+/u).includes(token) === true;
+}
+function relatedElement(host, id) {
+	const root = host.getRootNode();
+	if (typeof root.getElementById === "function") return root.getElementById(id);
+	return host.ownerDocument.getElementById(id);
+}
+function validateActiveDescendant(host, item, id, errors) {
+	const element = item.element;
+	if (!host || !element) return;
+	if (element.id !== id || relatedElement(element, id) !== element) {
+		errors.push(/* @__PURE__ */ new Error("VIZE_UI_COMPOSITE_NAVIGATION_ID_RELATIONSHIP: active descendant ID must uniquely resolve to its registered element"));
+		return;
+	}
+	if (host.contains(element) || tokenIncludes(host.getAttribute("aria-owns"), id)) return;
+	const role = host.getAttribute("role");
+	if (role === "combobox" || role === "searchbox" || role === "textbox") {
+		const controlledIds = host.getAttribute("aria-controls")?.split(/\s+/u) ?? [];
+		for (const controlledId of controlledIds) {
+			const controlled = relatedElement(host, controlledId);
+			if (controlled?.contains(element) || tokenIncludes(controlled?.getAttribute("aria-owns") ?? null, id)) return;
+		}
+	}
+	errors.push(/* @__PURE__ */ new Error("VIZE_UI_COMPOSITE_NAVIGATION_RELATIONSHIP: active descendant must be contained, aria-owned, or controlled by a supported input role"));
+}
+//#endregion
+//#region src/composite-navigation.ts
+const disposedDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_DISPOSED";
+const itemDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_ITEM";
+const setupDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_SETUP";
+/** Create an SSR-safe roving-tabindex or active-descendant collection adapter. */
+function createCompositeNavigation(options) {
+	const strategy = validateOptions(options);
+	const registry = options.registry;
+	const itemHandlers = /* @__PURE__ */ new Map();
+	let container = null;
+	let disposed = false;
+	const assertActive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	const getItem = (key) => {
+		const item = registry.getItem(key);
+		if (!item) throw new Error(`${itemDiagnostic}: no item is registered for ${String(key)}`);
+		return item;
+	};
+	const effectiveKey = () => registry.activeKey.value ?? registry.navigableItems.value[0]?.key ?? null;
+	const itemId = (item) => {
+		const getId = options.getItemId;
+		const value = getId?.(item) ?? (item.element?.id || void 0);
+		if (value === void 0) {
+			if (strategy === "active-descendant") throw new Error("VIZE_UI_COMPOSITE_NAVIGATION_ID: active-descendant items require a stable ID");
+			return;
+		}
+		return validateId(value);
+	};
+	const synchronizeDom = (key, originalEvent, moveDomFocus, errors) => {
+		const item = getItem(key);
+		if (strategy === "active-descendant") validateActiveDescendant(container, item, itemId(item), errors);
+		const preventScroll = strategy === "roving" && readBoolean(options.preventScroll, "preventScroll");
+		if (strategy === "roving" && moveDomFocus) focusItem(item.element, preventScroll, errors);
+		if (options.scrollIntoView || strategy === "active-descendant" || moveDomFocus && preventScroll) revealItem(item, options.scrollIntoView, originalEvent, errors);
+	};
+	const notify = (key, previousKey, intent, originalEvent, errors) => {
+		const change = Object.freeze({
+			key,
+			previousKey,
+			intent,
+			originalEvent,
+			focusStrategy: strategy
+		});
+		capture(errors, () => options.onNavigate?.(change));
+	};
+	const commit = (mutate, intent, originalEvent, moveDomFocus) => {
+		const previousKey = registry.activeKey.value;
+		const errors = [];
+		capture(errors, mutate);
+		const key = registry.activeKey.value;
+		if (key !== null && key !== previousKey) {
+			capture(errors, () => synchronizeDom(key, originalEvent, moveDomFocus, errors));
+			notify(key, previousKey, intent, originalEvent, errors);
+		}
+		surfaceErrors(errors, "Composite navigation transition failed");
+		return key;
+	};
+	const pageTarget = (intent) => {
+		const direction = intent === "page-next" ? "next" : "previous";
+		let key = effectiveKey();
+		for (let index = 0; index < readPageSize(options.pageSize); index++) {
+			const next = registry.getNavigationKey(direction, {
+				fromKey: key,
+				loop: false
+			});
+			if (next === null || next === key) break;
+			key = next;
+		}
+		return key;
+	};
+	const navigate = (intent, originalEvent = null) => {
+		assertActive();
+		intent = validateCommand(intent);
+		if (readBoolean(options.isDisabled, "isDisabled")) return null;
+		if (intent === "page-next" || intent === "page-previous") {
+			const target = pageTarget(intent);
+			if (target === null) return null;
+			return commit(() => {
+				registry.setActiveKey(target);
+			}, intent, originalEvent, strategy === "roving");
+		}
+		return commit(() => {
+			registry.moveActive(intent, { loop: readBoolean(options.loop, "loop") });
+		}, intent, originalEvent, strategy === "roving");
+	};
+	const configuredTypeahead = options.typeahead;
+	const typeahead = configuredTypeahead && typeof configuredTypeahead === "object" ? createTypeahead({
+		...configuredTypeahead,
+		registry,
+		isDisabled: () => readBoolean(options.isDisabled, "isDisabled") || readBoolean(configuredTypeahead.isDisabled, "typeahead.isDisabled"),
+		onMatch(match) {
+			const errors = [];
+			if (match.key !== match.previousKey) {
+				capture(errors, () => synchronizeDom(match.key, match.originalEvent, strategy === "roving", errors));
+				notify(match.key, match.previousKey, "typeahead", match.originalEvent, errors);
+			}
+			capture(errors, () => configuredTypeahead.onMatch?.(match));
+			surfaceErrors(errors, "Composite typeahead transition failed");
+		}
+	}) : null;
+	const activateItem = (key, event) => {
+		if (disposed || readBoolean(options.isDisabled, "isDisabled")) return;
+		if (!registry.navigableItems.value.some((item) => item.key === key)) return;
+		commit(() => {
+			registry.setActiveKey(key);
+		}, event.type === "pointerdown" ? "pointer" : "focus", event, false);
+	};
+	const handlersFor = (key) => {
+		const cached = itemHandlers.get(key);
+		if (cached) return cached;
+		for (const cachedKey of itemHandlers.keys()) if (!registry.getItem(cachedKey)) itemHandlers.delete(cachedKey);
+		const handlers = Object.freeze({
+			onFocus: (event) => activateItem(key, event),
+			onPointerdown: (event) => activateItem(key, event)
+		});
+		itemHandlers.set(key, handlers);
+		return handlers;
+	};
+	const onFocus = (event) => {
+		if (disposed) return;
+		container = eventElement(event.currentTarget);
+		if (strategy !== "active-descendant" || event.target !== event.currentTarget || readBoolean(options.isDisabled, "isDisabled")) return;
+		const key = effectiveKey();
+		if (key !== null && registry.activeKey.value === null) commit(() => {
+			registry.setActiveKey(key);
+		}, "focus", event, false);
+	};
+	const onKeydown = (event) => {
+		if (disposed) return;
+		container = eventElement(event.currentTarget);
+		if (event.defaultPrevented || isEditableDescendant(event) || readBoolean(options.isDisabled, "isDisabled")) return;
+		const intent = keyIntent(event, readOrientation(options.orientation), readDirection(options.direction));
+		if (intent && registry.navigableItems.value.length > 0) {
+			event.preventDefault();
+			navigate(intent, event);
+			return;
+		}
+		typeahead?.typeaheadProps.onKeydown(event);
+	};
+	return Object.freeze({
+		activeKey: registry.activeKey,
+		typeahead,
+		getContainerProps: () => {
+			assertActive();
+			const key = effectiveKey();
+			const activeDescendant = strategy === "active-descendant" && key !== null ? itemId(getItem(key)) : void 0;
+			const props = {
+				onFocus,
+				onKeydown,
+				...strategy === "active-descendant" ? { tabindex: 0 } : {},
+				...activeDescendant !== void 0 ? { "aria-activedescendant": activeDescendant } : {}
+			};
+			return Object.freeze(props);
+		},
+		getItemProps: (key) => {
+			assertActive();
+			const item = getItem(key);
+			const handlers = handlersFor(key);
+			const id = itemId(item);
+			const props = {
+				...handlers,
+				...id ? { id } : {},
+				...strategy === "roving" ? { tabindex: effectiveKey() === key ? 0 : -1 } : {}
+			};
+			return Object.freeze(props);
+		},
+		navigate,
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			typeahead?.dispose();
+			itemHandlers.clear();
+			container = null;
+		}
+	});
+}
+/** Create a composite adapter disposed with the current Vue effect scope. */
+function useCompositeNavigation(options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createCompositeNavigation(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { useCompositeNavigation as n, createCompositeNavigation as t };

package/dist/composite-navigation.d.mts

@@ -0,0 +1,2 @@
+import { a as CompositeDirection, c as CompositeNavigationBaseOptions, d as CompositeNavigationController, f as CompositeNavigationIntent, h as RovingNavigationOptions, i as CompositeContainerProps, l as CompositeNavigationChange, m as CompositeOrientation, n as useCompositeNavigation, o as CompositeFocusStrategy, p as CompositeNavigationOptions, r as ActiveDescendantNavigationOptions, s as CompositeItemProps, t as createCompositeNavigation, u as CompositeNavigationCommand } from "./composite-navigation-QINW9GLy.mjs";
+export { type ActiveDescendantNavigationOptions, type CompositeContainerProps, type CompositeDirection, type CompositeFocusStrategy, type CompositeItemProps, type CompositeNavigationBaseOptions, type CompositeNavigationChange, type CompositeNavigationCommand, type CompositeNavigationController, type CompositeNavigationIntent, type CompositeNavigationOptions, type CompositeOrientation, type RovingNavigationOptions, createCompositeNavigation, useCompositeNavigation };

package/dist/composite-navigation.mjs

@@ -0,0 +1,2 @@
+import { n as useCompositeNavigation, t as createCompositeNavigation } from "./composite-navigation-Skx3LZsv.mjs";
+export { createCompositeNavigation, useCompositeNavigation };

package/dist/controllable-state.d.mts

@@ -1,2 +1,2 @@
-import { i as useControllableState, n as ControllableStateOptions, r as StateUpdate, t as ControllableState } from "./controllable-state-DXsYJ3yl.mjs";
+import { i as useControllableState, n as ControllableStateOptions, r as StateUpdate, t as ControllableState } from "./controllable-state-BtoxKahh.mjs";
 export { ControllableState, ControllableStateOptions, StateUpdate, useControllableState };

package/dist/dismissable-layer-4icKahVs.d.mts

@@ -0,0 +1,119 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/dismissable-layer-types.d.ts
+/** Stable pointing-device family captured from an outside pointer event. */
+type DismissableLayerPointerType = "mouse" | "pen" | "pointer" | "touch" | "virtual";
+/** Outside interaction that can request dismissal. */
+type DismissableLayerOutsideReason = "focus-outside" | "pointer-down-outside";
+/** User action that can request dismissal. */
+type DismissableLayerDismissReason = DismissableLayerOutsideReason | "escape-key";
+/** Preventable, immutable snapshot emitted before a pointer dismissal is committed. */
+interface DismissableLayerPointerDownOutsideEvent {
+  readonly type: "pointer-down-outside";
+  readonly reason: "pointer-down-outside";
+  readonly target: Element;
+  readonly originalEvent: PointerEvent | MouseEvent | TouchEvent;
+  readonly pointerType: DismissableLayerPointerType;
+  readonly x: number | null;
+  readonly y: number | null;
+  readonly altKey: boolean;
+  readonly ctrlKey: boolean;
+  readonly metaKey: boolean;
+  readonly shiftKey: boolean;
+  readonly defaultPrevented: boolean;
+  readonly preventDefault: () => void;
+}
+/** Preventable, immutable snapshot emitted before a focus dismissal is committed. */
+interface DismissableLayerFocusOutsideEvent {
+  readonly type: "focus-outside";
+  readonly reason: "focus-outside";
+  readonly target: Element;
+  readonly relatedTarget: Element | null;
+  readonly originalEvent: FocusEvent;
+  readonly defaultPrevented: boolean;
+  readonly preventDefault: () => void;
+}
+/** Preventable, immutable snapshot emitted before an Escape dismissal is committed. */
+interface DismissableLayerEscapeKeyDownEvent {
+  readonly type: "escape-key";
+  readonly reason: "escape-key";
+  readonly target: Element | null;
+  readonly originalEvent: KeyboardEvent;
+  readonly altKey: boolean;
+  readonly ctrlKey: boolean;
+  readonly metaKey: boolean;
+  readonly shiftKey: boolean;
+  readonly defaultPrevented: boolean;
+  readonly preventDefault: () => void;
+}
+/** Preventable outside interaction snapshot shared by pointer and focus callbacks. */
+type DismissableLayerInteractOutsideEvent = DismissableLayerFocusOutsideEvent | DismissableLayerPointerDownOutsideEvent;
+/** Immutable notification emitted after dismissal has not been prevented. */
+interface DismissableLayerDismissEvent {
+  readonly type: "dismiss";
+  readonly reason: DismissableLayerDismissReason;
+  readonly target: Element | null;
+  readonly originalEvent: Event;
+}
+/** Native props to merge onto the rendered layer root. */
+interface DismissableLayerProps {
+  readonly "data-vize-dismissable-layer": "";
+}
+/** Native props to merge onto optional rendered branch roots. */
+interface DismissableLayerBranchProps {
+  readonly "data-vize-dismissable-branch": "";
+}
+/** Reactive configuration for one dismissable overlay layer. */
+interface DismissableLayerOptions {
+  /** Primary layer root. It may be `null` during SSR and before mount. */
+  readonly root: MaybeRefOrGetter<Element | null | undefined>;
+  /** Portalled or exceptional roots that count as inside this layer. @default [] */
+  readonly branches?: MaybeRefOrGetter<readonly Element[] | null | undefined>;
+  /** Whether an activated layer participates in the document dismissal stack. @default true */
+  readonly enabled?: MaybeRefOrGetter<boolean | undefined>;
+  /** Whether outside pointer-down events can request dismissal. @default true */
+  readonly outsidePointerDown?: MaybeRefOrGetter<boolean | undefined>;
+  /** Whether outside focus movement can request dismissal. @default true */
+  readonly outsideFocus?: MaybeRefOrGetter<boolean | undefined>;
+  /** Whether non-composing Escape keydown can request dismissal. @default true */
+  readonly escapeKey?: MaybeRefOrGetter<boolean | undefined>;
+  /** Called before an outside pointer-down dismissal is committed. */
+  readonly onPointerDownOutside?: (event: DismissableLayerPointerDownOutsideEvent) => void;
+  /** Called before an outside focus dismissal is committed. */
+  readonly onFocusOutside?: (event: DismissableLayerFocusOutsideEvent) => void;
+  /** Called for every outside pointer or focus interaction before dismissal is committed. */
+  readonly onInteractOutside?: (event: DismissableLayerInteractOutsideEvent) => void;
+  /** Called before an Escape dismissal is committed. */
+  readonly onEscapeKeyDown?: (event: DismissableLayerEscapeKeyDownEvent) => void;
+  /** Called after a top-layer dismissal request has not been prevented. */
+  readonly onDismiss?: (event: DismissableLayerDismissEvent) => void;
+}
+/** Lifecycle, state, and root/branch props for one dismissable layer. */
+interface DismissableLayerController {
+  /** Whether this controller has been activated, independently of reactive enablement. */
+  readonly isActive: Readonly<ShallowRef<boolean>>;
+  /** Whether this layer is the enabled, connected, topmost owner in its document. */
+  readonly isTopLayer: Readonly<ShallowRef<boolean>>;
+  /** Stable native props to merge onto the rendered layer root. */
+  readonly layerProps: Readonly<DismissableLayerProps>;
+  /** Stable native props to merge onto optional rendered branch roots. */
+  readonly branchProps: Readonly<DismissableLayerBranchProps>;
+  /** Register an imperative branch and receive an idempotent release function. */
+  readonly registerBranch: (branch: Element) => () => void;
+  /** Join the document dismissal stack. Safe to call repeatedly. */
+  readonly activate: () => void;
+  /** Leave the document dismissal stack. */
+  readonly deactivate: () => void;
+  /** Re-read roots and options after imperative DOM movement. */
+  readonly refresh: () => void;
+  /** Permanently release reactive and document-level ownership. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/dismissable-layer.d.ts
+/** Create an SSR-safe, document-scoped dismissal layer for overlays and popups. */
+declare function createDismissableLayer(options: DismissableLayerOptions): DismissableLayerController;
+/** Create, mount-activate, and scope-dispose a dismissable overlay layer. */
+declare function useDismissableLayer(options: DismissableLayerOptions): DismissableLayerController;
+//#endregion
+export { DismissableLayerDismissEvent as a, DismissableLayerFocusOutsideEvent as c, DismissableLayerOutsideReason as d, DismissableLayerPointerDownOutsideEvent as f, DismissableLayerController as i, DismissableLayerInteractOutsideEvent as l, DismissableLayerProps as m, useDismissableLayer as n, DismissableLayerDismissReason as o, DismissableLayerPointerType as p, DismissableLayerBranchProps as r, DismissableLayerEscapeKeyDownEvent as s, createDismissableLayer as t, DismissableLayerOptions as u };