@leaddreamer/inventorylogic 0.0.3-beta.79 → 0.0.3-beta.80

package/README.md

@@ -97,21 +97,19 @@ services.
 
 
 * [InventoryLogic](#module_InventoryLogic)
-    * _static_
-        * [.databasePromise(firebase, config, thisLogger)](#module_InventoryLogic.databasePromise) ⇒ <code>Promise.Firebase</code>
-    * _inner_
-        * [~FirebaseConfigObject](#module_InventoryLogic..FirebaseConfigObject) : <code>object</code>
+    * [module.exports(firebase, config, thisLogger)](#exp_module_InventoryLogic--module.exports) ⇒ <code>Promise.Firebase</code> ⏏
+        * [~FirebaseConfigObject](#module_InventoryLogic--module.exports..FirebaseConfigObject) : <code>object</code>
 
-<a name="module_InventoryLogic.databasePromise"></a>
+<a name="exp_module_InventoryLogic--module.exports"></a>
 
-### InventoryLogic.databasePromise(firebase, config, thisLogger) ⇒ <code>Promise.Firebase</code>
+### module.exports(firebase, config, thisLogger) ⇒ <code>Promise.Firebase</code> ⏏
 all-in-one wrapper for a solid subset of CLIENT-SIDE Firebase
 functions, with a consistent interface.  There is a parallel set for
 ADMIN-SIDE functions as well.
 Call/initialize with Firebase Configuration settings in an object as
 described below
 
-**Kind**: static method of [<code>InventoryLogic</code>](#module_InventoryLogic)  
+**Kind**: Exported function  
 
 | Param | Type | Description |
 | --- | --- | --- |
@@ -128,13 +126,13 @@ import FirebaseWrapper from "@leaddreamer/firebase-wrapper";
 FirebaseWrapper(config); //see below
 export * from "@leaddreamer/firebase-wrapper";
 ```
-<a name="module_InventoryLogic..FirebaseConfigObject"></a>
+<a name="module_InventoryLogic--module.exports..FirebaseConfigObject"></a>
 
-### InventoryLogic~FirebaseConfigObject : <code>object</code>
+#### module.exports~FirebaseConfigObject : <code>object</code>
 only authDomain, databaseURL and storageBucket are present when
 called from a cloud environment
 
-**Kind**: inner typedef of [<code>InventoryLogic</code>](#module_InventoryLogic)  
+**Kind**: inner typedef of [<code>module.exports</code>](#exp_module_InventoryLogic--module.exports)  
 **Properties**
 
 | Name | Type | Description |
@@ -157,21 +155,19 @@ frontEnd and NodeJS BackEnd
 
 
 * [InventoryLogic](#module_InventoryLogic)
-    * _static_
-        * [.databasePromise(firebase, config, thisLogger)](#module_InventoryLogic.databasePromise) ⇒ <code>Promise.Firebase</code>
-    * _inner_
-        * [~FirebaseConfigObject](#module_InventoryLogic..FirebaseConfigObject) : <code>object</code>
+    * [module.exports(firebase, config, thisLogger)](#exp_module_InventoryLogic--module.exports) ⇒ <code>Promise.Firebase</code> ⏏
+        * [~FirebaseConfigObject](#module_InventoryLogic--module.exports..FirebaseConfigObject) : <code>object</code>
 
-<a name="module_InventoryLogic.databasePromise"></a>
+<a name="exp_module_InventoryLogic--module.exports"></a>
 
-### InventoryLogic.databasePromise(firebase, config, thisLogger) ⇒ <code>Promise.Firebase</code>
+### module.exports(firebase, config, thisLogger) ⇒ <code>Promise.Firebase</code> ⏏
 all-in-one wrapper for a solid subset of CLIENT-SIDE Firebase
 functions, with a consistent interface.  There is a parallel set for
 ADMIN-SIDE functions as well.
 Call/initialize with Firebase Configuration settings in an object as
 described below
 
-**Kind**: static method of [<code>InventoryLogic</code>](#module_InventoryLogic)  
+**Kind**: Exported function  
 
 | Param | Type | Description |
 | --- | --- | --- |
@@ -188,13 +184,13 @@ import FirebaseWrapper from "@leaddreamer/firebase-wrapper";
 FirebaseWrapper(config); //see below
 export * from "@leaddreamer/firebase-wrapper";
 ```
-<a name="module_InventoryLogic..FirebaseConfigObject"></a>
+<a name="module_InventoryLogic--module.exports..FirebaseConfigObject"></a>
 
-### InventoryLogic~FirebaseConfigObject : <code>object</code>
+#### module.exports~FirebaseConfigObject : <code>object</code>
 only authDomain, databaseURL and storageBucket are present when
 called from a cloud environment
 
-**Kind**: inner typedef of [<code>InventoryLogic</code>](#module_InventoryLogic)  
+**Kind**: inner typedef of [<code>module.exports</code>](#exp_module_InventoryLogic--module.exports)  
 **Properties**
 
 | Name | Type | Description |

package/business/Utilities/index.js

@@ -336,3 +336,4 @@ export function choicesForm(fieldname) {
 }
 
 export * from "./other.js";
+export * from "./promise-queue/index.js";

package/business/Utilities/other.js

@@ -4,7 +4,7 @@
  * @module Utilities
  */
 import dayjs from "dayjs";
-import promisePool from "es6-promise-pool";
+//import promisePool from "es6-promise-pool";
 import isSameOrAfter from "dayjs/plugin/isSameOrAfter.js";
 import isSameOrBefore from "dayjs/plugin/isSameOrBefore.js";
 import {
@@ -402,5 +402,3 @@ export function makeHexAsNeeded(color) {
   if (colours[color.toLowerCase()]) return colours[color.toLowerCase()];
   return color;
 }
-
-export * from "./promise-queue/index.js";

package/business/Utilities/promise-queue/index.js

@@ -1,100 +1,132 @@
 /**
  * Typedefs, constants, support functions and database operations related to Promise getQueueSize
- * Thes era euseful for scheduling large serial asynchronous operations
+ * Thes are useful for scheduling large serial asynchronous operations
  * @module PromiseQueue
  */
-(function () {
-  /**
-   * Creates a new rate limited queue. The queue is created with stopped state, i.e. you have to call start() to run jobs.
-   * @param {number} maxCallsPerSecond=1 - The rate limit of this queue in maximum calls per seconds which may be executed at any time. Pass values less than 1 to have less than one call per second, e.g. 1/3 for 3 one call in three seconds at maximum.
-   * @param logger
-   * @constructor
-   */
-  function PromiseQueue(maxCallsPerSecond, logger) {
-    this.maxCallsPerSecond =
-      typeof maxCallsPerSecond === "undefined" ? 1 : maxCallsPerSecond;
-    this.logger = logger;
-
-    this.tasks = [];
-    this.isActive = false;
-    this.jobIntervalMillis = 1000 / maxCallsPerSecond;
-
-    this.lastTaskTimestamp = null;
-    this.currentTaskTimeoutId = null;
-  }
+/**
+ * Creates a new rate limited queue. The queue is created with stopped state, i.e. you have to call start() to run jobs.
+ * @class
+ */
+export class PromiseQueueClass {
+    /**
+     * @param {number} maxCallsPerSecond - The rate limit of this queue in maximum calls per seconds which may be executed at any time. Pass values less than 1 to have less than one call per second, e.g. 1/3 for 3 one call in three seconds at maximum.
+     * @param {callback} logger optional logger function for errors
+     * @constructor
+     */
+    constructor(maxCallsPerSecond=1, logger) {
+        /**
+         * The rate limit of this queue in maximum calls per seconds
+         * which may be executed at any time. Pass values less than 1
+         * to have less than one call per second, e.g. 1/3 for 3 one
+         * call in three seconds at maximum.
+         * @type {float}
+         */
+        this.maxCallsPerSecond =
+            typeof maxCallsPerSecond === "undefined" ? 1 : maxCallsPerSecond;
+        /**
+          *  optional logger function for errors
+          * @type {callback}
+          */
+        this.logger = logger;
+
+        /**
+         * lists of tasks to be processed, in order, in the queue
+         * @type {Array.callback}
+         */
+        this.tasks = [];
+        /**
+         * flag to indicate queue processing is active
+         * @type {boolean}
+         */
+        this.isActive = false;
+        /**
+         * pacing for queue processing / rate limiting
+         * @type {float}
+         */
+        this.jobIntervalMillis = 1000 / maxCallsPerSecond;
+        /**
+         * timestamp of start of last task
+         * @type {time}
+         */
+        this.lastTaskTimestamp = null;
+        /**
+         * @type {string}
+         */
+        this.currentTaskTimeoutId = null;
+    }
 
   /**
    * Processes the next task and returns the id of the time used to wait for the next invocation of this method.
    * @private
    */
-  PromiseQueue.prototype.updateTaskSchedule = function () {
-    if (this.logger && this.logger.debug) {
-      this.logger.debug("PromiseQueue.updateTaskSchedule");
-    }
+  updateTaskSchedule() {
+        if (this.logger && this.logger.debug) {
+            this.logger.debug("PromiseQueue.updateTaskSchedule");
+        }
 
-    if (this.isEmpty() || this.isStopped()) {
-      return;
-    }
+        if (this.isEmpty() || this.isStopped()) {
+            return;
+        }
 
-    const queue = this;
-
-    function processNextTask() {
-      if (queue.logger && queue.logger.debug) {
-        queue.logger.debug("PromiseQueue.processNextTask", queue.tasks.length);
-      }
-
-      var nextTaskItem = queue.tasks.shift();
-      if (nextTaskItem) {
-        try {
-          const result = nextTaskItem.task.call();
-
-          if (queue.logger && queue.logger.debug) {
-            queue.logger.debug(
-              "Resolving queued promise",
-              result,
-              result instanceof Promise
-            );
-          }
-
-          nextTaskItem.resolve(result);
-        } catch (e) {
-          queue.logger.info("rejecting queued promise result", e);
-          nextTaskItem.reject(e);
+        const queue = this;
+
+        function processNextTask() {
+            if (queue.logger && queue.logger.debug) {
+                queue.logger.debug("PromiseQueue.processNextTask", queue.tasks.length);
+            }
+
+            var nextTaskItem = queue.tasks.shift();
+            if (nextTaskItem) {
+                try {
+                    const result = nextTaskItem.task.call();
+
+                    if (queue.logger && queue.logger.debug) {
+                        queue.logger.debug(
+                            "Resolving queued promise",
+                            result,
+                            result instanceof Promise
+                        );
+                    }
+
+                    nextTaskItem.resolve(result);
+                } catch (e) {
+                    queue.logger.info("rejecting queued promise result", e);
+                    nextTaskItem.reject(e);
+                }
+            }
         }
-      }
-    }
 
-    function scheduleNext(timeoutMillisOverride) {
-      if (queue.logger && queue.logger.debug) {
-        queue.logger.debug("PromiseQueue.scheduleNext", timeoutMillisOverride);
-      }
+        function scheduleNext(timeoutMillisOverride) {
+            if (queue.logger && queue.logger.debug) {
+                queue.logger.debug("PromiseQueue.scheduleNext", timeoutMillisOverride);
+            }
 
-      if (queue.isEmpty()) {
-        queue.currentTaskTimeoutId = null;
-        return;
-      }
+            if (queue.isEmpty()) {
+                queue.currentTaskTimeoutId = null;
+                return;
+            }
 
-      queue.currentTaskTimeoutId = setTimeout(function () {
-        queue.lastTaskTimestamp = Date.now();
-        processNextTask();
+            queue.currentTaskTimeoutId = setTimeout(function () {
+                queue.lastTaskTimestamp = Date.now();
+                processNextTask();
 
-        scheduleNext(queue.jobIntervalMillis);
-      }, timeoutMillisOverride);
-    }
+                scheduleNext(queue.jobIntervalMillis);
+            }, timeoutMillisOverride);
+        }
 
-    if (this.currentTaskTimeoutId == null) {
-      if (this.lastTaskTimestamp) {
-        let passedTime = Date.now() - this.lastTaskTimestamp;
-        if (passedTime > this.jobIntervalMillis) {
-          scheduleNext(this.jobIntervalMillis);
-        } else {
-          scheduleNext(Math.max(0, this.jobIntervalMillis - passedTime));
+        if (this.currentTaskTimeoutId == null) {
+            if (this.lastTaskTimestamp) {
+                let passedTime = Date.now() - this.lastTaskTimestamp;
+                if (passedTime > this.jobIntervalMillis) {
+                    scheduleNext(this.jobIntervalMillis);
+                } else {
+                    scheduleNext(Math.max(0, this.jobIntervalMillis - passedTime));
+                }
+            } else {
+                scheduleNext(0);
+            }
         }
-      } else {
-        scheduleNext(0);
-      }
-    }
-  };
+    };
 
   /**
    * Starts the task processing of this queue.
@@ -104,128 +136,129 @@
    *
    * @return {boolean} true if this queue wasn't started before and now started to process tasks.
    */
-  PromiseQueue.prototype.start = function () {
-    if (this.isActive) {
-      return false;
-    }
+  start() {
+        if (this.isActive) {
+            return false;
+        }
 
-    this.isActive = true;
+        this.isActive = true;
 
-    this.updateTaskSchedule();
+        this.updateTaskSchedule();
 
-    return true;
-  };
+        return true;
+    };
 
   /**
    * Stops the processing of this queue.
    * @return true if the queue was started and is now stopped. false if it was already stopped.
    */
-  PromiseQueue.prototype.stop = function () {
-    if (this.isActive) {
-      this.isActive = false;
-
-      if (this.currentTaskTimeoutId) {
-        clearInterval(this.currentTaskTimeoutId);
-        this.currentTaskTimeoutId = null;
-        this.lastTaskTimestamp = null;
-      }
-    }
-  };
+  stop() {
+        if (this.isActive) {
+            this.isActive = false;
+
+            if (this.currentTaskTimeoutId) {
+                clearInterval(this.currentTaskTimeoutId);
+                this.currentTaskTimeoutId = null;
+                this.lastTaskTimestamp = null;
+            }
+        }
+    };
 
-  PromiseQueue.prototype.getMaxCallsPerSecond = function () {
-    return this.maxCallsPerSecond;
-  };
+  getMaxCallsPerSecond() {
+        return this.maxCallsPerSecond;
+    };
 
-  PromiseQueue.prototype.isStarted = function () {
-    return this.isActive;
-  };
+  isStarted() {
+        return this.isActive;
+    };
 
-  PromiseQueue.prototype.isStopped = function () {
-    return !this.isStarted();
-  };
+  isStopped() {
+        return !this.isStarted();
+    };
 
   /**
    * @returns {boolean} true if this queue is currently empty, i.e. if it has no tasks in the queue.
    */
-  PromiseQueue.prototype.isEmpty = function () {
-    return this.tasks.length === 0;
-  };
+  isEmpty() {
+        return this.tasks.length === 0;
+    };
 
   /**
    * @returns {boolean} true if this queue has one or more entries.
    */
-  PromiseQueue.prototype.isNotEmpty = function () {
-    return !this.isEmpty();
-  };
+  isNotEmpty() {
+        return !this.isEmpty();
+    };
 
   /**
    * @param {function} task - The task to add.
    * @param {boolean} append - if the task should be appended or prepended to the list of queued tasks
    * @return {Promise} A promise which is resolved/rejected when the task was executed by the queue.
    */
-  PromiseQueue.prototype.add = function (task, append) {
-    var self = this;
+  async add(task, append) {
+        var self = this;
 
-    var promise = new Promise(function (resolve, reject) {
-      var newTaskItem = { task: task, resolve: resolve, reject: reject };
+        var promise = new Promise(function (resolve, reject) {
+            var newTaskItem = { task: task, resolve: resolve, reject: reject };
 
-      if (self.isEmpty() || append) {
-        self.tasks.push(newTaskItem);
-      } else {
-        self.tasks.unshift(newTaskItem);
-      }
-    });
+            if (self.isEmpty() || append) {
+                self.tasks.push(newTaskItem);
+            } else {
+                self.tasks.unshift(newTaskItem);
+            }
+        });
 
-    self.updateTaskSchedule();
+        self.updateTaskSchedule();
 
-    return promise;
-  };
+        return promise;
+    };
 
   /**
    * Appends a new task at the end of the queue.
    * @param {function} task - The task to perform. This function will be called with no arguments.
    * @return {Promise} A promise which is resolved/rejected When the task was executed by the queue
    */
-  PromiseQueue.prototype.append = function (task) {
-    return this.add(task, true);
-  };
+  async append(task) {
+        return this.add(task, true);
+    };
 
   /**
    * Adds a new task as first item in the queue.
    * @param task
    * @return {Promise} A promise which is resolved/rejected When the task was executed by the queue
    */
-  PromiseQueue.prototype.prepend = function (task) {
-    return this.add(task, false);
-  };
+ async prepend(task) {
+        return this.add(task, false);
+    };
 
   /**
    * Removes the task from the qeueue. If the task is contained more than one time then all occurrences will be removed.
    * @param {function} task - The task to remove.
    * @return {number} - The number of items which were removed.
    */
-  PromiseQueue.prototype.remove = function (task) {
-    if (this.isEmpty()) {
-      return 0;
-    }
+  remove(task) {
+        if (this.isEmpty()) {
+            return 0;
+        }
 
-    var removedItems = 0;
-    for (var i = this.tasks.length - 1; i >= 0; i--) {
-      if (this.tasks[i].task === task) {
-        this.tasks.splice(i, 1);
-        removedItems++;
-      }
-    }
+        var removedItems = 0;
+        for (var i = this.tasks.length - 1; i >= 0; i--) {
+            if (this.tasks[i].task === task) {
+                this.tasks.splice(i, 1);
+                removedItems++;
+            }
+        }
 
-    return removedItems;
-  };
+        return removedItems;
+    };
 
   /**
    * @returns {Number} - The number of queued/waiting tasks in the queue.
    */
-  PromiseQueue.prototype.getQueueSize = function () {
-    return this.tasks.length;
-  };
+  getQueueSize() {
+        return this.tasks.length;
+    };
+
+};
 
-  module.exports = PromiseQueue;
-})();
+export default PromiseQueue = new PromiseQueueClass(1, null);