keyborg 1.1.0-alpha.1 → 1.1.0

package/{lib-commonjs/Keyborg.js → dist/index.js}

@@ -2,8 +2,180 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var FocusEvent = require('./FocusEvent.js');
-var WeakRefInstance = require('./WeakRefInstance.js');
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+// IE11 compat, checks if WeakRef is supported
+const _canUseWeakRef = typeof WeakRef !== "undefined";
+/**
+ * WeakRef wrapper around a HTMLElement that also supports IE11
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef}
+ * @internal
+ */
+
+class WeakRefInstance {
+  constructor(instance) {
+    if (_canUseWeakRef && typeof instance === "object") {
+      this._weakRef = new WeakRef(instance);
+    } else {
+      this._instance = instance;
+    }
+  }
+  /**
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef/deref}
+   */
+
+
+  deref() {
+    var _a, _b, _c;
+
+    let instance;
+
+    if (this._weakRef) {
+      instance = (_a = this._weakRef) === null || _a === void 0 ? void 0 : _a.deref();
+
+      if (!instance) {
+        delete this._weakRef;
+      }
+    } else {
+      instance = this._instance;
+
+      if ((_c = (_b = instance) === null || _b === void 0 ? void 0 : _b.isDisposed) === null || _c === void 0 ? void 0 : _c.call(_b)) {
+        delete this._instance;
+      }
+    }
+
+    return instance;
+  }
+
+}
+
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const KEYBORG_FOCUSIN = "keyborg:focusin";
+
+function canOverrideNativeFocus(win) {
+  const HTMLElement = win.HTMLElement;
+  const origFocus = HTMLElement.prototype.focus;
+  let isCustomFocusCalled = false;
+
+  HTMLElement.prototype.focus = function focus() {
+    isCustomFocusCalled = true;
+  };
+
+  const btn = win.document.createElement("button");
+  btn.focus();
+  HTMLElement.prototype.focus = origFocus;
+  return isCustomFocusCalled;
+}
+
+let _canOverrideNativeFocus = false;
+/**
+ * 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;
+
+  if (!_canOverrideNativeFocus) {
+    _canOverrideNativeFocus = canOverrideNativeFocus(kwin);
+  }
+
+  const origFocus = kwin.HTMLElement.prototype.focus;
+
+  if (origFocus.__keyborgNativeFocus) {
+    // Already set up.
+    return;
+  }
+
+  kwin.HTMLElement.prototype.focus = focus;
+  const data = kwin.__keyborgData = {
+    focusInHandler: e => {
+      var _a;
+
+      const target = e.target;
+
+      if (!target) {
+        return;
+      }
+
+      const event = document.createEvent("HTMLEvents");
+      event.initEvent(KEYBORG_FOCUSIN, true, true);
+      const details = {
+        relatedTarget: e.relatedTarget || undefined
+      };
+
+      if (_canOverrideNativeFocus || data.lastFocusedProgrammatically) {
+        details.isFocusedProgrammatically = target === ((_a = data.lastFocusedProgrammatically) === null || _a === void 0 ? void 0 : _a.deref());
+        data.lastFocusedProgrammatically = undefined;
+      }
+
+      event.details = details;
+      target.dispatchEvent(event);
+    }
+  };
+  kwin.document.addEventListener("focusin", kwin.__keyborgData.focusInHandler, true);
+
+  function focus() {
+    const keyborgNativeFocusEvent = kwin.__keyborgData;
+
+    if (keyborgNativeFocusEvent) {
+      keyborgNativeFocusEvent.lastFocusedProgrammatically = new WeakRefInstance(this);
+    } // eslint-disable-next-line prefer-rest-params
+
+
+    return origFocus.apply(this, arguments);
+  }
+
+  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 keyborgNativeFocusEvent = kwin.__keyborgData;
+
+  if (keyborgNativeFocusEvent) {
+    kwin.document.removeEventListener("focusin", keyborgNativeFocusEvent.focusInHandler, true);
+    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) {
+  var _a;
+
+  const keyborgNativeFocusEvent = win.__keyborgData;
+  return keyborgNativeFocusEvent ? ((_a = keyborgNativeFocusEvent.lastFocusedProgrammatically) === null || _a === void 0 ? void 0 : _a.deref()) || null : undefined;
+}
 
 /*!
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -30,7 +202,7 @@ class KeyborgState {
     const id = keyborg.id;
 
     if (!(id in this.__keyborgCoreRefs)) {
-      this.__keyborgCoreRefs[id] = new WeakRefInstance.WeakRefInstance(keyborg);
+      this.__keyborgCoreRefs[id] = new WeakRefInstance(keyborg);
     }
   }
 
@@ -127,13 +299,13 @@ class KeyborgCore {
     this.id = "c" + ++_lastId;
     this._win = win;
     const doc = win.document;
-    doc.addEventListener(FocusEvent.KEYBORG_FOCUSIN, this._onFocusIn, true); // Capture!
+    doc.addEventListener(KEYBORG_FOCUSIN, this._onFocusIn, true); // Capture!
 
     doc.addEventListener("mousedown", this._onMouseDown, true); // Capture!
 
     win.addEventListener("keydown", this._onKeyDown, true); // Capture!
 
-    FocusEvent.setupFocusEvent(win);
+    setupFocusEvent(win);
 
     _state.add(this);
   }
@@ -147,9 +319,9 @@ class KeyborgCore {
         this._dismissTimer = undefined;
       }
 
-      FocusEvent.disposeFocusEvent(win);
+      disposeFocusEvent(win);
       const doc = win.document;
-      doc.removeEventListener(FocusEvent.KEYBORG_FOCUSIN, this._onFocusIn, true); // Capture!
+      doc.removeEventListener(KEYBORG_FOCUSIN, this._onFocusIn, true); // Capture!
 
       doc.removeEventListener("mousedown", this._onMouseDown, true); // Capture!
 
@@ -313,8 +485,17 @@ function disposeKeyborg(instance) {
   Keyborg.dispose(instance);
 }
 
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const version = "1.1.0";
+
+exports.KEYBORG_FOCUSIN = KEYBORG_FOCUSIN;
 exports.Keyborg = Keyborg;
-exports.KeyborgState = KeyborgState;
 exports.createKeyborg = createKeyborg;
 exports.disposeKeyborg = disposeKeyborg;
-//# sourceMappingURL=Keyborg.js.map
+exports.getLastFocusedProgrammatically = getLastFocusedProgrammatically;
+exports.nativeFocus = nativeFocus;
+exports.version = version;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/{lib/Keyborg.js → dist/keyborg.esm.js}

@@ -1,5 +1,177 @@
-import { KEYBORG_FOCUSIN, setupFocusEvent, disposeFocusEvent } from './FocusEvent.js';
-import { WeakRefInstance } from './WeakRefInstance.js';
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+// IE11 compat, checks if WeakRef is supported
+const _canUseWeakRef = typeof WeakRef !== "undefined";
+/**
+ * WeakRef wrapper around a HTMLElement that also supports IE11
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef}
+ * @internal
+ */
+
+class WeakRefInstance {
+  constructor(instance) {
+    if (_canUseWeakRef && typeof instance === "object") {
+      this._weakRef = new WeakRef(instance);
+    } else {
+      this._instance = instance;
+    }
+  }
+  /**
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef/deref}
+   */
+
+
+  deref() {
+    var _a, _b, _c;
+
+    let instance;
+
+    if (this._weakRef) {
+      instance = (_a = this._weakRef) === null || _a === void 0 ? void 0 : _a.deref();
+
+      if (!instance) {
+        delete this._weakRef;
+      }
+    } else {
+      instance = this._instance;
+
+      if ((_c = (_b = instance) === null || _b === void 0 ? void 0 : _b.isDisposed) === null || _c === void 0 ? void 0 : _c.call(_b)) {
+        delete this._instance;
+      }
+    }
+
+    return instance;
+  }
+
+}
+
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const KEYBORG_FOCUSIN = "keyborg:focusin";
+
+function canOverrideNativeFocus(win) {
+  const HTMLElement = win.HTMLElement;
+  const origFocus = HTMLElement.prototype.focus;
+  let isCustomFocusCalled = false;
+
+  HTMLElement.prototype.focus = function focus() {
+    isCustomFocusCalled = true;
+  };
+
+  const btn = win.document.createElement("button");
+  btn.focus();
+  HTMLElement.prototype.focus = origFocus;
+  return isCustomFocusCalled;
+}
+
+let _canOverrideNativeFocus = false;
+/**
+ * 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;
+
+  if (!_canOverrideNativeFocus) {
+    _canOverrideNativeFocus = canOverrideNativeFocus(kwin);
+  }
+
+  const origFocus = kwin.HTMLElement.prototype.focus;
+
+  if (origFocus.__keyborgNativeFocus) {
+    // Already set up.
+    return;
+  }
+
+  kwin.HTMLElement.prototype.focus = focus;
+  const data = kwin.__keyborgData = {
+    focusInHandler: e => {
+      var _a;
+
+      const target = e.target;
+
+      if (!target) {
+        return;
+      }
+
+      const event = document.createEvent("HTMLEvents");
+      event.initEvent(KEYBORG_FOCUSIN, true, true);
+      const details = {
+        relatedTarget: e.relatedTarget || undefined
+      };
+
+      if (_canOverrideNativeFocus || data.lastFocusedProgrammatically) {
+        details.isFocusedProgrammatically = target === ((_a = data.lastFocusedProgrammatically) === null || _a === void 0 ? void 0 : _a.deref());
+        data.lastFocusedProgrammatically = undefined;
+      }
+
+      event.details = details;
+      target.dispatchEvent(event);
+    }
+  };
+  kwin.document.addEventListener("focusin", kwin.__keyborgData.focusInHandler, true);
+
+  function focus() {
+    const keyborgNativeFocusEvent = kwin.__keyborgData;
+
+    if (keyborgNativeFocusEvent) {
+      keyborgNativeFocusEvent.lastFocusedProgrammatically = new WeakRefInstance(this);
+    } // eslint-disable-next-line prefer-rest-params
+
+
+    return origFocus.apply(this, arguments);
+  }
+
+  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 keyborgNativeFocusEvent = kwin.__keyborgData;
+
+  if (keyborgNativeFocusEvent) {
+    kwin.document.removeEventListener("focusin", keyborgNativeFocusEvent.focusInHandler, true);
+    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) {
+  var _a;
+
+  const keyborgNativeFocusEvent = win.__keyborgData;
+  return keyborgNativeFocusEvent ? ((_a = keyborgNativeFocusEvent.lastFocusedProgrammatically) === null || _a === void 0 ? void 0 : _a.deref()) || null : undefined;
+}
 
 /*!
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -309,5 +481,11 @@ function disposeKeyborg(instance) {
   Keyborg.dispose(instance);
 }
 
-export { Keyborg, KeyborgState, createKeyborg, disposeKeyborg };
-//# sourceMappingURL=Keyborg.js.map
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const version = "1.1.0";
+
+export { KEYBORG_FOCUSIN, Keyborg, createKeyborg, disposeKeyborg, getLastFocusedProgrammatically, nativeFocus, version };
+//# sourceMappingURL=keyborg.esm.js.map

package/dist/keyborg.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyborg.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,31 +1,30 @@
 {
   "name": "keyborg",
-  "version": "1.1.0-alpha.1",
+  "version": "1.1.0",
   "description": "Keyboard Navigation Detection for Web",
   "author": "Marat Abdullin <marata@microsoft.com>",
   "license": "MIT",
   "sideEffects": false,
-  "main": "./lib-commonjs/index.js",
-  "module": "./lib/index.js",
-  "typings": "./lib/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/keyborg.esm.js",
+  "typings": "./dist/index.d.ts",
   "files": [
-    "lib",
-    "lib-commonjs"
+    "dist"
   ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/microsoft/keyborg"
   },
   "scripts": {
+    "clean": "rimraf dist",
     "build": "npm run clean && rollup -c",
-    "bundle-size": "bundle-size measure",
-    "lint": "eslint src/",
-    "lint:fix": "eslint src/ --fix",
+    "bundle-size": "npm run build && bundle-size measure",
     "format": "prettier --check .",
     "format:fix": "prettier --write .",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
     "prepublishOnly": "npm run lint && npm run format && npm run build",
-    "release": "release-it",
-    "clean": "rimraf lib && rimraf lib-commonjs"
+    "release": "release-it --verbose"
   },
   "devDependencies": {
     "@babel/core": "^7.16.0",

package/lib/FocusEvent.d.ts

@@ -1,26 +0,0 @@
-export declare const KEYBORG_FOCUSIN = "keyborg:focusin";
-export interface KeyborgFocusInEventDetails {
-    relatedTarget?: HTMLElement;
-    isFocusedProgrammatically?: boolean;
-}
-export interface KeyborgFocusInEvent extends Event {
-    details: KeyborgFocusInEventDetails;
-}
-/**
- * Guarantees that the native `focus` will be used
- */
-export declare function nativeFocus(element: HTMLElement): void;
-/**
- * Overrides the native `focus` and setups the keyborg focus event
- */
-export declare function setupFocusEvent(win: Window): void;
-/**
- * Removes keyborg event listeners and custom focus override
- * @param win The window that stores keyborg focus events
- */
-export declare function disposeFocusEvent(win: Window): void;
-/**
- * @param win The window that stores keyborg focus events
- * @returns The last element focused with element.focus()
- */
-export declare function getLastFocusedProgrammatically(win: Window): HTMLElement | null | undefined;

package/lib/FocusEvent.js

@@ -1,130 +0,0 @@
-import { WeakRefInstance } from './WeakRefInstance.js';
-
-/*!
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-const KEYBORG_FOCUSIN = "keyborg:focusin";
-
-function canOverrideNativeFocus(win) {
-  const HTMLElement = win.HTMLElement;
-  const origFocus = HTMLElement.prototype.focus;
-  let isCustomFocusCalled = false;
-
-  HTMLElement.prototype.focus = function focus() {
-    isCustomFocusCalled = true;
-  };
-
-  const btn = win.document.createElement("button");
-  btn.focus();
-  HTMLElement.prototype.focus = origFocus;
-  return isCustomFocusCalled;
-}
-
-let _canOverrideNativeFocus = false;
-/**
- * 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;
-
-  if (!_canOverrideNativeFocus) {
-    _canOverrideNativeFocus = canOverrideNativeFocus(kwin);
-  }
-
-  const origFocus = kwin.HTMLElement.prototype.focus;
-
-  if (origFocus.__keyborgNativeFocus) {
-    // Already set up.
-    return;
-  }
-
-  kwin.HTMLElement.prototype.focus = focus;
-  const data = kwin.__keyborgData = {
-    focusInHandler: e => {
-      var _a;
-
-      const target = e.target;
-
-      if (!target) {
-        return;
-      }
-
-      const event = document.createEvent("HTMLEvents");
-      event.initEvent(KEYBORG_FOCUSIN, true, true);
-      const details = {
-        relatedTarget: e.relatedTarget || undefined
-      };
-
-      if (_canOverrideNativeFocus || data.lastFocusedProgrammatically) {
-        details.isFocusedProgrammatically = target === ((_a = data.lastFocusedProgrammatically) === null || _a === void 0 ? void 0 : _a.deref());
-        data.lastFocusedProgrammatically = undefined;
-      }
-
-      event.details = details;
-      target.dispatchEvent(event);
-    }
-  };
-  kwin.document.addEventListener("focusin", kwin.__keyborgData.focusInHandler, true);
-
-  function focus() {
-    const keyborgNativeFocusEvent = kwin.__keyborgData;
-
-    if (keyborgNativeFocusEvent) {
-      keyborgNativeFocusEvent.lastFocusedProgrammatically = new WeakRefInstance(this);
-    } // eslint-disable-next-line prefer-rest-params
-
-
-    return origFocus.apply(this, arguments);
-  }
-
-  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 keyborgNativeFocusEvent = kwin.__keyborgData;
-
-  if (keyborgNativeFocusEvent) {
-    kwin.document.removeEventListener("focusin", keyborgNativeFocusEvent.focusInHandler, true);
-    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) {
-  var _a;
-
-  const keyborgNativeFocusEvent = win.__keyborgData;
-  return keyborgNativeFocusEvent ? ((_a = keyborgNativeFocusEvent.lastFocusedProgrammatically) === null || _a === void 0 ? void 0 : _a.deref()) || null : undefined;
-}
-
-export { KEYBORG_FOCUSIN, disposeFocusEvent, getLastFocusedProgrammatically, nativeFocus, setupFocusEvent };
-//# sourceMappingURL=FocusEvent.js.map

package/lib/FocusEvent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FocusEvent.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/Keyborg.d.ts

@@ -1,81 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-import { Disposable } from "./WeakRefInstance";
-interface WindowWithKeyborg extends Window {
-    __keyborg?: {
-        core: KeyborgCore;
-        refs: {
-            [id: string]: Keyborg;
-        };
-    };
-}
-export declare type KeyborgCallback = (isNavigatingWithKeyboard: boolean) => void;
-/**
- * Source of truth for all the keyborg core instances and the current keyboard navigation state
- */
-export declare class KeyborgState {
-    private __keyborgCoreRefs;
-    private _isNavigatingWithKeyboard;
-    add(keyborg: KeyborgCore): void;
-    remove(id: string): void;
-    setVal(isNavigatingWithKeyboard: boolean): void;
-    getVal(): boolean;
-}
-/**
- * Manages a collection of Keyborg instances in a window/document and updates keyborg state
- */
-declare class KeyborgCore implements Disposable {
-    readonly id: string;
-    private _win?;
-    private _isMouseUsed;
-    private _dismissTimer;
-    constructor(win: WindowWithKeyborg);
-    dispose(): void;
-    isDisposed(): boolean;
-    /**
-     * Updates all keyborg instances with the keyboard navigation state
-     */
-    update(isNavigatingWithKeyboard: boolean): void;
-    private _onFocusIn;
-    private _onMouseDown;
-    private _onKeyDown;
-    private _scheduleDismiss;
-}
-/**
- * Used to determine the keyboard navigation state
- */
-export declare class Keyborg {
-    private _id;
-    private _win?;
-    private _core?;
-    private _cb;
-    static create(win: WindowWithKeyborg): 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;
-}
-export declare function createKeyborg(win: Window): Keyborg;
-export declare function disposeKeyborg(instance: Keyborg): void;
-export {};

package/lib/Keyborg.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Keyborg.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/WeakRefInstance.d.ts

@@ -1,25 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-export declare const _canUseWeakRef: boolean;
-/**
- * Allows disposable instances to be used
- */
-export interface Disposable {
-    isDisposed?(): boolean;
-}
-/**
- * WeakRef wrapper around a HTMLElement that also supports IE11
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef}
- * @internal
- */
-export declare class WeakRefInstance<T extends Disposable | object> {
-    private _weakRef?;
-    private _instance?;
-    constructor(instance: T);
-    /**
-     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef/deref}
-     */
-    deref(): T | undefined;
-}

package/lib/WeakRefInstance.js

@@ -1,51 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-// IE11 compat, checks if WeakRef is supported
-const _canUseWeakRef = typeof WeakRef !== "undefined";
-/**
- * WeakRef wrapper around a HTMLElement that also supports IE11
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef}
- * @internal
- */
-
-class WeakRefInstance {
-  constructor(instance) {
-    if (_canUseWeakRef && typeof instance === "object") {
-      this._weakRef = new WeakRef(instance);
-    } else {
-      this._instance = instance;
-    }
-  }
-  /**
-   * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef/deref}
-   */
-
-
-  deref() {
-    var _a, _b, _c;
-
-    let instance;
-
-    if (this._weakRef) {
-      instance = (_a = this._weakRef) === null || _a === void 0 ? void 0 : _a.deref();
-
-      if (!instance) {
-        delete this._weakRef;
-      }
-    } else {
-      instance = this._instance;
-
-      if ((_c = (_b = instance) === null || _b === void 0 ? void 0 : _b.isDisposed) === null || _c === void 0 ? void 0 : _c.call(_b)) {
-        delete this._instance;
-      }
-    }
-
-    return instance;
-  }
-
-}
-
-export { WeakRefInstance, _canUseWeakRef };
-//# sourceMappingURL=WeakRefInstance.js.map

package/lib/WeakRefInstance.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WeakRefInstance.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/index.d.ts

@@ -1,7 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-export { Keyborg, createKeyborg, disposeKeyborg } from "./Keyborg";
-export { getLastFocusedProgrammatically, nativeFocus, KEYBORG_FOCUSIN, KeyborgFocusInEvent, KeyborgFocusInEventDetails, } from "./FocusEvent";
-export declare const version: string;

package/lib/index.js

@@ -1,11 +0,0 @@
-export { Keyborg, createKeyborg, disposeKeyborg } from './Keyborg.js';
-export { KEYBORG_FOCUSIN, getLastFocusedProgrammatically, nativeFocus } from './FocusEvent.js';
-
-/*!
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-const version = "1.1.0-alpha.1";
-
-export { version };
-//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/lib-commonjs/FocusEvent.js

@@ -1,138 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var WeakRefInstance = require('./WeakRefInstance.js');
-
-/*!
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-const KEYBORG_FOCUSIN = "keyborg:focusin";
-
-function canOverrideNativeFocus(win) {
-  const HTMLElement = win.HTMLElement;
-  const origFocus = HTMLElement.prototype.focus;
-  let isCustomFocusCalled = false;
-
-  HTMLElement.prototype.focus = function focus() {
-    isCustomFocusCalled = true;
-  };
-
-  const btn = win.document.createElement("button");
-  btn.focus();
-  HTMLElement.prototype.focus = origFocus;
-  return isCustomFocusCalled;
-}
-
-let _canOverrideNativeFocus = false;
-/**
- * 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;
-
-  if (!_canOverrideNativeFocus) {
-    _canOverrideNativeFocus = canOverrideNativeFocus(kwin);
-  }
-
-  const origFocus = kwin.HTMLElement.prototype.focus;
-
-  if (origFocus.__keyborgNativeFocus) {
-    // Already set up.
-    return;
-  }
-
-  kwin.HTMLElement.prototype.focus = focus;
-  const data = kwin.__keyborgData = {
-    focusInHandler: e => {
-      var _a;
-
-      const target = e.target;
-
-      if (!target) {
-        return;
-      }
-
-      const event = document.createEvent("HTMLEvents");
-      event.initEvent(KEYBORG_FOCUSIN, true, true);
-      const details = {
-        relatedTarget: e.relatedTarget || undefined
-      };
-
-      if (_canOverrideNativeFocus || data.lastFocusedProgrammatically) {
-        details.isFocusedProgrammatically = target === ((_a = data.lastFocusedProgrammatically) === null || _a === void 0 ? void 0 : _a.deref());
-        data.lastFocusedProgrammatically = undefined;
-      }
-
-      event.details = details;
-      target.dispatchEvent(event);
-    }
-  };
-  kwin.document.addEventListener("focusin", kwin.__keyborgData.focusInHandler, true);
-
-  function focus() {
-    const keyborgNativeFocusEvent = kwin.__keyborgData;
-
-    if (keyborgNativeFocusEvent) {
-      keyborgNativeFocusEvent.lastFocusedProgrammatically = new WeakRefInstance.WeakRefInstance(this);
-    } // eslint-disable-next-line prefer-rest-params
-
-
-    return origFocus.apply(this, arguments);
-  }
-
-  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 keyborgNativeFocusEvent = kwin.__keyborgData;
-
-  if (keyborgNativeFocusEvent) {
-    kwin.document.removeEventListener("focusin", keyborgNativeFocusEvent.focusInHandler, true);
-    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) {
-  var _a;
-
-  const keyborgNativeFocusEvent = win.__keyborgData;
-  return keyborgNativeFocusEvent ? ((_a = keyborgNativeFocusEvent.lastFocusedProgrammatically) === null || _a === void 0 ? void 0 : _a.deref()) || null : undefined;
-}
-
-exports.KEYBORG_FOCUSIN = KEYBORG_FOCUSIN;
-exports.disposeFocusEvent = disposeFocusEvent;
-exports.getLastFocusedProgrammatically = getLastFocusedProgrammatically;
-exports.nativeFocus = nativeFocus;
-exports.setupFocusEvent = setupFocusEvent;
-//# sourceMappingURL=FocusEvent.js.map

package/lib-commonjs/FocusEvent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FocusEvent.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib-commonjs/Keyborg.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Keyborg.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib-commonjs/WeakRefInstance.js

@@ -1,56 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-/*!
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-// IE11 compat, checks if WeakRef is supported
-const _canUseWeakRef = typeof WeakRef !== "undefined";
-/**
- * WeakRef wrapper around a HTMLElement that also supports IE11
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef}
- * @internal
- */
-
-class WeakRefInstance {
-  constructor(instance) {
-    if (_canUseWeakRef && typeof instance === "object") {
-      this._weakRef = new WeakRef(instance);
-    } else {
-      this._instance = instance;
-    }
-  }
-  /**
-   * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef/deref}
-   */
-
-
-  deref() {
-    var _a, _b, _c;
-
-    let instance;
-
-    if (this._weakRef) {
-      instance = (_a = this._weakRef) === null || _a === void 0 ? void 0 : _a.deref();
-
-      if (!instance) {
-        delete this._weakRef;
-      }
-    } else {
-      instance = this._instance;
-
-      if ((_c = (_b = instance) === null || _b === void 0 ? void 0 : _b.isDisposed) === null || _c === void 0 ? void 0 : _c.call(_b)) {
-        delete this._instance;
-      }
-    }
-
-    return instance;
-  }
-
-}
-
-exports.WeakRefInstance = WeakRefInstance;
-exports._canUseWeakRef = _canUseWeakRef;
-//# sourceMappingURL=WeakRefInstance.js.map

package/lib-commonjs/WeakRefInstance.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WeakRefInstance.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib-commonjs/index.js

@@ -1,21 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var Keyborg = require('./Keyborg.js');
-var FocusEvent = require('./FocusEvent.js');
-
-/*!
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-const version = "1.1.0-alpha.1";
-
-exports.Keyborg = Keyborg.Keyborg;
-exports.createKeyborg = Keyborg.createKeyborg;
-exports.disposeKeyborg = Keyborg.disposeKeyborg;
-exports.KEYBORG_FOCUSIN = FocusEvent.KEYBORG_FOCUSIN;
-exports.getLastFocusedProgrammatically = FocusEvent.getLastFocusedProgrammatically;
-exports.nativeFocus = FocusEvent.nativeFocus;
-exports.version = version;
-//# sourceMappingURL=index.js.map

package/lib-commonjs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}