keyborg 1.0.7 → 1.1.0-alpha.3

package/dist/keyborg.esm.js

@@ -3,16 +3,16 @@
  * Licensed under the MIT License.
  */
 // IE11 compat, checks if WeakRef is supported
-var _canUseWeakRef = typeof WeakRef !== 'undefined';
+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
  */
 
-var WeakRefInstance = /*#__PURE__*/function () {
-  function WeakRefInstance(instance) {
-    if (_canUseWeakRef) {
+class WeakRefInstance {
+  constructor(instance) {
+    if (_canUseWeakRef && typeof instance === "object") {
       this._weakRef = new WeakRef(instance);
     } else {
       this._instance = instance;
@@ -23,10 +23,10 @@ var WeakRefInstance = /*#__PURE__*/function () {
    */
 
 
-  WeakRefInstance.prototype.deref = function () {
+  deref() {
     var _a, _b, _c;
 
-    var instance;
+    let instance;
 
     if (this._weakRef) {
       instance = (_a = this._weakRef) === null || _a === void 0 ? void 0 : _a.deref();
@@ -43,43 +43,38 @@ var WeakRefInstance = /*#__PURE__*/function () {
     }
 
     return instance;
-  };
+  }
 
-  return WeakRefInstance;
-}();
+}
 
 /*!
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-var KEYBORG_FOCUSIN = 'keyborg:focusin';
+const KEYBORG_FOCUSIN = "keyborg:focusin";
 
 function canOverrideNativeFocus(win) {
-  var HTMLElement = win.HTMLElement;
-  var origFocus = HTMLElement.prototype.focus;
-  var isCustomFocusCalled = false;
+  const HTMLElement = win.HTMLElement;
+  const origFocus = HTMLElement.prototype.focus;
+  let isCustomFocusCalled = false;
 
   HTMLElement.prototype.focus = function focus() {
     isCustomFocusCalled = true;
   };
 
-  var btn = win.document.createElement('button');
+  const btn = win.document.createElement("button");
   btn.focus();
   HTMLElement.prototype.focus = origFocus;
   return isCustomFocusCalled;
 }
 
-var _canOverrideNativeFocus = false;
+let _canOverrideNativeFocus = false;
 /**
  * Guarantees that the native `focus` will be used
- * Use this when trying to simulate a native keyboard focus since it does not
- * the programmatic focus flag.
- *
- * ⚠️⚠️ This focus will always activate the keyboard navigation state.
  */
 
 function nativeFocus(element) {
-  var focus = element.focus;
+  const focus = element.focus;
 
   if (focus.__keyborgNativeFocus) {
     focus.__keyborgNativeFocus.call(element);
@@ -92,13 +87,13 @@ function nativeFocus(element) {
  */
 
 function setupFocusEvent(win) {
-  var kwin = win;
+  const kwin = win;
 
   if (!_canOverrideNativeFocus) {
     _canOverrideNativeFocus = canOverrideNativeFocus(kwin);
   }
 
-  var origFocus = kwin.HTMLElement.prototype.focus;
+  const origFocus = kwin.HTMLElement.prototype.focus;
 
   if (origFocus.__keyborgNativeFocus) {
     // Already set up.
@@ -106,19 +101,19 @@ function setupFocusEvent(win) {
   }
 
   kwin.HTMLElement.prototype.focus = focus;
-  var data = kwin.__keyborgData = {
-    focusInHandler: function focusInHandler(e) {
+  const data = kwin.__keyborgData = {
+    focusInHandler: e => {
       var _a;
 
-      var target = e.target;
+      const target = e.target;
 
       if (!target) {
         return;
       }
 
-      var event = document.createEvent('HTMLEvents');
+      const event = document.createEvent("HTMLEvents");
       event.initEvent(KEYBORG_FOCUSIN, true, true);
-      var details = {
+      const details = {
         relatedTarget: e.relatedTarget || undefined
       };
 
@@ -131,14 +126,15 @@ function setupFocusEvent(win) {
       target.dispatchEvent(event);
     }
   };
-  kwin.document.addEventListener('focusin', kwin.__keyborgData.focusInHandler, true);
+  kwin.document.addEventListener("focusin", kwin.__keyborgData.focusInHandler, true);
 
   function focus() {
-    var keyborgNativeFocusEvent = kwin.__keyborgData;
+    const keyborgNativeFocusEvent = kwin.__keyborgData;
 
     if (keyborgNativeFocusEvent) {
       keyborgNativeFocusEvent.lastFocusedProgrammatically = new WeakRefInstance(this);
-    }
+    } // eslint-disable-next-line prefer-rest-params
+
 
     return origFocus.apply(this, arguments);
   }
@@ -151,13 +147,13 @@ function setupFocusEvent(win) {
  */
 
 function disposeFocusEvent(win) {
-  var kwin = win;
-  var proto = kwin.HTMLElement.prototype;
-  var origFocus = proto.focus.__keyborgNativeFocus;
-  var keyborgNativeFocusEvent = kwin.__keyborgData;
+  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);
+    kwin.document.removeEventListener("focusin", keyborgNativeFocusEvent.focusInHandler, true);
     delete kwin.__keyborgData;
   }
 
@@ -173,7 +169,7 @@ function disposeFocusEvent(win) {
 function getLastFocusedProgrammatically(win) {
   var _a;
 
-  var keyborgNativeFocusEvent = win.__keyborgData;
+  const keyborgNativeFocusEvent = win.__keyborgData;
   return keyborgNativeFocusEvent ? ((_a = keyborgNativeFocusEvent.lastFocusedProgrammatically) === null || _a === void 0 ? void 0 : _a.deref()) || null : undefined;
 }
 
@@ -181,50 +177,49 @@ function getLastFocusedProgrammatically(win) {
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-var KeyTab = 9;
-var KeyEsc = 27;
-var _dismissTimeout = 500; // When Esc is pressed and the focused is not moved
+const KeyTab = 9;
+const KeyEsc = 27;
+const _dismissTimeout = 500; // When Esc is pressed and the focused is not moved
 // during _dismissTimeout time, dismiss the keyboard
 // navigation mode.
 
-var _lastId = 0;
+let _lastId = 0;
 /**
  * Source of truth for all the keyborg core instances and the current keyboard navigation state
  */
 
-var KeyborgState = /*#__PURE__*/function () {
-  function KeyborgState() {
+class KeyborgState {
+  constructor() {
     this.__keyborgCoreRefs = {};
     this._isNavigatingWithKeyboard = false;
   }
 
-  KeyborgState.prototype.add = function (keyborg) {
-    var id = keyborg.id;
+  add(keyborg) {
+    const id = keyborg.id;
 
     if (!(id in this.__keyborgCoreRefs)) {
       this.__keyborgCoreRefs[id] = new WeakRefInstance(keyborg);
     }
-  };
+  }
 
-  KeyborgState.prototype.remove = function (id) {
+  remove(id) {
     delete this.__keyborgCoreRefs[id];
 
     if (Object.keys(this.__keyborgCoreRefs).length === 0) {
       this._isNavigatingWithKeyboard = false;
     }
-  };
+  }
 
-  KeyborgState.prototype.setVal = function (isNavigatingWithKeyboard) {
+  setVal(isNavigatingWithKeyboard) {
     if (this._isNavigatingWithKeyboard === isNavigatingWithKeyboard) {
       return;
     }
 
     this._isNavigatingWithKeyboard = isNavigatingWithKeyboard;
 
-    for (var _i = 0, _a = Object.keys(this.__keyborgCoreRefs); _i < _a.length; _i++) {
-      var id = _a[_i];
-      var ref = this.__keyborgCoreRefs[id];
-      var keyborg = ref.deref();
+    for (const id of Object.keys(this.__keyborgCoreRefs)) {
+      const ref = this.__keyborgCoreRefs[id];
+      const keyborg = ref.deref();
 
       if (keyborg) {
         keyborg.update(isNavigatingWithKeyboard);
@@ -232,30 +227,27 @@ var KeyborgState = /*#__PURE__*/function () {
         this.remove(id);
       }
     }
-  };
+  }
 
-  KeyborgState.prototype.getVal = function () {
+  getVal() {
     return this._isNavigatingWithKeyboard;
-  };
+  }
 
-  return KeyborgState;
-}();
+}
 
-var _state = /*#__PURE__*/new KeyborgState();
+const _state = /*#__PURE__*/new KeyborgState();
 /**
  * Manages a collection of Keyborg instances in a window/document and updates keyborg state
  */
 
 
-var KeyborgCore = /*#__PURE__*/function () {
-  function KeyborgCore(win) {
-    var _this = this;
-
+class KeyborgCore {
+  constructor(win) {
     this._isMouseUsed = false;
 
-    this._onFocusIn = function (e) {
-      if (_this._isMouseUsed) {
-        _this._isMouseUsed = false;
+    this._onFocusIn = e => {
+      if (this._isMouseUsed) {
+        this._isMouseUsed = false;
         return;
       }
 
@@ -263,7 +255,7 @@ var KeyborgCore = /*#__PURE__*/function () {
         return;
       }
 
-      var details = e.details;
+      const details = e.details;
 
       if (!details.relatedTarget) {
         return;
@@ -278,44 +270,44 @@ var KeyborgCore = /*#__PURE__*/function () {
       _state.setVal(true);
     };
 
-    this._onMouseDown = function (e) {
+    this._onMouseDown = e => {
       if (e.buttons === 0 || e.clientX === 0 && e.clientY === 0 && e.screenX === 0 && e.screenY === 0) {
         // This is most likely an event triggered by the screen reader to perform
         // an action on an element, do not dismiss the keyboard navigation mode.
         return;
       }
 
-      _this._isMouseUsed = true;
+      this._isMouseUsed = true;
 
       _state.setVal(false);
     };
 
-    this._onKeyDown = function (e) {
-      var isNavigatingWithKeyboard = _state.getVal();
+    this._onKeyDown = e => {
+      const isNavigatingWithKeyboard = _state.getVal();
 
       if (!isNavigatingWithKeyboard && e.keyCode === KeyTab) {
         _state.setVal(true);
       } else if (isNavigatingWithKeyboard && e.keyCode === KeyEsc) {
-        _this._scheduleDismiss();
+        this._scheduleDismiss();
       }
     };
 
-    this.id = 'c' + ++_lastId;
+    this.id = "c" + ++_lastId;
     this._win = win;
-    var doc = win.document;
+    const doc = win.document;
     doc.addEventListener(KEYBORG_FOCUSIN, this._onFocusIn, true); // Capture!
 
-    doc.addEventListener('mousedown', this._onMouseDown, true); // Capture!
+    doc.addEventListener("mousedown", this._onMouseDown, true); // Capture!
 
-    win.addEventListener('keydown', this._onKeyDown, true); // Capture!
+    win.addEventListener("keydown", this._onKeyDown, true); // Capture!
 
     setupFocusEvent(win);
 
     _state.add(this);
   }
 
-  KeyborgCore.prototype.dispose = function () {
-    var win = this._win;
+  dispose() {
+    const win = this._win;
 
     if (win) {
       if (this._dismissTimer) {
@@ -324,44 +316,41 @@ var KeyborgCore = /*#__PURE__*/function () {
       }
 
       disposeFocusEvent(win);
-      var doc = win.document;
+      const doc = win.document;
       doc.removeEventListener(KEYBORG_FOCUSIN, this._onFocusIn, true); // Capture!
 
-      doc.removeEventListener('mousedown', this._onMouseDown, true); // Capture!
+      doc.removeEventListener("mousedown", this._onMouseDown, true); // Capture!
 
-      win.removeEventListener('keydown', this._onKeyDown, true); // Capture!
+      win.removeEventListener("keydown", this._onKeyDown, true); // Capture!
 
       delete this._win;
 
       _state.remove(this.id);
     }
-  };
+  }
 
-  KeyborgCore.prototype.isDisposed = function () {
+  isDisposed() {
     return !!this._win;
-  };
+  }
   /**
    * Updates all keyborg instances with the keyboard navigation state
    */
 
 
-  KeyborgCore.prototype.update = function (isNavigatingWithKeyboard) {
+  update(isNavigatingWithKeyboard) {
     var _a, _b;
 
-    var keyborgs = (_b = (_a = this._win) === null || _a === void 0 ? void 0 : _a.__keyborg) === null || _b === void 0 ? void 0 : _b.refs;
+    const keyborgs = (_b = (_a = this._win) === null || _a === void 0 ? void 0 : _a.__keyborg) === null || _b === void 0 ? void 0 : _b.refs;
 
     if (keyborgs) {
-      for (var _i = 0, _c = Object.keys(keyborgs); _i < _c.length; _i++) {
-        var id = _c[_i];
+      for (const id of Object.keys(keyborgs)) {
         Keyborg.update(keyborgs[id], isNavigatingWithKeyboard);
       }
     }
-  };
-
-  KeyborgCore.prototype._scheduleDismiss = function () {
-    var _this = this;
+  }
 
-    var win = this._win;
+  _scheduleDismiss() {
+    const win = this._win;
 
     if (win) {
       if (this._dismissTimer) {
@@ -369,35 +358,32 @@ var KeyborgCore = /*#__PURE__*/function () {
         this._dismissTimer = undefined;
       }
 
-      var was_1 = win.document.activeElement;
-      this._dismissTimer = win.setTimeout(function () {
-        _this._dismissTimer = undefined;
-        var cur = win.document.activeElement;
+      const was = win.document.activeElement;
+      this._dismissTimer = win.setTimeout(() => {
+        this._dismissTimer = undefined;
+        const cur = win.document.activeElement;
 
-        if (was_1 && cur && was_1 === cur) {
+        if (was && cur && was === cur) {
           // Esc was pressed, currently focused element hasn't changed.
           // Just dismiss the keyboard navigation mode.
           _state.setVal(false);
         }
       }, _dismissTimeout);
     }
-  };
+  }
 
-  return KeyborgCore;
-}();
+}
 /**
  * Used to determine the keyboard navigation state
  */
 
 
-var Keyborg = /*#__PURE__*/function () {
-  function Keyborg(win) {
-    var _a;
-
+class Keyborg {
+  constructor(win) {
     this._cb = [];
-    this._id = 'k' + ++_lastId;
+    this._id = "k" + ++_lastId;
     this._win = win;
-    var current = win.__keyborg;
+    const current = win.__keyborg;
 
     if (current) {
       this._core = current.core;
@@ -406,88 +392,88 @@ var Keyborg = /*#__PURE__*/function () {
       this._core = new KeyborgCore(win);
       win.__keyborg = {
         core: this._core,
-        refs: (_a = {}, _a[this._id] = this, _a)
+        refs: {
+          [this._id]: this
+        }
       };
     }
   }
 
-  Keyborg.create = function (win) {
+  static create(win) {
     return new Keyborg(win);
-  };
+  }
 
-  Keyborg.dispose = function (instance) {
+  static dispose(instance) {
     instance.dispose();
-  };
+  }
   /**
    * Updates all subscribed callbacks with the keyboard navigation state
    */
 
 
-  Keyborg.update = function (instance, isNavigatingWithKeyboard) {
-    instance._cb.forEach(function (callback) {
-      return callback(isNavigatingWithKeyboard);
-    });
-  };
+  static update(instance, isNavigatingWithKeyboard) {
+    instance._cb.forEach(callback => callback(isNavigatingWithKeyboard));
+  }
 
-  Keyborg.prototype.dispose = function () {
+  dispose() {
     var _a;
 
-    var current = (_a = this._win) === null || _a === void 0 ? void 0 : _a.__keyborg;
+    const current = (_a = this._win) === null || _a === void 0 ? void 0 : _a.__keyborg;
 
     if (current === null || current === void 0 ? void 0 : current.refs[this._id]) {
       delete current.refs[this._id];
 
       if (Object.keys(current.refs).length === 0) {
-        current.core.dispose();
+        current.core.dispose(); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
         delete this._win.__keyborg;
       }
-    } else if (process.env.NODE_ENV !== "production") {
+    } else if (process.env.NODE_ENV === 'development') {
       console.error("Keyborg instance " + this._id + " is being disposed incorrectly.");
     }
 
     this._cb = [];
     delete this._core;
     delete this._win;
-  };
+  }
   /**
    * @returns Whether the user is navigating with keyboard
    */
 
 
-  Keyborg.prototype.isNavigatingWithKeyboard = function () {
+  isNavigatingWithKeyboard() {
     return _state.getVal();
-  };
+  }
   /**
    * @param callback - Called when the keyboard navigation state changes
    */
 
 
-  Keyborg.prototype.subscribe = function (callback) {
+  subscribe(callback) {
     this._cb.push(callback);
-  };
+  }
   /**
    * @param callback - Registered with subscribe
    */
 
 
-  Keyborg.prototype.unsubscribe = function (callback) {
-    var index = this._cb.indexOf(callback);
+  unsubscribe(callback) {
+    const index = this._cb.indexOf(callback);
 
     if (index >= 0) {
       this._cb.splice(index, 1);
     }
-  };
+  }
   /**
    * Manually set the keyboard navigtion state
    */
 
 
-  Keyborg.prototype.setVal = function (isNavigatingWithKeyboard) {
+  setVal(isNavigatingWithKeyboard) {
     _state.setVal(isNavigatingWithKeyboard);
-  };
+  }
 
-  return Keyborg;
-}();
+}
 function createKeyborg(win) {
   return Keyborg.create(win);
 }
@@ -495,5 +481,11 @@ function disposeKeyborg(instance) {
   Keyborg.dispose(instance);
 }
 
-export { KEYBORG_FOCUSIN, Keyborg, createKeyborg, disposeKeyborg, getLastFocusedProgrammatically, nativeFocus };
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const version = "1.1.0-alpha.3";
+
+export { KEYBORG_FOCUSIN, Keyborg, createKeyborg, disposeKeyborg, getLastFocusedProgrammatically, nativeFocus, version };
 //# sourceMappingURL=keyborg.esm.js.map

package/dist/keyborg.esm.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keyborg",
-  "version": "1.0.7",
+  "version": "1.1.0-alpha.3",
   "description": "Keyboard Navigation Detection for Web",
   "author": "Marat Abdullin <marata@microsoft.com>",
   "license": "MIT",
@@ -13,22 +13,44 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/microsoft/tabster"
+    "url": "git+https://github.com/microsoft/keyborg"
   },
   "scripts": {
-    "build": "npm run tslint && npm run clean && tsdx build",
     "clean": "rimraf dist",
-    "tslint": "tslint --project tsconfig.json --fix || true",
-    "tslint:check": "tslint --project tsconfig.json",
-    "prepare": "npm run build"
+    "build": "npm run clean && rollup -c",
+    "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 --verbose"
   },
   "devDependencies": {
-    "lint": "^1.0.0-alpha.0",
+    "@babel/core": "^7.16.0",
+    "@babel/preset-env": "^7.16.4",
+    "@babel/preset-typescript": "^7.12.7",
+    "@fluentui/bundle-size": "^1.1.3",
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-commonjs": "^21.0.1",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.0.6",
+    "@rollup/plugin-replace": "^3.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.4.0",
+    "@typescript-eslint/parser": "^5.4.0",
+    "babel-plugin-annotate-pure-calls": "^0.4.0",
+    "ci-info": "^3.3.0",
+    "eslint": "^8.2.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-header": "^3.1.1",
+    "eslint-plugin-import": "^2.25.3",
+    "node-fetch": "^2.6.6",
+    "prettier": "^2.4.1",
+    "release-it": "^14.11.8",
     "rimraf": "^3.0.2",
-    "tsdx": "^0.14.1",
-    "tslint": "^6.1.3",
-    "tsutils": "^3.21.0",
-    "typescript": "^4.2.3"
-  },
-  "gitHead": "4cee6ea0ac8205619806c53440c76446235faed9"
+    "rollup": "^2.60.1",
+    "rollup-plugin-sourcemaps": "^0.6.3",
+    "rollup-plugin-typescript2": "^0.31.1",
+    "typescript": "^4.5.2"
+  }
 }