@workos-inc/authkit-js - npm Package Compare versions

Comparing version 0.0.3 to 0.0.4

dist/index.js

@@ -0,1 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(src_exports);
+
 // src/exceptions/no-client-id-provided.exception.ts
@@ -244,4 +270,312 @@ var NoClientIdProvidedException = class extends Error {
 
+// src/vendor/browser-tabs-lock/processLock.ts
+var ProcessLocking = class _ProcessLocking {
+  constructor() {
+    this.locked = /* @__PURE__ */ new Map();
+    this.addToLocked = (key, toAdd) => {
+      let callbacks = this.locked.get(key);
+      if (callbacks === void 0) {
+        if (toAdd === void 0) {
+          this.locked.set(key, []);
+        } else {
+          this.locked.set(key, [toAdd]);
+        }
+      } else {
+        if (toAdd !== void 0) {
+          callbacks.unshift(toAdd);
+          this.locked.set(key, callbacks);
+        }
+      }
+    };
+    this.isLocked = (key) => {
+      return this.locked.has(key);
+    };
+    this.lock = (key) => {
+      return new Promise((resolve, reject) => {
+        if (this.isLocked(key)) {
+          this.addToLocked(key, resolve);
+        } else {
+          this.addToLocked(key);
+          resolve();
+        }
+      });
+    };
+    this.unlock = (key) => {
+      let callbacks = this.locked.get(key);
+      if (callbacks === void 0 || callbacks.length === 0) {
+        this.locked.delete(key);
+        return;
+      }
+      let toCall = callbacks.pop();
+      this.locked.set(key, callbacks);
+      if (toCall !== void 0) {
+        setTimeout(toCall, 0);
+      }
+    };
+  }
+  static getInstance() {
+    if (_ProcessLocking.instance === void 0) {
+      _ProcessLocking.instance = new _ProcessLocking();
+    }
+    return _ProcessLocking.instance;
+  }
+};
+function getLock() {
+  return ProcessLocking.getInstance();
+}
+
+// src/vendor/browser-tabs-lock/index.ts
+var LOCK_STORAGE_KEY = "browser-tabs-lock-key";
+var DEFAULT_STORAGE_HANDLER = {
+  key: async (index) => {
+    throw new Error("Unsupported");
+  },
+  getItem: async (key) => {
+    throw new Error("Unsupported");
+  },
+  clear: async () => {
+    return window.localStorage.clear();
+  },
+  removeItem: async (key) => {
+    throw new Error("Unsupported");
+  },
+  setItem: async (key, value) => {
+    throw new Error("Unsupported");
+  },
+  keySync: (index) => {
+    return window.localStorage.key(index);
+  },
+  getItemSync: (key) => {
+    return window.localStorage.getItem(key);
+  },
+  clearSync: () => {
+    return window.localStorage.clear();
+  },
+  removeItemSync: (key) => {
+    return window.localStorage.removeItem(key);
+  },
+  setItemSync: (key, value) => {
+    return window.localStorage.setItem(key, value);
+  }
+};
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function generateRandomString(length) {
+  const CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
+  let randomstring = "";
+  for (let i = 0; i < length; i++) {
+    const INDEX = Math.floor(Math.random() * CHARS.length);
+    randomstring += CHARS[INDEX];
+  }
+  return randomstring;
+}
+function getLockId() {
+  return Date.now().toString() + generateRandomString(15);
+}
+var _SuperTokensLock = class _SuperTokensLock {
+  constructor(storageHandler) {
+    this.acquiredIatSet = /* @__PURE__ */ new Set();
+    this.storageHandler = void 0;
+    this.id = getLockId();
+    this.acquireLock = this.acquireLock.bind(this);
+    this.releaseLock = this.releaseLock.bind(this);
+    this.releaseLock__private__ = this.releaseLock__private__.bind(this);
+    this.waitForSomethingToChange = this.waitForSomethingToChange.bind(this);
+    this.refreshLockWhileAcquired = this.refreshLockWhileAcquired.bind(this);
+    this.storageHandler = storageHandler;
+    if (_SuperTokensLock.waiters === void 0) {
+      _SuperTokensLock.waiters = [];
+    }
+  }
+  /**
+   * @async
+   * @memberOf Lock
+   * @function acquireLock
+   * @param {string} lockKey - Key for which the lock is being acquired
+   * @param {number} [timeout=5000] - Maximum time for which the function will wait to acquire the lock
+   * @returns {Promise<boolean>}
+   * @description Will return true if lock is being acquired, else false.
+   *              Also the lock can be acquired for maximum 10 secs
+   */
+  async acquireLock(lockKey, timeout = 5e3) {
+    let iat = Date.now() + generateRandomString(4);
+    const MAX_TIME = Date.now() + timeout;
+    const STORAGE_KEY = `${LOCK_STORAGE_KEY}-${lockKey}`;
+    const STORAGE = this.storageHandler === void 0 ? DEFAULT_STORAGE_HANDLER : this.storageHandler;
+    while (Date.now() < MAX_TIME) {
+      await delay(30);
+      let lockObj = STORAGE.getItemSync(STORAGE_KEY);
+      if (lockObj === null) {
+        const TIMEOUT_KEY = `${this.id}-${lockKey}-${iat}`;
+        await delay(Math.floor(Math.random() * 25));
+        STORAGE.setItemSync(STORAGE_KEY, JSON.stringify({
+          id: this.id,
+          iat,
+          timeoutKey: TIMEOUT_KEY,
+          timeAcquired: Date.now(),
+          timeRefreshed: Date.now()
+        }));
+        await delay(30);
+        let lockObjPostDelay = STORAGE.getItemSync(STORAGE_KEY);
+        if (lockObjPostDelay !== null) {
+          let parsedLockObjPostDelay = JSON.parse(lockObjPostDelay);
+          if (parsedLockObjPostDelay.id === this.id && parsedLockObjPostDelay.iat === iat) {
+            this.acquiredIatSet.add(iat);
+            this.refreshLockWhileAcquired(STORAGE_KEY, iat);
+            return true;
+          }
+        }
+      } else {
+        _SuperTokensLock.lockCorrector(this.storageHandler === void 0 ? DEFAULT_STORAGE_HANDLER : this.storageHandler);
+        await this.waitForSomethingToChange(MAX_TIME);
+      }
+      iat = Date.now() + generateRandomString(4);
+    }
+    return false;
+  }
+  async refreshLockWhileAcquired(storageKey, iat) {
+    setTimeout(async () => {
+      await getLock().lock(iat);
+      if (!this.acquiredIatSet.has(iat)) {
+        getLock().unlock(iat);
+        return;
+      }
+      const STORAGE = this.storageHandler === void 0 ? DEFAULT_STORAGE_HANDLER : this.storageHandler;
+      let lockObj = STORAGE.getItemSync(storageKey);
+      if (lockObj !== null) {
+        let parsedLockObj = JSON.parse(lockObj);
+        parsedLockObj.timeRefreshed = Date.now();
+        STORAGE.setItemSync(storageKey, JSON.stringify(parsedLockObj));
+        getLock().unlock(iat);
+      } else {
+        getLock().unlock(iat);
+        return;
+      }
+      this.refreshLockWhileAcquired(storageKey, iat);
+    }, 1e3);
+  }
+  async waitForSomethingToChange(MAX_TIME) {
+    await new Promise((resolve) => {
+      let resolvedCalled = false;
+      let startedAt = Date.now();
+      const MIN_TIME_TO_WAIT = 50;
+      let removedListeners = false;
+      function stopWaiting() {
+        if (!removedListeners) {
+          window.removeEventListener("storage", stopWaiting);
+          _SuperTokensLock.removeFromWaiting(stopWaiting);
+          clearTimeout(timeOutId);
+          removedListeners = true;
+        }
+        if (!resolvedCalled) {
+          resolvedCalled = true;
+          let timeToWait = MIN_TIME_TO_WAIT - (Date.now() - startedAt);
+          if (timeToWait > 0) {
+            setTimeout(resolve, timeToWait);
+          } else {
+            resolve(null);
+          }
+        }
+      }
+      window.addEventListener("storage", stopWaiting);
+      _SuperTokensLock.addToWaiting(stopWaiting);
+      let timeOutId = setTimeout(stopWaiting, Math.max(0, MAX_TIME - Date.now()));
+    });
+  }
+  static addToWaiting(func) {
+    this.removeFromWaiting(func);
+    if (_SuperTokensLock.waiters === void 0) {
+      return;
+    }
+    _SuperTokensLock.waiters.push(func);
+  }
+  static removeFromWaiting(func) {
+    if (_SuperTokensLock.waiters === void 0) {
+      return;
+    }
+    _SuperTokensLock.waiters = _SuperTokensLock.waiters.filter((i) => i !== func);
+  }
+  static notifyWaiters() {
+    if (_SuperTokensLock.waiters === void 0) {
+      return;
+    }
+    let waiters = [..._SuperTokensLock.waiters];
+    waiters.forEach((i) => i());
+  }
+  /**
+   * @function releaseLock
+   * @memberOf Lock
+   * @param {string} lockKey - Key for which lock is being released
+   * @returns {void}
+   * @description Release a lock.
+   */
+  async releaseLock(lockKey) {
+    return await this.releaseLock__private__(lockKey);
+  }
+  /**
+   * @function releaseLock
+   * @memberOf Lock
+   * @param {string} lockKey - Key for which lock is being released
+   * @returns {void}
+   * @description Release a lock.
+   */
+  async releaseLock__private__(lockKey) {
+    const STORAGE = this.storageHandler === void 0 ? DEFAULT_STORAGE_HANDLER : this.storageHandler;
+    const STORAGE_KEY = `${LOCK_STORAGE_KEY}-${lockKey}`;
+    let lockObj = STORAGE.getItemSync(STORAGE_KEY);
+    if (lockObj === null) {
+      return;
+    }
+    let parsedlockObj = JSON.parse(lockObj);
+    if (parsedlockObj.id === this.id) {
+      await getLock().lock(parsedlockObj.iat);
+      this.acquiredIatSet.delete(parsedlockObj.iat);
+      STORAGE.removeItemSync(STORAGE_KEY);
+      getLock().unlock(parsedlockObj.iat);
+      _SuperTokensLock.notifyWaiters();
+    }
+  }
+  /**
+   * @function lockCorrector
+   * @returns {void}
+   * @description If a lock is acquired by a tab and the tab is closed before the lock is
+   *              released, this function will release those locks
+   */
+  static lockCorrector(storageHandler) {
+    const MIN_ALLOWED_TIME = Date.now() - 5e3;
+    const STORAGE = storageHandler;
+    const KEYS = [];
+    let currIndex = 0;
+    while (true) {
+      let key = STORAGE.keySync(currIndex);
+      if (key === null) {
+        break;
+      }
+      KEYS.push(key);
+      currIndex++;
+    }
+    let notifyWaiters = false;
+    for (let i = 0; i < KEYS.length; i++) {
+      const LOCK_KEY = KEYS[i];
+      if (LOCK_KEY.includes(LOCK_STORAGE_KEY)) {
+        let lockObj = STORAGE.getItemSync(LOCK_KEY);
+        if (lockObj !== null) {
+          let parsedlockObj = JSON.parse(lockObj);
+          if (parsedlockObj.timeRefreshed === void 0 && parsedlockObj.timeAcquired < MIN_ALLOWED_TIME || parsedlockObj.timeRefreshed !== void 0 && parsedlockObj.timeRefreshed < MIN_ALLOWED_TIME) {
+            STORAGE.removeItemSync(LOCK_KEY);
+            notifyWaiters = true;
+          }
+        }
+      }
+    }
+    if (notifyWaiters) {
+      _SuperTokensLock.notifyWaiters();
+    }
+  }
+};
+_SuperTokensLock.waiters = void 0;
+var SuperTokensLock = _SuperTokensLock;
+
 // src/create-client.ts
-import Lock from "browser-tabs-lock";
 var DEFAULT_HOSTNAME = "api.workos.com";
@@ -316,3 +650,2 @@ async function createClient(clientId, options = {}) {
         refreshSession().catch((e) => {
-          debugger;
           console.error(e);
@@ -326,3 +659,2 @@ }).then(_scheduleAutomaticRefresh);
   async function _initialize() {
-    console.log("HELLO THIS IS THE LINKED VERSION");
     if (_authkitClientState !== "INITIAL") {
@@ -384,4 +716,3 @@ return;
     }
-    console.debug("refreshing...");
-    const lock = new Lock();
+    const lock = new SuperTokensLock();
     try {
@@ -429,5 +760,6 @@ _authkitClientState = "AUTHENTICATING";
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   createClient
-};
+});
 //# sourceMappingURL=index.js.map

package.json

 {
   "name": "@workos-inc/authkit-js",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "AuthKit SDK",
-  "type": "module",
-  "exports": {
-    "import": "./dist/index.js",
-    "require": "./dist/index.cjs"
-  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -34,6 +31,3 @@ "files": [
     "typescript": "^5.5.3"
-  },
-  "dependencies": {
-    "browser-tabs-lock": "^1.3.0"
   }
 }

src/create-client.ts

@@ -17,3 +17,3 @@ import { CreateClientOptions, User } from "./interfaces";
 import { RedirectParams } from "./interfaces/create-client-options.interface";
-import Lock from "browser-tabs-lock";
+import Lock from "./vendor/browser-tabs-lock";
 import { RefreshError } from "./utils/authenticate-with-refresh-token";
@@ -123,3 +123,2 @@
           .catch((e) => {
-            debugger;
             console.error(e);
@@ -135,3 +134,2 @@ })
   async function _initialize() {
-    console.log("HELLO THIS IS THE LINKED VERSION");
     if (_authkitClientState !== "INITIAL") {
@@ -209,5 +207,3 @@ return;
 
-    console.debug("refreshing...");
     const lock = new Lock();
-
     try {
@@ -214,0 +210,0 @@ _authkitClientState = "AUTHENTICATING";

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

178791

increased by191.28%

Dependency count

0

decreased by-100%

Number of package files

36

increased by20%

Lines of code

2443

increased by134%

Worsened metrics

Number of medium supply chain risk alerts

4

increased by100%

Is type module

No

Dependency changes

• - Removedbrowser-tabs-lock@^1.3.0

• - Removedbrowser-tabs-lock@1.3.0(transitive)

• - Removedlodash@4.17.21(transitive)