@loaders.gl/loader-utils 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/lib/path-utils/file-aliases.js

@@ -1,24 +1,40 @@
+// Simple file alias mechanisms for tests.
 let pathPrefix = '';
 const fileAliases = {};
+/*
+ * Set a relative path prefix
+ */
 export function setPathPrefix(prefix) {
-  pathPrefix = prefix;
+    pathPrefix = prefix;
 }
+/*
+ * Get the relative path prefix
+ */
 export function getPathPrefix() {
-  return pathPrefix;
+    return pathPrefix;
 }
+/**
+ *
+ * @param aliases
+ *
+ * Note: addAliases are an experimental export, they are only for testing of loaders.gl loaders
+ * not intended as a generic aliasing mechanism
+ */
 export function addAliases(aliases) {
-  Object.assign(fileAliases, aliases);
+    Object.assign(fileAliases, aliases);
 }
+/**
+ * Resolves aliases and adds path-prefix to paths
+ */
 export function resolvePath(filename) {
-  for (const alias in fileAliases) {
-    if (filename.startsWith(alias)) {
-      const replacement = fileAliases[alias];
-      filename = filename.replace(alias, replacement);
+    for (const alias in fileAliases) {
+        if (filename.startsWith(alias)) {
+            const replacement = fileAliases[alias];
+            filename = filename.replace(alias, replacement);
+        }
     }
-  }
-  if (!filename.startsWith('http://') && !filename.startsWith('https://')) {
-    filename = `${pathPrefix}${filename}`;
-  }
-  return filename;
+    if (!filename.startsWith('http://') && !filename.startsWith('https://')) {
+        filename = `${pathPrefix}${filename}`;
+    }
+    return filename;
 }
-//# sourceMappingURL=file-aliases.js.map

package/dist/lib/path-utils/get-cwd.js

@@ -1,9 +1,8 @@
+// loaders.gl MIT license
 export function getCWD() {
-  var _window$location;
-  if (typeof process !== 'undefined' && typeof process.cwd !== 'undefined') {
-    return process.cwd();
-  }
-  const pathname = (_window$location = window.location) === null || _window$location === void 0 ? void 0 : _window$location.pathname;
-  return (pathname === null || pathname === void 0 ? void 0 : pathname.slice(0, pathname.lastIndexOf('/') + 1)) || '';
+    if (typeof process !== 'undefined' && typeof process.cwd !== 'undefined') {
+        return process.cwd();
+    }
+    const pathname = window.location?.pathname;
+    return pathname?.slice(0, pathname.lastIndexOf('/') + 1) || '';
 }
-//# sourceMappingURL=get-cwd.js.map

package/dist/lib/path-utils/path.js

@@ -1,127 +1,171 @@
+// Beginning of a minimal implementation of the Node.js path API, that doesn't pull in big polyfills.
 import { getCWD } from "./get-cwd.js";
+/**
+ * Replacement for Node.js path.filename
+ * @param url
+ */
 export function filename(url) {
-  const slashIndex = url ? url.lastIndexOf('/') : -1;
-  return slashIndex >= 0 ? url.substr(slashIndex + 1) : '';
+    const slashIndex = url ? url.lastIndexOf('/') : -1;
+    return slashIndex >= 0 ? url.substr(slashIndex + 1) : '';
 }
+/**
+ * Replacement for Node.js path.dirname
+ * @param url
+ */
 export function dirname(url) {
-  const slashIndex = url ? url.lastIndexOf('/') : -1;
-  return slashIndex >= 0 ? url.substr(0, slashIndex) : '';
+    const slashIndex = url ? url.lastIndexOf('/') : -1;
+    return slashIndex >= 0 ? url.substr(0, slashIndex) : '';
 }
-export function join() {
-  for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) {
-    parts[_key] = arguments[_key];
-  }
-  const separator = '/';
-  parts = parts.map((part, index) => {
-    if (index) {
-      part = part.replace(new RegExp(`^${separator}`), '');
+/**
+ * Replacement for Node.js path.join
+ * @param parts
+ */
+export function join(...parts) {
+    const separator = '/';
+    parts = parts.map((part, index) => {
+        if (index) {
+            part = part.replace(new RegExp(`^${separator}`), '');
+        }
+        if (index !== parts.length - 1) {
+            part = part.replace(new RegExp(`${separator}$`), '');
+        }
+        return part;
+    });
+    return parts.join(separator);
+}
+/* eslint-disable no-continue */
+/**
+ * https://nodejs.org/api/path.html#path_path_resolve_paths
+ * @param paths A sequence of paths or path segments.
+ * @return resolved path
+ * Forked from BTOdell/path-resolve under MIT license
+ * @see https://github.com/BTOdell/path-resolve/blob/master/LICENSE
+ */
+export function resolve(...components) {
+    const paths = [];
+    for (let _i = 0; _i < components.length; _i++) {
+        paths[_i] = components[_i];
     }
-    if (index !== parts.length - 1) {
-      part = part.replace(new RegExp(`${separator}$`), '');
+    let resolvedPath = '';
+    let resolvedAbsolute = false;
+    let cwd;
+    for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        let path;
+        if (i >= 0) {
+            path = paths[i];
+        }
+        else {
+            if (cwd === undefined) {
+                cwd = getCWD();
+            }
+            path = cwd;
+        }
+        // Skip empty entries
+        if (path.length === 0) {
+            continue;
+        }
+        resolvedPath = `${path}/${resolvedPath}`;
+        resolvedAbsolute = path.charCodeAt(0) === SLASH;
     }
-    return part;
-  });
-  return parts.join(separator);
-}
-export function resolve() {
-  const paths = [];
-  for (let _i = 0; _i < arguments.length; _i++) {
-    paths[_i] = _i < 0 || arguments.length <= _i ? undefined : arguments[_i];
-  }
-  let resolvedPath = '';
-  let resolvedAbsolute = false;
-  let cwd;
-  for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    let path;
-    if (i >= 0) {
-      path = paths[i];
-    } else {
-      if (cwd === undefined) {
-        cwd = getCWD();
-      }
-      path = cwd;
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+    // Normalize the path (removes leading slash)
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+        return `/${resolvedPath}`;
     }
-    if (path.length === 0) {
-      continue;
+    else if (resolvedPath.length > 0) {
+        return resolvedPath;
     }
-    resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = path.charCodeAt(0) === SLASH;
-  }
-  resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute) {
-    return `/${resolvedPath}`;
-  } else if (resolvedPath.length > 0) {
-    return resolvedPath;
-  }
-  return '.';
+    return '.';
 }
 const SLASH = 47;
 const DOT = 46;
+/**
+ * Resolves . and .. elements in a path with directory names
+ * Forked from BTOdell/path-resolve under MIT license
+ * @see https://github.com/BTOdell/path-resolve/blob/master/LICENSE
+ */
+/* eslint-disable max-depth */
+// eslint-disable-next-line complexity, max-statements
 function normalizeStringPosix(path, allowAboveRoot) {
-  let res = '';
-  let lastSlash = -1;
-  let dots = 0;
-  let code;
-  let isAboveRoot = false;
-  for (let i = 0; i <= path.length; ++i) {
-    if (i < path.length) {
-      code = path.charCodeAt(i);
-    } else if (code === SLASH) {
-      break;
-    } else {
-      code = SLASH;
-    }
-    if (code === SLASH) {
-      if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) {
-        if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
-          if (res.length > 2) {
-            const start = res.length - 1;
-            let j = start;
-            for (; j >= 0; --j) {
-              if (res.charCodeAt(j) === SLASH) {
-                break;
-              }
+    let res = '';
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    let isAboveRoot = false;
+    for (let i = 0; i <= path.length; ++i) {
+        if (i < path.length) {
+            code = path.charCodeAt(i);
+        }
+        else if (code === SLASH) {
+            break;
+        }
+        else {
+            code = SLASH;
+        }
+        if (code === SLASH) {
+            if (lastSlash === i - 1 || dots === 1) {
+                // NOOP
+            }
+            else if (lastSlash !== i - 1 && dots === 2) {
+                if (res.length < 2 ||
+                    !isAboveRoot ||
+                    res.charCodeAt(res.length - 1) !== DOT ||
+                    res.charCodeAt(res.length - 2) !== DOT) {
+                    if (res.length > 2) {
+                        const start = res.length - 1;
+                        let j = start;
+                        for (; j >= 0; --j) {
+                            if (res.charCodeAt(j) === SLASH) {
+                                break;
+                            }
+                        }
+                        if (j !== start) {
+                            res = j === -1 ? '' : res.slice(0, j);
+                            lastSlash = i;
+                            dots = 0;
+                            isAboveRoot = false;
+                            continue;
+                        }
+                    }
+                    else if (res.length === 2 || res.length === 1) {
+                        res = '';
+                        lastSlash = i;
+                        dots = 0;
+                        isAboveRoot = false;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    if (res.length > 0) {
+                        res += '/..';
+                    }
+                    else {
+                        res = '..';
+                    }
+                    isAboveRoot = true;
+                }
             }
-            if (j !== start) {
-              res = j === -1 ? '' : res.slice(0, j);
-              lastSlash = i;
-              dots = 0;
-              isAboveRoot = false;
-              continue;
+            else {
+                const slice = path.slice(lastSlash + 1, i);
+                if (res.length > 0) {
+                    res += `/${slice}`;
+                }
+                else {
+                    res = slice;
+                }
+                isAboveRoot = false;
             }
-          } else if (res.length === 2 || res.length === 1) {
-            res = '';
             lastSlash = i;
             dots = 0;
-            isAboveRoot = false;
-            continue;
-          }
         }
-        if (allowAboveRoot) {
-          if (res.length > 0) {
-            res += '/..';
-          } else {
-            res = '..';
-          }
-          isAboveRoot = true;
+        else if (code === DOT && dots !== -1) {
+            ++dots;
         }
-      } else {
-        const slice = path.slice(lastSlash + 1, i);
-        if (res.length > 0) {
-          res += `/${slice}`;
-        } else {
-          res = slice;
+        else {
+            dots = -1;
         }
-        isAboveRoot = false;
-      }
-      lastSlash = i;
-      dots = 0;
-    } else if (code === DOT && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
     }
-  }
-  return res;
+    return res;
 }
-//# sourceMappingURL=path.js.map

package/dist/lib/request-utils/request-scheduler.d.ts

@@ -10,6 +10,7 @@ export type RequestSchedulerProps = {
     id?: string;
     throttleRequests?: boolean;
     maxRequests?: number;
+    debounceTime?: number;
 };
 /** Tracks one request */
 type Request = {
@@ -29,7 +30,7 @@ export default class RequestScheduler {
     /** Tracks the number of active requests and prioritizes/cancels queued requests. */
     private requestQueue;
     private requestMap;
-    private deferredUpdate;
+    private updateTimer;
     constructor(props?: RequestSchedulerProps);
     /**
      * Called by an application that wants to issue a request, without having it deeply queued by the browser

package/dist/lib/request-utils/request-scheduler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-scheduler.d.ts","sourceRoot":"","sources":["../../../src/lib/request-utils/request-scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAEtC,KAAK,MAAM,GAAG,GAAG,CAAC;AAClB,KAAK,YAAY,GAAG,MAAM,GAAG,CAAC;AAC9B,KAAK,mBAAmB,GAAG,MAAM,MAAM,CAAC;AACxC,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,YAAY,CAAC;CACpB,GAAG,IAAI,CAAC;AAET,+BAA+B;AAC/B,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAgBF,yBAAyB;AACzB,KAAK,OAAO,GAAG;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;CAC/B,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,qBAAqB,CAAC,CAAC;IAChD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAK;IAE/B,oFAAoF;IACpF,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,UAAU,CAAkD;IACpE,OAAO,CAAC,cAAc,CAAa;gBAEvB,KAAK,GAAE,qBAA0B;IAY7C;;;;;;;;;;;;;;;OAeG;IACH,eAAe,CACb,MAAM,EAAE,MAAM,EACd,WAAW,GAAE,mBAA6B,GACzC,OAAO,CAAC,aAAa,CAAC;IA0BzB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;IAuB7C,oEAAoE;IACpE,iBAAiB,IAAI,IAAI;IAMzB,4BAA4B;IAC5B,sBAAsB;IAwBtB,mGAAmG;IACnG,kBAAkB;IAgBlB,sDAAsD;IACtD,cAAc,CAAC,OAAO,KAAA;CAUvB"}
+{"version":3,"file":"request-scheduler.d.ts","sourceRoot":"","sources":["../../../src/lib/request-utils/request-scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAEtC,KAAK,MAAM,GAAG,GAAG,CAAC;AAClB,KAAK,YAAY,GAAG,MAAM,GAAG,CAAC;AAC9B,KAAK,mBAAmB,GAAG,MAAM,MAAM,CAAC;AACxC,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,YAAY,CAAC;CACpB,GAAG,IAAI,CAAC;AAET,+BAA+B;AAC/B,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAqBF,yBAAyB;AACzB,KAAK,OAAO,GAAG;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;CAC/B,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,qBAAqB,CAAC,CAAC;IAChD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAK;IAE/B,oFAAoF;IACpF,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,UAAU,CAAkD;IACpE,OAAO,CAAC,WAAW,CAA8C;gBAErD,KAAK,GAAE,qBAA0B;IAY7C;;;;;;;;;;;;;;;OAeG;IACH,eAAe,CACb,MAAM,EAAE,MAAM,EACd,WAAW,GAAE,mBAA6B,GACzC,OAAO,CAAC,aAAa,CAAC;IA0BzB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;IAuB7C,oEAAoE;IACpE,iBAAiB,IAAI,IAAI;IAOzB,4BAA4B;IAC5B,sBAAsB;IA0BtB,mGAAmG;IACnG,kBAAkB;IAgBlB,sDAAsD;IACtD,cAAc,CAAC,OAAO,KAAA;CAUvB"}

package/dist/lib/request-utils/request-scheduler.js

@@ -5,115 +5,143 @@ const STAT_CANCELLED_REQUESTS = 'Cancelled Requests';
 const STAT_QUEUED_REQUESTS_EVER = 'Queued Requests Ever';
 const STAT_ACTIVE_REQUESTS_EVER = 'Active Requests Ever';
 const DEFAULT_PROPS = {
-  id: 'request-scheduler',
-  throttleRequests: true,
-  maxRequests: 6
+    id: 'request-scheduler',
+    /** Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing. */
+    throttleRequests: true,
+    /** The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit. */
+    maxRequests: 6,
+    /**
+     * Specifies a debounce time, in milliseconds. All requests are queued, until no new requests have
+     * been added to the queue for this amount of time.
+     */
+    debounceTime: 0
 };
+/**
+ * Used to issue a request, without having them "deeply queued" by the browser.
+ * @todo - Track requests globally, across multiple servers
+ */
 export default class RequestScheduler {
-  constructor() {
-    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this.props = void 0;
-    this.stats = void 0;
-    this.activeRequestCount = 0;
-    this.requestQueue = [];
-    this.requestMap = new Map();
-    this.deferredUpdate = null;
-    this.props = {
-      ...DEFAULT_PROPS,
-      ...props
-    };
-    this.stats = new Stats({
-      id: this.props.id
-    });
-    this.stats.get(STAT_QUEUED_REQUESTS);
-    this.stats.get(STAT_ACTIVE_REQUESTS);
-    this.stats.get(STAT_CANCELLED_REQUESTS);
-    this.stats.get(STAT_QUEUED_REQUESTS_EVER);
-    this.stats.get(STAT_ACTIVE_REQUESTS_EVER);
-  }
-  scheduleRequest(handle) {
-    let getPriority = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => 0;
-    if (!this.props.throttleRequests) {
-      return Promise.resolve({
-        done: () => {}
-      });
+    constructor(props = {}) {
+        this.activeRequestCount = 0;
+        /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+        this.requestQueue = [];
+        this.requestMap = new Map();
+        this.updateTimer = null;
+        this.props = { ...DEFAULT_PROPS, ...props };
+        // Returns the statistics used by the request scheduler.
+        this.stats = new Stats({ id: this.props.id });
+        this.stats.get(STAT_QUEUED_REQUESTS);
+        this.stats.get(STAT_ACTIVE_REQUESTS);
+        this.stats.get(STAT_CANCELLED_REQUESTS);
+        this.stats.get(STAT_QUEUED_REQUESTS_EVER);
+        this.stats.get(STAT_ACTIVE_REQUESTS_EVER);
     }
-    if (this.requestMap.has(handle)) {
-      return this.requestMap.get(handle);
-    }
-    const request = {
-      handle,
-      priority: 0,
-      getPriority
-    };
-    const promise = new Promise(resolve => {
-      request.resolve = resolve;
-      return request;
-    });
-    this.requestQueue.push(request);
-    this.requestMap.set(handle, promise);
-    this._issueNewRequests();
-    return promise;
-  }
-  _issueRequest(request) {
-    const {
-      handle,
-      resolve
-    } = request;
-    let isDone = false;
-    const done = () => {
-      if (!isDone) {
-        isDone = true;
-        this.requestMap.delete(handle);
-        this.activeRequestCount--;
+    /**
+     * Called by an application that wants to issue a request, without having it deeply queued by the browser
+     *
+     * When the returned promise resolved, it is OK for the application to issue a request.
+     * The promise resolves to an object that contains a `done` method.
+     * When the application's request has completed (or failed), the application must call the `done` function
+     *
+     * @param handle
+     * @param getPriority will be called when request "slots" open up,
+     *    allowing the caller to update priority or cancel the request
+     *    Highest priority executes first, priority < 0 cancels the request
+     * @returns a promise
+     *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
+     *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
+     *     In this case the application should not issue the request
+     */
+    scheduleRequest(handle, getPriority = () => 0) {
+        // Allows throttling to be disabled
+        if (!this.props.throttleRequests) {
+            return Promise.resolve({ done: () => { } });
+        }
+        // dedupe
+        if (this.requestMap.has(handle)) {
+            return this.requestMap.get(handle);
+        }
+        const request = { handle, priority: 0, getPriority };
+        const promise = new Promise((resolve) => {
+            // @ts-ignore
+            request.resolve = resolve;
+            return request;
+        });
+        this.requestQueue.push(request);
+        this.requestMap.set(handle, promise);
         this._issueNewRequests();
-      }
-    };
-    this.activeRequestCount++;
-    return resolve ? resolve({
-      done
-    }) : Promise.resolve({
-      done
-    });
-  }
-  _issueNewRequests() {
-    if (!this.deferredUpdate) {
-      this.deferredUpdate = setTimeout(() => this._issueNewRequestsAsync(), 0);
+        return promise;
+    }
+    // PRIVATE
+    _issueRequest(request) {
+        const { handle, resolve } = request;
+        let isDone = false;
+        const done = () => {
+            // can only be called once
+            if (!isDone) {
+                isDone = true;
+                // Stop tracking a request - it has completed, failed, cancelled etc
+                this.requestMap.delete(handle);
+                this.activeRequestCount--;
+                // A slot just freed up, see if any queued requests are waiting
+                this._issueNewRequests();
+            }
+        };
+        // Track this request
+        this.activeRequestCount++;
+        return resolve ? resolve({ done }) : Promise.resolve({ done });
     }
-  }
-  _issueNewRequestsAsync() {
-    this.deferredUpdate = null;
-    const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0);
-    if (freeSlots === 0) {
-      return;
+    /** We check requests asynchronously, to prevent multiple updates */
+    _issueNewRequests() {
+        if (this.updateTimer !== null) {
+            clearTimeout(this.updateTimer);
+        }
+        this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
     }
-    this._updateAllRequests();
-    for (let i = 0; i < freeSlots; ++i) {
-      const request = this.requestQueue.shift();
-      if (request) {
-        this._issueRequest(request);
-      }
+    /** Refresh all requests  */
+    _issueNewRequestsAsync() {
+        if (this.updateTimer !== null) {
+            clearTimeout(this.updateTimer);
+        }
+        this.updateTimer = null;
+        const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0);
+        if (freeSlots === 0) {
+            return;
+        }
+        this._updateAllRequests();
+        // Resolve pending promises for the top-priority requests
+        for (let i = 0; i < freeSlots; ++i) {
+            const request = this.requestQueue.shift();
+            if (request) {
+                this._issueRequest(request); // eslint-disable-line @typescript-eslint/no-floating-promises
+            }
+        }
+        // Uncomment to debug
+        // console.log(`${freeSlots} free slots, ${this.requestQueue.length} queued requests`);
     }
-  }
-  _updateAllRequests() {
-    const requestQueue = this.requestQueue;
-    for (let i = 0; i < requestQueue.length; ++i) {
-      const request = requestQueue[i];
-      if (!this._updateRequest(request)) {
-        requestQueue.splice(i, 1);
-        this.requestMap.delete(request.handle);
-        i--;
-      }
+    /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
+    _updateAllRequests() {
+        const requestQueue = this.requestQueue;
+        for (let i = 0; i < requestQueue.length; ++i) {
+            const request = requestQueue[i];
+            if (!this._updateRequest(request)) {
+                // Remove the element and make sure to adjust the counter to account for shortened array
+                requestQueue.splice(i, 1);
+                this.requestMap.delete(request.handle);
+                i--;
+            }
+        }
+        // Sort the remaining requests based on priority
+        requestQueue.sort((a, b) => a.priority - b.priority);
     }
-    requestQueue.sort((a, b) => a.priority - b.priority);
-  }
-  _updateRequest(request) {
-    request.priority = request.getPriority(request.handle);
-    if (request.priority < 0) {
-      request.resolve(null);
-      return false;
+    /** Update a single request by calling the callback */
+    _updateRequest(request) {
+        request.priority = request.getPriority(request.handle); // eslint-disable-line callback-return
+        // by returning a negative priority, the callback cancels the request
+        if (request.priority < 0) {
+            request.resolve(null);
+            return false;
+        }
+        return true;
     }
-    return true;
-  }
 }
-//# sourceMappingURL=request-scheduler.js.map