keyborg 2.325.0-canary.0 → 3.0.0

package/dist/index.cjs

@@ -0,0 +1,347 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/dom.mts
+/*!
+* Copyright (c) Microsoft Corporation. All rights reserved.
+* Licensed under the MIT License.
+*/
+const addEventListener = (target, type, handler) => {
+	target.addEventListener(type, handler, true);
+};
+const removeEventListener = (target, type, handler) => {
+	target.removeEventListener(type, handler, true);
+};
+//#endregion
+//#region src/FocusEvent.mts
+/*!
+* Copyright (c) Microsoft Corporation. All rights reserved.
+* Licensed under the MIT License.
+*/
+const KEYBORG_FOCUSIN = "keyborg:focusin";
+const KEYBORG_FOCUSOUT = "keyborg:focusout";
+const FOCUS_IN_HANDLER = 0;
+const FOCUS_OUT_HANDLER = 1;
+const SHADOW_TARGETS = 2;
+const LAST_FOCUSED_PROGRAMMATICALLY = 3;
+/**
+* Guarantees that the native `focus` will be used
+*/
+function nativeFocus(element) {
+	const focus = element.focus;
+	if (focus.__keyborgNativeFocus) focus.__keyborgNativeFocus.call(element);
+	else element.focus();
+}
+/**
+* Overrides the native `focus` and setups the keyborg focus event
+*/
+function setupFocusEvent(win) {
+	const kwin = win;
+	const doc = kwin.document;
+	const proto = kwin.HTMLElement.prototype;
+	const origFocus = proto.focus;
+	if (origFocus.__keyborgNativeFocus) return;
+	proto.focus = focus;
+	const shadowTargets = /* @__PURE__ */ new Set();
+	const focusOutHandler = (e) => {
+		const target = e.target;
+		if (!target) return;
+		const event = new CustomEvent(KEYBORG_FOCUSOUT, {
+			cancelable: true,
+			bubbles: true,
+			composed: true,
+			detail: { originalEvent: e }
+		});
+		target.dispatchEvent(event);
+	};
+	const focusInHandler = (e) => {
+		const target = e.target;
+		if (!target) return;
+		let node = e.composedPath()[0];
+		const currentShadows = /* @__PURE__ */ new Set();
+		while (node) if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+			currentShadows.add(node);
+			node = node.host;
+		} else node = node.parentNode;
+		for (const shadowRootWeakRef of shadowTargets) {
+			const shadowRoot = shadowRootWeakRef.deref();
+			if (!shadowRoot || !currentShadows.has(shadowRoot)) {
+				shadowTargets.delete(shadowRootWeakRef);
+				if (shadowRoot) {
+					removeEventListener(shadowRoot, "focusin", focusInHandler);
+					removeEventListener(shadowRoot, "focusout", focusOutHandler);
+				}
+			}
+		}
+		onFocusIn(target, e.relatedTarget || void 0);
+	};
+	const onFocusIn = (target, relatedTarget, originalEvent) => {
+		const shadowRoot = target.shadowRoot;
+		if (shadowRoot) {
+			/**
+			* https://bugs.chromium.org/p/chromium/issues/detail?id=1512028
+			* focusin events don't bubble up through an open shadow root once focus is inside
+			* once focus moves into a shadow root - we drop the same focusin handler there
+			* keyborg's custom event will still bubble up since it is composed
+			* event handlers should be cleaned up once focus leaves the shadow root.
+			*
+			* When a focusin event is dispatched from a shadow root, its target is the shadow root parent.
+			* Each shadow root encounter requires a new capture listener.
+			* Why capture? - we want to follow the focus event in order or descending nested shadow roots
+			* When there are no more shadow root targets - dispatch the keyborg:focusin event
+			*
+			* 1. no focus event
+			* > document - capture listener ✅
+			*   > shadow root 1
+			*     > shadow root 2
+			*       > shadow root 3
+			*         > focused element
+			*
+			* 2. focus event received by document listener
+			* > document - capture listener ✅ (focus event here)
+			*   > shadow root 1 - capture listener ✅
+			*     > shadow root 2
+			*       > shadow root 3
+			*         > focused element
+			*
+			* 3. focus event received by root l1 listener
+			* > document - capture listener ✅
+			*   > shadow root 1 - capture listener ✅ (focus event here)
+			*     > shadow root 2 - capture listener ✅
+			*       > shadow root 3
+			*         > focused element
+			*
+			* 4. focus event received by root l2 listener
+			* > document - capture listener ✅
+			*   > shadow root 1 - capture listener ✅
+			*     > shadow root 2 - capture listener ✅ (focus event here)
+			*       > shadow root 3 - capture listener ✅
+			*         > focused element
+			*
+			* 5. focus event received by root l3 listener, no more shadow root targets
+			* > document - capture listener ✅
+			*   > shadow root 1 - capture listener ✅
+			*     > shadow root 2 - capture listener ✅
+			*       > shadow root 3 - capture listener ✅ (focus event here)
+			*         > focused element ✅ (no shadow root - dispatch keyborg event)
+			*/
+			for (const shadowRootWeakRef of shadowTargets) if (shadowRootWeakRef.deref() === shadowRoot) return;
+			addEventListener(shadowRoot, "focusin", focusInHandler);
+			addEventListener(shadowRoot, "focusout", focusOutHandler);
+			shadowTargets.add(new WeakRef(shadowRoot));
+			return;
+		}
+		const details = {
+			relatedTarget,
+			originalEvent
+		};
+		const event = new CustomEvent(KEYBORG_FOCUSIN, {
+			cancelable: true,
+			bubbles: true,
+			composed: true,
+			detail: details
+		});
+		details.isFocusedProgrammatically = target === data[LAST_FOCUSED_PROGRAMMATICALLY]?.deref();
+		data[LAST_FOCUSED_PROGRAMMATICALLY] = void 0;
+		target.dispatchEvent(event);
+	};
+	const data = [
+		focusInHandler,
+		focusOutHandler,
+		shadowTargets
+	];
+	kwin.__keyborgData = data;
+	addEventListener(doc, "focusin", focusInHandler);
+	addEventListener(doc, "focusout", focusOutHandler);
+	function focus() {
+		const d = kwin.__keyborgData;
+		if (d) d[LAST_FOCUSED_PROGRAMMATICALLY] = new WeakRef(this);
+		return origFocus.apply(this, arguments);
+	}
+	let activeElement = doc.activeElement;
+	while (activeElement && activeElement.shadowRoot) {
+		onFocusIn(activeElement);
+		activeElement = activeElement.shadowRoot.activeElement;
+	}
+	focus.__keyborgNativeFocus = origFocus;
+}
+/**
+* Removes keyborg event listeners and custom focus override
+* @param win The window that stores keyborg focus events
+*/
+function disposeFocusEvent(win) {
+	const kwin = win;
+	const proto = kwin.HTMLElement.prototype;
+	const origFocus = proto.focus.__keyborgNativeFocus;
+	const data = kwin.__keyborgData;
+	if (data) {
+		const doc = kwin.document;
+		removeEventListener(doc, "focusin", data[FOCUS_IN_HANDLER]);
+		removeEventListener(doc, "focusout", data[FOCUS_OUT_HANDLER]);
+		for (const shadowRootWeakRef of data[SHADOW_TARGETS]) {
+			const shadowRoot = shadowRootWeakRef.deref();
+			if (shadowRoot) {
+				removeEventListener(shadowRoot, "focusin", data[FOCUS_IN_HANDLER]);
+				removeEventListener(shadowRoot, "focusout", data[FOCUS_OUT_HANDLER]);
+			}
+		}
+		data[SHADOW_TARGETS].clear();
+		delete kwin.__keyborgData;
+	}
+	if (origFocus) proto.focus = origFocus;
+}
+/**
+* @param win The window that stores keyborg focus events
+* @returns The last element focused with element.focus()
+*/
+function getLastFocusedProgrammatically(win) {
+	const data = win.__keyborgData;
+	return data ? data[LAST_FOCUSED_PROGRAMMATICALLY]?.deref() || null : void 0;
+}
+//#endregion
+//#region src/Keyborg.mts
+/*!
+* Copyright (c) Microsoft Corporation. All rights reserved.
+* Licensed under the MIT License.
+*/
+let _lastId = 0;
+function createKeyborgCore(targetWindow) {
+	let currentTargetWindow = targetWindow;
+	let isNavigating = false;
+	let isMouseOrTouchUsedTimer;
+	const broadcast = () => {
+		const refs = currentTargetWindow?.__keyborg?.refs;
+		if (refs) for (const id of Object.keys(refs)) refs[id]._cb.forEach((cb) => cb(isNavigating));
+	};
+	const setNavigating = (val) => {
+		if (isNavigating !== val) {
+			isNavigating = val;
+			broadcast();
+		}
+	};
+	const shouldTrigger = (e) => {
+		if (e.key === "Tab") return true;
+		const active = currentTargetWindow?.document.activeElement;
+		return !(active && (active.tagName === "INPUT" || active.tagName === "TEXTAREA" || active.isContentEditable));
+	};
+	const onFocusIn = (e) => {
+		if (isMouseOrTouchUsedTimer) return;
+		if (isNavigating) return;
+		const details = e.detail;
+		if (!details.relatedTarget) return;
+		if (details.isFocusedProgrammatically || details.isFocusedProgrammatically === void 0) return;
+		setNavigating(true);
+	};
+	const onMouseOrTouch = () => {
+		if (currentTargetWindow) {
+			if (isMouseOrTouchUsedTimer) currentTargetWindow.clearTimeout(isMouseOrTouchUsedTimer);
+			isMouseOrTouchUsedTimer = currentTargetWindow.setTimeout(() => {
+				isMouseOrTouchUsedTimer = void 0;
+			}, 1e3);
+		}
+		setNavigating(false);
+	};
+	const onMouseDown = (e) => {
+		if (e.buttons === 0 || e.clientX === 0 && e.clientY === 0 && e.screenX === 0 && e.screenY === 0) return;
+		onMouseOrTouch();
+	};
+	const onKeyDown = (e) => {
+		if (!isNavigating && shouldTrigger(e)) setNavigating(true);
+	};
+	const targetDocument = targetWindow.document;
+	addEventListener(targetDocument, KEYBORG_FOCUSIN, onFocusIn);
+	addEventListener(targetDocument, "mousedown", onMouseDown);
+	addEventListener(targetWindow, "keydown", onKeyDown);
+	addEventListener(targetDocument, "touchstart", onMouseOrTouch);
+	addEventListener(targetDocument, "touchend", onMouseOrTouch);
+	addEventListener(targetDocument, "touchcancel", onMouseOrTouch);
+	setupFocusEvent(targetWindow);
+	const dispose = () => {
+		if (!currentTargetWindow) return;
+		if (isMouseOrTouchUsedTimer) {
+			currentTargetWindow.clearTimeout(isMouseOrTouchUsedTimer);
+			isMouseOrTouchUsedTimer = void 0;
+		}
+		disposeFocusEvent(currentTargetWindow);
+		const targetDocument = currentTargetWindow.document;
+		removeEventListener(targetDocument, KEYBORG_FOCUSIN, onFocusIn);
+		removeEventListener(targetDocument, "mousedown", onMouseDown);
+		removeEventListener(currentTargetWindow, "keydown", onKeyDown);
+		removeEventListener(targetDocument, "touchstart", onMouseOrTouch);
+		removeEventListener(targetDocument, "touchend", onMouseOrTouch);
+		removeEventListener(targetDocument, "touchcancel", onMouseOrTouch);
+		currentTargetWindow = void 0;
+	};
+	return {
+		dispose,
+		get isNavigatingWithKeyboard() {
+			return isNavigating;
+		},
+		set isNavigatingWithKeyboard(val) {
+			setNavigating(val);
+		}
+	};
+}
+function createKeyborg(win) {
+	const kwin = win;
+	const id = "k" + ++_lastId;
+	let localWin = kwin;
+	let core;
+	const callbacks = [];
+	const existing = kwin.__keyborg;
+	if (existing) core = existing.core;
+	else core = createKeyborgCore(kwin);
+	const instance = {
+		isNavigatingWithKeyboard() {
+			return !!core?.isNavigatingWithKeyboard;
+		},
+		subscribe(callback) {
+			callbacks.push(callback);
+		},
+		unsubscribe(callback) {
+			const index = callbacks.indexOf(callback);
+			if (index >= 0) callbacks.splice(index, 1);
+		},
+		setVal(val) {
+			if (core) core.isNavigatingWithKeyboard = val;
+		},
+		_cb: callbacks,
+		dispose() {
+			const wkb = localWin?.__keyborg;
+			if (wkb?.refs[id]) {
+				delete wkb.refs[id];
+				if (Object.keys(wkb.refs).length === 0) {
+					wkb.core.dispose();
+					delete localWin.__keyborg;
+				}
+			} else if (process.env.NODE_ENV !== "production") console.error(`Keyborg instance ${id} is being disposed incorrectly.`);
+			callbacks.length = 0;
+			core = void 0;
+			localWin = void 0;
+		}
+	};
+	if (existing) existing.refs[id] = instance;
+	else kwin.__keyborg = {
+		core,
+		refs: { [id]: instance }
+	};
+	return instance;
+}
+function disposeKeyborg(instance) {
+	instance.dispose();
+}
+//#endregion
+//#region src/index.mts
+/*!
+* Copyright (c) Microsoft Corporation. All rights reserved.
+* Licensed under the MIT License.
+*/
+const version = "3.0.0";
+//#endregion
+exports.KEYBORG_FOCUSIN = KEYBORG_FOCUSIN;
+exports.KEYBORG_FOCUSOUT = KEYBORG_FOCUSOUT;
+exports.createKeyborg = createKeyborg;
+exports.disposeKeyborg = disposeKeyborg;
+exports.getLastFocusedProgrammatically = getLastFocusedProgrammatically;
+exports.nativeFocus = nativeFocus;
+exports.version = version;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/dom.mts","../src/FocusEvent.mts","../src/Keyborg.mts","../src/index.mts"],"sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// All keyborg listeners use the capture phase; centralizing the calls lets the\n// minifier collapse the repeated DOM method names into a single short-named\n// import binding.\nexport const addEventListener = (\n  target: EventTarget,\n  type: string,\n  handler: EventListener,\n): void => {\n  target.addEventListener(type, handler, true);\n};\n\nexport const removeEventListener = (\n  target: EventTarget,\n  type: string,\n  handler: EventListener,\n): void => {\n  target.removeEventListener(type, handler, true);\n};\n","/*!\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { addEventListener, removeEventListener } from \"./dom.mts\";\n\nexport const KEYBORG_FOCUSIN = \"keyborg:focusin\";\nexport const KEYBORG_FOCUSOUT = \"keyborg:focusout\";\n\ninterface KeyborgFocus {\n  /**\n   * This is the native `focus` function that is retained so that it can be restored when keyborg is disposed\n   */\n  __keyborgNativeFocus?: (options?: FocusOptions | undefined) => void;\n}\n\n// Internal data stored on `window.__keyborgData` as a tuple. Nothing outside\n// this module reads these slots, so a tuple drops the property-name strings\n// from the minified output — the indexes below inline as numeric literals.\nconst FOCUS_IN_HANDLER = 0;\nconst FOCUS_OUT_HANDLER = 1;\nconst SHADOW_TARGETS = 2;\nconst LAST_FOCUSED_PROGRAMMATICALLY = 3;\ntype KeyborgFocusEventData = [\n  (e: FocusEvent) => void,\n  (e: FocusEvent) => void,\n  Set<WeakRef<ShadowRoot>>,\n  WeakRef<HTMLElement>?,\n];\n\n/**\n * Extends the global window with keyborg focus event data\n */\ninterface WindowWithKeyborgFocusEvent extends Window {\n  HTMLElement: typeof HTMLElement;\n  __keyborgData?: KeyborgFocusEventData;\n}\n\nexport interface KeyborgFocusInEventDetails {\n  relatedTarget?: HTMLElement;\n  isFocusedProgrammatically?: boolean;\n  originalEvent?: FocusEvent;\n}\n\nexport type KeyborgFocusInEvent = CustomEvent<KeyborgFocusInEventDetails>;\n\nexport interface KeyborgFocusOutEventDetails {\n  originalEvent: FocusEvent;\n}\n\nexport type KeyborgFocusOutEvent = CustomEvent<KeyborgFocusOutEventDetails>;\n\n/**\n * Guarantees that the native `focus` will be used\n */\nexport function nativeFocus(element: HTMLElement): void {\n  const focus = element.focus as KeyborgFocus;\n\n  if (focus.__keyborgNativeFocus) {\n    focus.__keyborgNativeFocus.call(element);\n  } else {\n    element.focus();\n  }\n}\n\n/**\n * Overrides the native `focus` and setups the keyborg focus event\n */\nexport function setupFocusEvent(win: Window): void {\n  const kwin = win as WindowWithKeyborgFocusEvent;\n  const doc = kwin.document;\n  const proto = kwin.HTMLElement.prototype;\n  const origFocus = proto.focus;\n\n  if ((origFocus as KeyborgFocus).__keyborgNativeFocus) {\n    // Already set up.\n    return;\n  }\n\n  proto.focus = focus;\n\n  const shadowTargets: Set<WeakRef<ShadowRoot>> = new Set();\n\n  const focusOutHandler = (e: FocusEvent) => {\n    const target = e.target as HTMLElement;\n\n    if (!target) {\n      return;\n    }\n\n    const event: KeyborgFocusOutEvent = new CustomEvent(KEYBORG_FOCUSOUT, {\n      cancelable: true,\n      bubbles: true,\n      // Allows the event to bubble past an open shadow root\n      composed: true,\n      detail: {\n        originalEvent: e,\n      },\n    });\n\n    target.dispatchEvent(event);\n  };\n\n  const focusInHandler = (e: FocusEvent) => {\n    const target = e.target as HTMLElement;\n\n    if (!target) {\n      return;\n    }\n\n    let node: Node | null | undefined = e.composedPath()[0] as\n      | Node\n      | null\n      | undefined;\n\n    const currentShadows: Set<ShadowRoot> = new Set();\n\n    while (node) {\n      if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n        currentShadows.add(node as ShadowRoot);\n        node = (node as ShadowRoot).host;\n      } else {\n        node = node.parentNode;\n      }\n    }\n\n    for (const shadowRootWeakRef of shadowTargets) {\n      const shadowRoot = shadowRootWeakRef.deref();\n\n      if (!shadowRoot || !currentShadows.has(shadowRoot)) {\n        shadowTargets.delete(shadowRootWeakRef);\n\n        if (shadowRoot) {\n          removeEventListener(shadowRoot, \"focusin\", focusInHandler);\n          removeEventListener(shadowRoot, \"focusout\", focusOutHandler);\n        }\n      }\n    }\n\n    onFocusIn(target, (e.relatedTarget as HTMLElement | null) || undefined);\n  };\n\n  const onFocusIn = (\n    target: Element,\n    relatedTarget?: HTMLElement,\n    originalEvent?: FocusEvent,\n  ) => {\n    const shadowRoot = target.shadowRoot;\n\n    if (shadowRoot) {\n      /**\n       * https://bugs.chromium.org/p/chromium/issues/detail?id=1512028\n       * focusin events don't bubble up through an open shadow root once focus is inside\n       * once focus moves into a shadow root - we drop the same focusin handler there\n       * keyborg's custom event will still bubble up since it is composed\n       * event handlers should be cleaned up once focus leaves the shadow root.\n       *\n       * When a focusin event is dispatched from a shadow root, its target is the shadow root parent.\n       * Each shadow root encounter requires a new capture listener.\n       * Why capture? - we want to follow the focus event in order or descending nested shadow roots\n       * When there are no more shadow root targets - dispatch the keyborg:focusin event\n       *\n       * 1. no focus event\n       * > document - capture listener ✅\n       *   > shadow root 1\n       *     > shadow root 2\n       *       > shadow root 3\n       *         > focused element\n       *\n       * 2. focus event received by document listener\n       * > document - capture listener ✅ (focus event here)\n       *   > shadow root 1 - capture listener ✅\n       *     > shadow root 2\n       *       > shadow root 3\n       *         > focused element\n       *\n       * 3. focus event received by root l1 listener\n       * > document - capture listener ✅\n       *   > shadow root 1 - capture listener ✅ (focus event here)\n       *     > shadow root 2 - capture listener ✅\n       *       > shadow root 3\n       *         > focused element\n       *\n       * 4. focus event received by root l2 listener\n       * > document - capture listener ✅\n       *   > shadow root 1 - capture listener ✅\n       *     > shadow root 2 - capture listener ✅ (focus event here)\n       *       > shadow root 3 - capture listener ✅\n       *         > focused element\n       *\n       * 5. focus event received by root l3 listener, no more shadow root targets\n       * > document - capture listener ✅\n       *   > shadow root 1 - capture listener ✅\n       *     > shadow root 2 - capture listener ✅\n       *       > shadow root 3 - capture listener ✅ (focus event here)\n       *         > focused element ✅ (no shadow root - dispatch keyborg event)\n       */\n\n      for (const shadowRootWeakRef of shadowTargets) {\n        if (shadowRootWeakRef.deref() === shadowRoot) {\n          return;\n        }\n      }\n\n      addEventListener(shadowRoot, \"focusin\", focusInHandler);\n      addEventListener(shadowRoot, \"focusout\", focusOutHandler);\n\n      shadowTargets.add(new WeakRef(shadowRoot));\n\n      return;\n    }\n\n    const details: KeyborgFocusInEventDetails = {\n      relatedTarget,\n      originalEvent,\n    };\n\n    const event: KeyborgFocusInEvent = new CustomEvent(KEYBORG_FOCUSIN, {\n      cancelable: true,\n      bubbles: true,\n      // Allows the event to bubble past an open shadow root\n      composed: true,\n      detail: details,\n    });\n\n    details.isFocusedProgrammatically =\n      target === data[LAST_FOCUSED_PROGRAMMATICALLY]?.deref();\n\n    data[LAST_FOCUSED_PROGRAMMATICALLY] = undefined;\n\n    target.dispatchEvent(event);\n  };\n\n  const data: KeyborgFocusEventData = [\n    focusInHandler,\n    focusOutHandler,\n    shadowTargets,\n  ];\n  kwin.__keyborgData = data;\n\n  addEventListener(doc, \"focusin\", focusInHandler);\n  addEventListener(doc, \"focusout\", focusOutHandler);\n\n  function focus(this: HTMLElement) {\n    const d = (kwin as WindowWithKeyborgFocusEvent).__keyborgData;\n\n    if (d) {\n      d[LAST_FOCUSED_PROGRAMMATICALLY] = new WeakRef(this);\n    }\n\n    // eslint-disable-next-line prefer-rest-params\n    return origFocus.apply(this, arguments);\n  }\n\n  let activeElement = doc.activeElement as Element | null;\n\n  // If keyborg is created with the focus inside shadow root, we need\n  // to go through the shadows up to make sure all relevant shadows\n  // have focus handlers attached.\n  while (activeElement && activeElement.shadowRoot) {\n    onFocusIn(activeElement);\n    activeElement = activeElement.shadowRoot.activeElement;\n  }\n\n  (focus as KeyborgFocus).__keyborgNativeFocus = origFocus;\n}\n\n/**\n * Removes keyborg event listeners and custom focus override\n * @param win The window that stores keyborg focus events\n */\nexport function disposeFocusEvent(win: Window): void {\n  const kwin = win as WindowWithKeyborgFocusEvent;\n  const proto = kwin.HTMLElement.prototype;\n  const origFocus = (proto.focus as KeyborgFocus).__keyborgNativeFocus;\n  const data = kwin.__keyborgData;\n\n  if (data) {\n    const doc = kwin.document;\n    removeEventListener(doc, \"focusin\", data[FOCUS_IN_HANDLER]);\n    removeEventListener(doc, \"focusout\", data[FOCUS_OUT_HANDLER]);\n\n    for (const shadowRootWeakRef of data[SHADOW_TARGETS]) {\n      const shadowRoot = shadowRootWeakRef.deref();\n\n      if (shadowRoot) {\n        removeEventListener(shadowRoot, \"focusin\", data[FOCUS_IN_HANDLER]);\n        removeEventListener(shadowRoot, \"focusout\", data[FOCUS_OUT_HANDLER]);\n      }\n    }\n\n    data[SHADOW_TARGETS].clear();\n\n    delete kwin.__keyborgData;\n  }\n\n  if (origFocus) {\n    proto.focus = origFocus;\n  }\n}\n\n/**\n * @param win The window that stores keyborg focus events\n * @returns The last element focused with element.focus()\n */\nexport function getLastFocusedProgrammatically(\n  win: Window,\n): HTMLElement | null | undefined {\n  const data = (win as WindowWithKeyborgFocusEvent).__keyborgData;\n\n  return data\n    ? data[LAST_FOCUSED_PROGRAMMATICALLY]?.deref() || null\n    : undefined;\n}\n","/*!\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { addEventListener, removeEventListener } from \"./dom.mts\";\nimport {\n  disposeFocusEvent,\n  KeyborgFocusInEvent,\n  KEYBORG_FOCUSIN,\n  setupFocusEvent,\n} from \"./FocusEvent.mts\";\n\ninterface WindowWithKeyborg extends Window {\n  __keyborg?: {\n    core: KeyborgCoreHandle;\n    refs: { [id: string]: Keyborg };\n  };\n}\n\nlet _lastId = 0;\n\nexport type KeyborgCallback = (isNavigatingWithKeyboard: boolean) => void;\n\n/**\n * Internal handle for the per-window core state. Not part of the public API.\n *\n * Shape is part of the `__keyborg.core` slot contract: when multiple keyborg\n * majors share the same window, the second loader reads `core` set by the\n * first. Keep `isNavigatingWithKeyboard` as a writable property accessor and\n * `dispose()` as a method so older majors can still read/write state without\n * TypeError. Changes here are breaking for that interop.\n */\ninterface KeyborgCoreHandle {\n  isNavigatingWithKeyboard: boolean;\n  dispose(): void;\n}\n\n/**\n * Used to determine the keyboard navigation state.\n */\nexport interface Keyborg {\n  /**\n   * @returns Whether the user is navigating with keyboard\n   */\n  isNavigatingWithKeyboard(): boolean;\n  /**\n   * @param callback - Called when the keyboard navigation state changes\n   */\n  subscribe(callback: KeyborgCallback): void;\n  /**\n   * @param callback - Registered with subscribe\n   */\n  unsubscribe(callback: KeyborgCallback): void;\n  /**\n   * Manually set the keyboard navigation state\n   */\n  setVal(isNavigatingWithKeyboard: boolean): void;\n}\n\n// Augments the public Keyborg with internal members that also form the\n// `__keyborg.refs` slot wire protocol. The shape — `_cb` callback array and\n// `dispose()` method — matches keyborg <= 2.6.0's `Keyborg` class so that\n// mixed-version environments can broadcast and tear down each other's\n// instances without TypeError. Changes here are breaking for that interop.\ninterface KeyborgInternal extends Keyborg {\n  _cb: KeyborgCallback[];\n  dispose(): void;\n}\n\nfunction createKeyborgCore(targetWindow: WindowWithKeyborg): KeyborgCoreHandle {\n  let currentTargetWindow: WindowWithKeyborg | undefined = targetWindow;\n  let isNavigating = false;\n  let isMouseOrTouchUsedTimer: number | undefined;\n\n  const broadcast = (): void => {\n    const refs = currentTargetWindow?.__keyborg?.refs;\n    if (refs) {\n      for (const id of Object.keys(refs)) {\n        (refs[id] as KeyborgInternal)._cb.forEach((cb) => cb(isNavigating));\n      }\n    }\n  };\n\n  const setNavigating = (val: boolean): void => {\n    if (isNavigating !== val) {\n      isNavigating = val;\n      broadcast();\n    }\n  };\n\n  const shouldTrigger = (e: KeyboardEvent): boolean => {\n    // TODO Some rich text fields can allow Tab key for indentation so it\n    // doesn't need to be a navigation key. If there is a bug regarding that\n    // we should revisit.\n    if (e.key === \"Tab\") {\n      return true;\n    }\n    const active = currentTargetWindow?.document\n      .activeElement as HTMLElement | null;\n    const isEditable =\n      active &&\n      (active.tagName === \"INPUT\" ||\n        active.tagName === \"TEXTAREA\" ||\n        active.isContentEditable);\n    return !isEditable;\n  };\n\n  const onFocusIn = (e: KeyborgFocusInEvent): void => {\n    // When the focus is moved not programmatically and without keydown events,\n    // it is likely that the focus is moved by screen reader (as it might\n    // swallow the events when the screen reader shortcuts are used). The\n    // screen reader usage is keyboard navigation.\n    if (isMouseOrTouchUsedTimer) {\n      return;\n    }\n    if (isNavigating) {\n      return;\n    }\n    const details = e.detail;\n    if (!details.relatedTarget) {\n      return;\n    }\n    if (\n      details.isFocusedProgrammatically ||\n      details.isFocusedProgrammatically === undefined\n    ) {\n      return;\n    }\n    setNavigating(true);\n  };\n\n  const onMouseOrTouch = (): void => {\n    if (currentTargetWindow) {\n      if (isMouseOrTouchUsedTimer) {\n        currentTargetWindow.clearTimeout(isMouseOrTouchUsedTimer);\n      }\n      isMouseOrTouchUsedTimer = currentTargetWindow.setTimeout(() => {\n        isMouseOrTouchUsedTimer = undefined;\n      }, 1000);\n    }\n    setNavigating(false);\n  };\n\n  const onMouseDown = (e: MouseEvent): void => {\n    if (\n      e.buttons === 0 ||\n      (e.clientX === 0 && e.clientY === 0 && e.screenX === 0 && e.screenY === 0)\n    ) {\n      // This is most likely an event triggered by the screen reader to\n      // perform an action on an element, do not dismiss the keyboard\n      // navigation mode.\n      return;\n    }\n    onMouseOrTouch();\n  };\n\n  const onKeyDown = (e: KeyboardEvent): void => {\n    if (!isNavigating && shouldTrigger(e)) {\n      setNavigating(true);\n    }\n  };\n\n  const targetDocument = targetWindow.document;\n  addEventListener(targetDocument, KEYBORG_FOCUSIN, onFocusIn as EventListener);\n  addEventListener(targetDocument, \"mousedown\", onMouseDown as EventListener);\n  addEventListener(targetWindow, \"keydown\", onKeyDown as EventListener);\n  addEventListener(targetDocument, \"touchstart\", onMouseOrTouch);\n  addEventListener(targetDocument, \"touchend\", onMouseOrTouch);\n  addEventListener(targetDocument, \"touchcancel\", onMouseOrTouch);\n\n  setupFocusEvent(targetWindow);\n\n  const dispose = (): void => {\n    if (!currentTargetWindow) {\n      return;\n    }\n    if (isMouseOrTouchUsedTimer) {\n      currentTargetWindow.clearTimeout(isMouseOrTouchUsedTimer);\n      isMouseOrTouchUsedTimer = undefined;\n    }\n    disposeFocusEvent(currentTargetWindow);\n    const targetDocument = currentTargetWindow.document;\n    removeEventListener(\n      targetDocument,\n      KEYBORG_FOCUSIN,\n      onFocusIn as EventListener,\n    );\n    removeEventListener(\n      targetDocument,\n      \"mousedown\",\n      onMouseDown as EventListener,\n    );\n    removeEventListener(\n      currentTargetWindow,\n      \"keydown\",\n      onKeyDown as EventListener,\n    );\n    removeEventListener(targetDocument, \"touchstart\", onMouseOrTouch);\n    removeEventListener(targetDocument, \"touchend\", onMouseOrTouch);\n    removeEventListener(targetDocument, \"touchcancel\", onMouseOrTouch);\n    currentTargetWindow = undefined;\n  };\n\n  return {\n    dispose,\n    get isNavigatingWithKeyboard() {\n      return isNavigating;\n    },\n    set isNavigatingWithKeyboard(val: boolean) {\n      setNavigating(val);\n    },\n  };\n}\n\nexport function createKeyborg(win: Window): Keyborg {\n  const kwin = win as WindowWithKeyborg;\n  const id = \"k\" + ++_lastId;\n  let localWin: WindowWithKeyborg | undefined = kwin;\n  let core: KeyborgCoreHandle | undefined;\n  // `callbacks` is exposed as `instance._cb` to satisfy the slot wire\n  // protocol. We mutate the array in place (push/splice/length=0) so the\n  // reference stays stable for foreign-version broadcasts.\n  const callbacks: KeyborgCallback[] = [];\n\n  const existing = kwin.__keyborg;\n  if (existing) {\n    core = existing.core;\n  } else {\n    core = createKeyborgCore(kwin);\n  }\n\n  const instance: KeyborgInternal = {\n    isNavigatingWithKeyboard() {\n      return !!core?.isNavigatingWithKeyboard;\n    },\n    subscribe(callback) {\n      callbacks.push(callback);\n    },\n    unsubscribe(callback) {\n      const index = callbacks.indexOf(callback);\n      if (index >= 0) {\n        callbacks.splice(index, 1);\n      }\n    },\n    setVal(val) {\n      if (core) {\n        core.isNavigatingWithKeyboard = val;\n      }\n    },\n    _cb: callbacks,\n    dispose() {\n      const wkb = localWin?.__keyborg;\n      if (wkb?.refs[id]) {\n        delete wkb.refs[id];\n        if (Object.keys(wkb.refs).length === 0) {\n          wkb.core.dispose();\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          delete localWin!.__keyborg;\n        }\n      } else if (process.env.NODE_ENV !== \"production\") {\n        console.error(`Keyborg instance ${id} is being disposed incorrectly.`);\n      }\n      callbacks.length = 0;\n      core = undefined;\n      localWin = undefined;\n    },\n  };\n\n  if (existing) {\n    existing.refs[id] = instance;\n  } else {\n    kwin.__keyborg = {\n      core,\n      refs: { [id]: instance },\n    };\n  }\n\n  return instance;\n}\n\nexport function disposeKeyborg(instance: Keyborg): void {\n  (instance as KeyborgInternal).dispose();\n}\n","/*!\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport type { Keyborg, KeyborgCallback } from \"./Keyborg.mts\";\nexport { createKeyborg, disposeKeyborg } from \"./Keyborg.mts\";\n\nexport type {\n  KeyborgFocusInEvent,\n  KeyborgFocusInEventDetails,\n  KeyborgFocusOutEvent,\n  KeyborgFocusOutEventDetails,\n} from \"./FocusEvent.mts\";\nexport {\n  getLastFocusedProgrammatically,\n  nativeFocus,\n  KEYBORG_FOCUSIN,\n  KEYBORG_FOCUSOUT,\n} from \"./FocusEvent.mts\";\n\nexport const version = process.env.PKG_VERSION;\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -0,0 +1,62 @@
+//#region src/Keyborg.d.mts
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+type KeyborgCallback = (isNavigatingWithKeyboard: boolean) => void;
+/**
+ * Used to determine the keyboard navigation state.
+ */
+interface Keyborg {
+  /**
+   * @returns Whether the user is navigating with keyboard
+   */
+  isNavigatingWithKeyboard(): boolean;
+  /**
+   * @param callback - Called when the keyboard navigation state changes
+   */
+  subscribe(callback: KeyborgCallback): void;
+  /**
+   * @param callback - Registered with subscribe
+   */
+  unsubscribe(callback: KeyborgCallback): void;
+  /**
+   * Manually set the keyboard navigation state
+   */
+  setVal(isNavigatingWithKeyboard: boolean): void;
+}
+declare function createKeyborg(win: Window): Keyborg;
+declare function disposeKeyborg(instance: Keyborg): void;
+//#endregion
+//#region src/FocusEvent.d.mts
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+declare const KEYBORG_FOCUSIN = "keyborg:focusin";
+declare const KEYBORG_FOCUSOUT = "keyborg:focusout";
+interface KeyborgFocusInEventDetails {
+  relatedTarget?: HTMLElement;
+  isFocusedProgrammatically?: boolean;
+  originalEvent?: FocusEvent;
+}
+type KeyborgFocusInEvent = CustomEvent<KeyborgFocusInEventDetails>;
+interface KeyborgFocusOutEventDetails {
+  originalEvent: FocusEvent;
+}
+type KeyborgFocusOutEvent = CustomEvent<KeyborgFocusOutEventDetails>;
+/**
+ * Guarantees that the native `focus` will be used
+ */
+declare function nativeFocus(element: HTMLElement): void;
+/**
+ * @param win The window that stores keyborg focus events
+ * @returns The last element focused with element.focus()
+ */
+declare function getLastFocusedProgrammatically(win: Window): HTMLElement | null | undefined;
+//#endregion
+//#region src/index.d.mts
+declare const version: any;
+//#endregion
+export { KEYBORG_FOCUSIN, KEYBORG_FOCUSOUT, type Keyborg, type KeyborgCallback, type KeyborgFocusInEvent, type KeyborgFocusInEventDetails, type KeyborgFocusOutEvent, type KeyborgFocusOutEventDetails, createKeyborg, disposeKeyborg, getLastFocusedProgrammatically, nativeFocus, version };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,113 +1,48 @@
-/**
- * Allows disposable instances to be used
- */
-interface Disposable {
-    isDisposed?(): boolean;
-}
-
+//#region src/Keyborg.d.mts
 /*!
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-
-interface WindowWithKeyborg extends Window {
-    __keyborg?: {
-        core: KeyborgCore;
-        refs: {
-            [id: string]: Keyborg;
-        };
-    };
-}
-interface KeyborgProps {
-    triggerKeys?: number[];
-    dismissKeys?: number[];
-}
 type KeyborgCallback = (isNavigatingWithKeyboard: boolean) => void;
 /**
- * Manages a collection of Keyborg instances in a window/document and updates keyborg state
+ * Used to determine the keyboard navigation state.
  */
-declare class KeyborgCore implements Disposable {
-    readonly id: string;
-    private _win?;
-    private _isMouseOrTouchUsedTimer;
-    private _dismissTimer;
-    private _triggerKeys?;
-    private _dismissKeys?;
-    private _isNavigatingWithKeyboard_DO_NOT_USE;
-    constructor(win: WindowWithKeyborg, props?: KeyborgProps);
-    get isNavigatingWithKeyboard(): boolean;
-    set isNavigatingWithKeyboard(val: boolean);
-    dispose(): void;
-    isDisposed(): boolean;
-    /**
-     * Updates all keyborg instances with the keyboard navigation state
-     */
-    update(): void;
-    private _onFocusIn;
-    private _onMouseDown;
-    private _onMouseOrTouch;
-    private _onKeyDown;
-    /**
-     * @returns whether the keyboard event should trigger keyboard navigation mode
-     */
-    private _shouldTriggerKeyboardNavigation;
-    /**
-     * @returns whether the keyboard event should dismiss keyboard navigation mode
-     */
-    private _shouldDismissKeyboardNavigation;
-    private _scheduleDismiss;
-}
-/**
- * Used to determine the keyboard navigation state
- */
-declare class Keyborg {
-    private _id;
-    private _win?;
-    private _core?;
-    private _cb;
-    static create(win: WindowWithKeyborg, props?: KeyborgProps): Keyborg;
-    static dispose(instance: Keyborg): void;
-    /**
-     * Updates all subscribed callbacks with the keyboard navigation state
-     */
-    static update(instance: Keyborg, isNavigatingWithKeyboard: boolean): void;
-    private constructor();
-    private dispose;
-    /**
-     * @returns Whether the user is navigating with keyboard
-     */
-    isNavigatingWithKeyboard(): boolean;
-    /**
-     * @param callback - Called when the keyboard navigation state changes
-     */
-    subscribe(callback: KeyborgCallback): void;
-    /**
-     * @param callback - Registered with subscribe
-     */
-    unsubscribe(callback: KeyborgCallback): void;
-    /**
-     * Manually set the keyboard navigtion state
-     */
-    setVal(isNavigatingWithKeyboard: boolean): void;
-}
-declare function createKeyborg(win: Window, props?: KeyborgProps): Keyborg;
+interface Keyborg {
+  /**
+   * @returns Whether the user is navigating with keyboard
+   */
+  isNavigatingWithKeyboard(): boolean;
+  /**
+   * @param callback - Called when the keyboard navigation state changes
+   */
+  subscribe(callback: KeyborgCallback): void;
+  /**
+   * @param callback - Registered with subscribe
+   */
+  unsubscribe(callback: KeyborgCallback): void;
+  /**
+   * Manually set the keyboard navigation state
+   */
+  setVal(isNavigatingWithKeyboard: boolean): void;
+}
+declare function createKeyborg(win: Window): Keyborg;
 declare function disposeKeyborg(instance: Keyborg): void;
-
+//#endregion
+//#region src/FocusEvent.d.mts
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
 declare const KEYBORG_FOCUSIN = "keyborg:focusin";
 declare const KEYBORG_FOCUSOUT = "keyborg:focusout";
 interface KeyborgFocusInEventDetails {
-    relatedTarget?: HTMLElement;
-    isFocusedProgrammatically?: boolean;
-    originalEvent?: FocusEvent;
-}
-interface KeyborgFocusInEvent extends CustomEvent<KeyborgFocusInEventDetails> {
-    /**
-     * @deprecated - used `event.detail`
-     */
-    details?: KeyborgFocusInEventDetails;
+  relatedTarget?: HTMLElement;
+  isFocusedProgrammatically?: boolean;
+  originalEvent?: FocusEvent;
 }
+type KeyborgFocusInEvent = CustomEvent<KeyborgFocusInEventDetails>;
 interface KeyborgFocusOutEventDetails {
-    originalEvent: FocusEvent;
+  originalEvent: FocusEvent;
 }
 type KeyborgFocusOutEvent = CustomEvent<KeyborgFocusOutEventDetails>;
 /**
@@ -119,12 +54,9 @@ declare function nativeFocus(element: HTMLElement): void;
  * @returns The last element focused with element.focus()
  */
 declare function getLastFocusedProgrammatically(win: Window): HTMLElement | null | undefined;
-
-/*!
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-declare const version: string | undefined;
-
-export { KEYBORG_FOCUSIN, KEYBORG_FOCUSOUT, Keyborg, type KeyborgCallback, type KeyborgFocusInEvent, type KeyborgFocusInEventDetails, type KeyborgFocusOutEvent, type KeyborgFocusOutEventDetails, createKeyborg, disposeKeyborg, getLastFocusedProgrammatically, nativeFocus, version };
+//#endregion
+//#region src/index.d.mts
+declare const version: any;
+//#endregion
+export { KEYBORG_FOCUSIN, KEYBORG_FOCUSOUT, type Keyborg, type KeyborgCallback, type KeyborgFocusInEvent, type KeyborgFocusInEventDetails, type KeyborgFocusOutEvent, type KeyborgFocusOutEventDetails, createKeyborg, disposeKeyborg, getLastFocusedProgrammatically, nativeFocus, version };
+//# sourceMappingURL=index.d.ts.map