@highstate/designer 0.4.4 → 0.4.5

package/.output/server/node_modules/better-lock/dist/better_lock.js

@@ -0,0 +1,377 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterLock = void 0;
+var errors_1 = require("./errors");
+var internals_1 = require("./internals");
+var tools = require("./tools");
+/**
+ * Main better lock class.
+ */
+var BetterLock = /** @class */ (function () {
+    /**
+     * Create a better lock instance
+     */
+    function BetterLock(options) {
+        this.options = tools.assign({}, [BetterLock.DEFAULT_OPTIONS, options]);
+        this.log = tools.makeLog(this.options.name, this.options.log);
+        this.queues = {};
+    }
+    /**
+     * Return or create a key queue for given key
+     */
+    BetterLock.prototype.getQueue = function (key) {
+        if (key === undefined || key === null) {
+            key = internals_1.KeyQueue.DEFAULT_QUEUE_KEY;
+        }
+        var queue = this.queues[key];
+        if (!queue) {
+            queue = this.queues[key] = new internals_1.KeyQueue(String(key));
+        }
+        return queue;
+    };
+    /**
+     * Returns true if the caller can *immediately* acquire the lock. There is nothing holding the key and nothing in the queue.
+     */
+    BetterLock.prototype.canAcquire = function (key) {
+        var queue = this.getQueue(key);
+        return !queue.active && !queue.jobs.length;
+    };
+    BetterLock.prototype.normalizeAndValidateKey = function (key) {
+        if (key === undefined) {
+            return null;
+        }
+        if (key === null) {
+            return null;
+        }
+        if (tools.isString(key)) {
+            return key;
+        }
+        if (tools.isNumber(key)) {
+            return String(key);
+        }
+        // Invalid key value
+        throw new errors_1.BetterLockInvalidArgumentError(this.options.name, 'key', 'an instance of ILockKey: string, number, undefined or null', key);
+    };
+    /**
+     * Acquire the lock for given key or list of keys. If waiting on a list, keys will be acquired in order,
+     * as they become free. Any deadlock prevention must be handled by the caller.
+     *
+     * Once the lock is acquired, we will call the executor function, with a "done" method.
+     * You must call "done" to release the lock. Alternatively, return a Promise; lock will be released
+     * once promise resolves or rejects.
+     *
+     * Return values from your executor will be passed to callback (or the resulting promise).
+     *
+     * @param key Named key or array of keys for this particular call. Calls with different keys will be run in parallel. Not required.
+     * @param executor Function that will run inside the lock. Required.
+     * @param callback Function to be called after the executor finishes or if we never enter the lock (timeout, queue depletion). Leave out to use promises.
+     * @param jobOptions Options to be applied on this job only
+     */
+    BetterLock.prototype.acquire = function (key, executor, callback, jobOptions) {
+        var _this = this;
+        if (tools.isFunction(key)) {
+            // Presume we weren't given a key (first form)
+            jobOptions = callback;
+            callback = executor;
+            executor = key;
+            key = null;
+        }
+        // Create callback wrapper for promise interface
+        if (!tools.isFunction(callback)) {
+            if (jobOptions === undefined) {
+                jobOptions = callback;
+            }
+            callback = tools.callbackWithPromise();
+        }
+        // Prepare job options
+        var effectiveJobOptions = jobOptions
+            ? tools.assign({}, [this.options, jobOptions])
+            : // No need to create new object since these will be read-only and are subset of global options
+                this.options;
+        // Repackage "key" into an array of keys, but only if lock_condition allows it.
+        // Otherwise, it stays an array and gets executed immediately.
+        var keys = [];
+        if (!effectiveJobOptions.lock_condition || effectiveJobOptions.lock_condition(key)) {
+            if (Array.isArray(key)) {
+                var arrayOfKeys = key;
+                // Make sure we don't add duplicates
+                var seenKeys = new Set();
+                for (var i = 0; i < arrayOfKeys.length; i++) {
+                    var normalizedKey = this.normalizeAndValidateKey(arrayOfKeys[i]);
+                    if (!seenKeys.has(normalizedKey)) {
+                        keys.push(normalizedKey);
+                        seenKeys.add(normalizedKey);
+                    }
+                }
+            }
+            else {
+                keys.push(this.normalizeAndValidateKey(key));
+            }
+        }
+        // Validate other options
+        if (!tools.isFunction(executor)) {
+            throw new errors_1.BetterLockInvalidArgumentError(this.options.name, 'executor', 'a function', executor);
+        }
+        if (!tools.isFunction(callback)) {
+            throw new errors_1.BetterLockInvalidArgumentError(this.options.name, 'callback', 'a function', callback);
+        }
+        var job = new internals_1.LockJob(keys, executor, callback, effectiveJobOptions);
+        // Set incoming stack
+        if (effectiveJobOptions.extend_stack_traces) {
+            var tempErr = new Error();
+            Error.captureStackTrace(tempErr, this.acquire);
+            job.incoming_stack = tempErr.stack;
+        }
+        // Add job to its key queues
+        var queuesToUpdate = [];
+        for (var i = 0; i < keys.length; i++) {
+            var queue = this.getQueue(keys[i]);
+            queue.jobs.push(job);
+            queuesToUpdate.push(queue);
+        }
+        // Start wait timer, if enabled
+        if (tools.isNumber(job.options.wait_timeout)) {
+            job.wait_timeout_id = setTimeout(function () { return _this.onWaitTimeout(job); }, job.options.wait_timeout);
+            // NOTE: timeout of 0 will NOT trigger error if lock can be acquired immediately.
+        }
+        this.log("Enqueued ".concat(job));
+        // Perform update of queues this job has modified. We don't do this in next tick or something,
+        // because we want canAcquire to immediately return false
+        if (queuesToUpdate.length) {
+            this.update(queuesToUpdate);
+        }
+        else {
+            // Special case. We are given empty list of keys. We will immediately execute jobs like this.
+            this.executeJob(job);
+        }
+        return callback.promise;
+    };
+    /**
+     * The same as acquire, except if the lock can't be acquired (the executor never gets called), instead of throwing
+     * an error, the lock will resolve/callback with the provided failureResult value (for example, a `null`).
+     * @param key Named key or array of keys for this particular call. Calls with different keys will be run in parallel. Not required.
+     * @param failureResult The value to return if the executor never get called. This happens instead of rejecting.
+     * @param executor Function that will run inside the lock. Required.
+     * @param callback Function to be called after the executor finishes, or there is an execution timeout. Leave out to use promises.
+     * @param jobOptions Options to be applied on this job only
+     */
+    BetterLock.prototype.acquireOr = function (key, failureResult, executor, callback, jobOptions) {
+        if (tools.isFunction(failureResult)) {
+            // There is no key given. Reshuffle.
+            jobOptions = callback;
+            callback = executor;
+            executor = failureResult;
+            failureResult = key;
+            key = null;
+        }
+        if (tools.isFunction(callback)) {
+            var originalCallback_1 = callback;
+            callback = function (err) {
+                var results = [];
+                for (var _i = 1; _i < arguments.length; _i++) {
+                    results[_i - 1] = arguments[_i];
+                }
+                if ((0, errors_1.isAcquisitionFailureError)(err)) {
+                    originalCallback_1(null, failureResult);
+                }
+                else {
+                    originalCallback_1.apply(void 0, __spreadArray([err], results, false));
+                }
+            };
+        }
+        // noinspection JSVoidFunctionReturnValueUsed
+        var promiseResult = this.acquire(key, executor, callback, jobOptions);
+        if (typeof promiseResult !== 'undefined') {
+            promiseResult = promiseResult.catch(function (err) {
+                if ((0, errors_1.isAcquisitionFailureError)(err)) {
+                    return failureResult;
+                }
+                throw err;
+            });
+        }
+        return promiseResult;
+    };
+    /**
+     * Update state of given list of queues.
+     */
+    BetterLock.prototype.update = function (queues) {
+        for (var i = 0; i < queues.length; i++) {
+            var queue = queues[i];
+            // If key is available, have next job grab it
+            if (!queue.active && queue.jobs.length) {
+                var job = queue.jobs.splice(0, 1)[0];
+                queue.active = job;
+                job.waiting_count--;
+                if (job.waiting_count <= 0) {
+                    // This job can be executed now.
+                    this.executeJob(job);
+                }
+            }
+            // Handle wait queue overflow
+            if (tools.isNumber(this.options.queue_size) && this.options.queue_size < queue.jobs.length) {
+                var strategy = this.options.queue_ejection_strategy || 'oldest';
+                var targetJob = queue.jobs[strategy === 'oldest' ? 0 : queue.jobs.length - 1];
+                this.log("".concat(queue.toString(), " has overflown, so the ").concat(strategy, " job (").concat(targetJob, ") was kicked out"));
+                this.endJob(targetJob, [
+                    new errors_1.BetterLockQueueOverflowError(this.options.name, queue.key, queue.jobs.length, targetJob, strategy),
+                ]);
+            }
+        }
+    };
+    BetterLock.prototype.executeJob = function (job) {
+        var _this = this;
+        this.log("Executing ".concat(job));
+        // Clear wait timeout
+        clearTimeout(job.wait_timeout_id);
+        job.wait_timeout_id = null;
+        // We want to do the rest of this in a separate context, because we don't want user executor code
+        // to ever interfere with the code calling acquire().
+        setImmediate(function () {
+            // Make sure job hasn't been ended in the meantime
+            if (job.executed_at || job.ended_at) {
+                return;
+            }
+            // Validate this job is holding all queues it needs
+            for (var i = 0; i < job.keys.length; i++) {
+                var queue = _this.getQueue(job.keys[i]);
+                if (queue.active !== job) {
+                    // This should never happen
+                    return _this.endJob(job, [
+                        new errors_1.BetterLockInternalError(_this.options.name, "Corrupted wait queue state for ".concat(queue.key)),
+                    ]);
+                }
+            }
+            // Mark job as having started executing
+            job.executed_at = new Date();
+            if (tools.isNumber(job.options.execution_timeout)) {
+                job.execution_timeout_id = setTimeout(function () { return _this.onExecutionTimeout(job); }, job.options.execution_timeout);
+            }
+            var lockDone = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                _this.log("Done called for ".concat(job));
+                _this.endJob(job, args);
+            };
+            if (job.executor.length > 0) {
+                // Callback interface
+                job.executor(lockDone);
+                return;
+            }
+            // Promise interface
+            var executorResult;
+            try {
+                executorResult = job.executor();
+            }
+            catch (err) {
+                // Error thrown directly from executor
+                lockDone(err);
+            }
+            // Promise sniffing
+            if (_this.options.promise_tester(executorResult)) {
+                executorResult.then(function (res) { return lockDone(null, res); }, function (err) { return lockDone(err); });
+            }
+            else {
+                // "promise" is just some random value. We don't have to wait
+                lockDone(null, executorResult);
+            }
+        });
+    };
+    BetterLock.prototype.onWaitTimeout = function (job) {
+        this.log("".concat(job, " has timed out after waiting in queue for ").concat(new Date().valueOf() - job.enqueued_at.valueOf(), "ms"));
+        this.endJob(job, [new errors_1.BetterLockWaitTimeoutError(this.options.name, job)]);
+    };
+    BetterLock.prototype.onExecutionTimeout = function (job) {
+        this.log("".concat(job, " has timed out after executing for ").concat(new Date().valueOf() - job.executed_at.valueOf(), "ms"));
+        this.endJob(job, [new errors_1.BetterLockExecutionTimeoutError(this.options.name, job)]);
+    };
+    BetterLock.prototype.endJob = function (job, callbackArgs) {
+        var _this = this;
+        if (job.ended_at) {
+            this.log("WARNING: ".concat(job, " is trying to end, but it has already ended at ").concat(job.ended_at.toISOString(), ". Called with arguments: ").concat(callbackArgs));
+            return;
+        }
+        clearTimeout(job.wait_timeout_id);
+        job.wait_timeout_id = null;
+        clearTimeout(job.execution_timeout_id);
+        job.execution_timeout_id = null;
+        job.ended_at = new Date();
+        var queuesToUpdate = [];
+        for (var i = 0; i < job.keys.length; i++) {
+            var queue = this.getQueue(job.keys[i]);
+            queuesToUpdate.push(queue);
+            if (queue.active === job) {
+                // This job was holding on the queue's key
+                queue.active = null;
+            }
+            else {
+                // This job was still in wait list for this queue
+                var index = queue.jobs.indexOf(job);
+                if (index >= 0) {
+                    // Remove from queue
+                    queue.jobs.splice(index, 1);
+                }
+                else {
+                    // Something is wrong. Where did this job come from?
+                    this.log("WARNING: ".concat(job, " is ending, but it is not found anywhere in the queue for ").concat(queue.key));
+                }
+            }
+        }
+        // Call the callback
+        try {
+            job.callback.apply(null, callbackArgs);
+        }
+        finally {
+            // Whatever happens, schedule a queue update
+            setImmediate(function () { return _this.update(queuesToUpdate); });
+        }
+    };
+    /**
+     * Abort all jobs for a given key (or from the default job queue, if no key is given).
+     * Job executors will not be called. Callbacks will be called with JobAbortedError.
+     * Currently executing job will not be interrupted.
+     * @param [key]
+     */
+    BetterLock.prototype.abort = function (key) {
+        var _this = this;
+        var queue = this.getQueue(key);
+        queue.jobs.slice().forEach(function (job) {
+            _this.endJob(job, [new errors_1.BetterLockJobAbortedError(_this.options.name, job)]);
+        });
+        if (queue.active && !queue.active.executed_at) {
+            // If we have a job holding this queue that hasn't been executed yet, abort it as well
+            this.endJob(queue.active, [new errors_1.BetterLockJobAbortedError(this.options.name, queue.active)]);
+        }
+    };
+    /**
+     * Abort all pending jobs from all queues.
+     * Currently executing jobs will not be interrupted.
+     */
+    BetterLock.prototype.abortAll = function () {
+        this.abort(null);
+        for (var key in this.queues) {
+            // noinspection JSUnfilteredForInLoop
+            this.abort(key);
+        }
+    };
+    /**
+     * Default options to be used when creating BetterLock instances.
+     */
+    BetterLock.DEFAULT_OPTIONS = {
+        extend_stack_traces: true,
+        promise_tester: function (p) { return p && typeof p.then === 'function'; },
+    };
+    return BetterLock;
+}());
+exports.BetterLock = BetterLock;
+//# sourceMappingURL=better_lock.js.map

package/.output/server/node_modules/better-lock/dist/errors.js

@@ -0,0 +1,136 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAcquisitionFailureError = exports.BetterLockJobAbortedError = exports.BetterLockQueueOverflowError = exports.BetterLockExecutionTimeoutError = exports.BetterLockWaitTimeoutError = exports.BetterLockInvalidArgumentError = exports.BetterLockInternalError = exports.BetterLockError = void 0;
+var internals_1 = require("./internals");
+var BetterLockError = /** @class */ (function (_super) {
+    __extends(BetterLockError, _super);
+    function BetterLockError(lockName, message, incomingStack) {
+        if (incomingStack === void 0) { incomingStack = null; }
+        var _newTarget = this.constructor;
+        var _this = this;
+        // Fix typescript custom Error prototype chain
+        // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        // https://github.com/reduardo7/ts-base-error/blob/master/src/index.ts
+        var trueProto = _newTarget.prototype;
+        if (lockName) {
+            _this = _super.call(this, "[".concat(lockName, "] ").concat(message)) || this;
+        }
+        else {
+            _this = _super.call(this, message) || this;
+        }
+        Object.setPrototypeOf(_this, trueProto);
+        _this.lock_name = lockName;
+        _this.name = _this.constructor.name;
+        if (incomingStack) {
+            var withoutFirstLine = incomingStack.split('\n').slice(1).join('\n');
+            _this.stack =
+                _this.stack +
+                    '\n    --------------------------------------------------------------------------------\n' +
+                    withoutFirstLine;
+        }
+        return _this;
+    }
+    return BetterLockError;
+}(Error));
+exports.BetterLockError = BetterLockError;
+var BetterLockInternalError = /** @class */ (function (_super) {
+    __extends(BetterLockInternalError, _super);
+    function BetterLockInternalError(lockName, message) {
+        var lastChar = message[message.length - 1];
+        if (lastChar !== '.' && lastChar !== '!' && lastChar !== '?') {
+            message += '.';
+        }
+        return _super.call(this, lockName, message + ' This is probably a bug inside "better-lock" library') || this;
+    }
+    return BetterLockInternalError;
+}(BetterLockError));
+exports.BetterLockInternalError = BetterLockInternalError;
+var BetterLockInvalidArgumentError = /** @class */ (function (_super) {
+    __extends(BetterLockInvalidArgumentError, _super);
+    function BetterLockInvalidArgumentError(lockName, argument, expected, actual) {
+        var _this = _super.call(this, lockName, "Argument \"".concat(argument, "\" must be ").concat(expected, " (got: \"").concat(actual, "\")")) || this;
+        _this.argument = argument;
+        _this.argument = argument;
+        return _this;
+    }
+    return BetterLockInvalidArgumentError;
+}(BetterLockError));
+exports.BetterLockInvalidArgumentError = BetterLockInvalidArgumentError;
+var BetterLockWaitTimeoutError = /** @class */ (function (_super) {
+    __extends(BetterLockWaitTimeoutError, _super);
+    function BetterLockWaitTimeoutError(lockName, job) {
+        var _this = this;
+        var message = "".concat(job, " has timed out after ").concat(new Date().valueOf() - job.enqueued_at.valueOf(), "ms in wait queue");
+        _this = _super.call(this, lockName, message, job.incoming_stack) || this;
+        _this.job_id = job.id;
+        _this.keys = job.keys;
+        _this.enqueued_at = job.enqueued_at;
+        return _this;
+    }
+    return BetterLockWaitTimeoutError;
+}(BetterLockError));
+exports.BetterLockWaitTimeoutError = BetterLockWaitTimeoutError;
+var BetterLockExecutionTimeoutError = /** @class */ (function (_super) {
+    __extends(BetterLockExecutionTimeoutError, _super);
+    function BetterLockExecutionTimeoutError(lockName, job) {
+        var _this = this;
+        var message = "".concat(job, " has timed out after ").concat(new Date().valueOf() - job.executed_at.valueOf(), "ms of execution");
+        _this = _super.call(this, lockName, message, job.incoming_stack) || this;
+        _this.job_id = job.id;
+        _this.keys = job.keys;
+        _this.executed_at = job.executed_at;
+        return _this;
+    }
+    return BetterLockExecutionTimeoutError;
+}(BetterLockError));
+exports.BetterLockExecutionTimeoutError = BetterLockExecutionTimeoutError;
+var BetterLockQueueOverflowError = /** @class */ (function (_super) {
+    __extends(BetterLockQueueOverflowError, _super);
+    function BetterLockQueueOverflowError(lockName, key, count, job, strategy) {
+        var _this = this;
+        var keyDesignation = key === internals_1.KeyQueue.DEFAULT_QUEUE_KEY ? '' : " for key \"".concat(key, "\"");
+        var message = "Too many jobs (".concat(count, ") are waiting").concat(keyDesignation, ". The ").concat(strategy, " job (").concat(job, ") was kicked out");
+        _this = _super.call(this, lockName, message, job.incoming_stack) || this;
+        _this.job_id = job.id;
+        _this.keys = job.keys;
+        _this.job_count = count;
+        _this.kicked_out_job_id = job.id;
+        _this.strategy = strategy;
+        return _this;
+    }
+    return BetterLockQueueOverflowError;
+}(BetterLockError));
+exports.BetterLockQueueOverflowError = BetterLockQueueOverflowError;
+var BetterLockJobAbortedError = /** @class */ (function (_super) {
+    __extends(BetterLockJobAbortedError, _super);
+    function BetterLockJobAbortedError(lockName, job) {
+        var _this = _super.call(this, lockName, "".concat(job, " has been aborted by the user"), job.incoming_stack) || this;
+        _this.job_id = job.id;
+        _this.keys = job.keys;
+        return _this;
+    }
+    return BetterLockJobAbortedError;
+}(BetterLockError));
+exports.BetterLockJobAbortedError = BetterLockJobAbortedError;
+function isAcquisitionFailureError(err) {
+    return ((err && err instanceof BetterLockQueueOverflowError) ||
+        err instanceof BetterLockWaitTimeoutError ||
+        err instanceof BetterLockJobAbortedError);
+}
+exports.isAcquisitionFailureError = isAcquisitionFailureError;
+//# sourceMappingURL=errors.js.map

package/.output/server/node_modules/better-lock/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterLock = exports.BetterLockWaitTimeoutError = exports.BetterLockQueueOverflowError = exports.BetterLockJobAbortedError = exports.BetterLockInvalidArgumentError = exports.BetterLockInternalError = exports.BetterLockExecutionTimeoutError = exports.BetterLockError = void 0;
+var better_lock_1 = require("./better_lock");
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "BetterLockError", { enumerable: true, get: function () { return errors_1.BetterLockError; } });
+Object.defineProperty(exports, "BetterLockExecutionTimeoutError", { enumerable: true, get: function () { return errors_1.BetterLockExecutionTimeoutError; } });
+Object.defineProperty(exports, "BetterLockInternalError", { enumerable: true, get: function () { return errors_1.BetterLockInternalError; } });
+Object.defineProperty(exports, "BetterLockInvalidArgumentError", { enumerable: true, get: function () { return errors_1.BetterLockInvalidArgumentError; } });
+Object.defineProperty(exports, "BetterLockJobAbortedError", { enumerable: true, get: function () { return errors_1.BetterLockJobAbortedError; } });
+Object.defineProperty(exports, "BetterLockQueueOverflowError", { enumerable: true, get: function () { return errors_1.BetterLockQueueOverflowError; } });
+Object.defineProperty(exports, "BetterLockWaitTimeoutError", { enumerable: true, get: function () { return errors_1.BetterLockWaitTimeoutError; } });
+function attachExports(target, exports) {
+    Object.assign(target, exports);
+    return target;
+}
+exports.BetterLock = attachExports(better_lock_1.BetterLock, {
+    BetterLock: better_lock_1.BetterLock,
+    Error: errors_1.BetterLockError,
+    InternalError: errors_1.BetterLockInternalError,
+    InvalidArgumentError: errors_1.BetterLockInvalidArgumentError,
+    WaitTimeoutError: errors_1.BetterLockWaitTimeoutError,
+    ExecutionTimeoutError: errors_1.BetterLockExecutionTimeoutError,
+    QueueOverflowError: errors_1.BetterLockQueueOverflowError,
+    JobAbortedError: errors_1.BetterLockJobAbortedError,
+});
+exports.default = exports.BetterLock;
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/better-lock/dist/internals.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyQueue = exports.LockJob = void 0;
+/**
+ * Class that represents one scheduled job and its state. This is created every time user calls "acquire"
+ */
+var LockJob = /** @class */ (function () {
+    function LockJob(keys, executor, callback, options) {
+        /** ID to uniquely identify this particular job */
+        this.id = undefined;
+        /**
+         * Timestamp when job was created
+         */
+        this.enqueued_at = new Date();
+        /**
+         * Timestamp when job was executed
+         */
+        this.executed_at = null;
+        /**
+         * This is set when job ends, in case something holds a reference to it
+         */
+        this.ended_at = null;
+        /**
+         * Id of the wait timer
+         */
+        this.wait_timeout_id = null;
+        /**
+         * Id of the execution timer
+         */
+        this.execution_timeout_id = null;
+        /**
+         * Saved incoming stack, for the purpose of extending stack traces
+         */
+        this.incoming_stack = null;
+        LockJob._lastId++;
+        this.id = LockJob._lastId;
+        this.keys = keys;
+        this.waiting_count = keys.length;
+        this.executor = executor;
+        this.callback = callback;
+        this.options = options;
+    }
+    LockJob.prototype.toString = function () {
+        return "Job #".concat(this.id, " [").concat(this.keys.join(', '), "]");
+    };
+    LockJob._lastId = 0;
+    return LockJob;
+}());
+exports.LockJob = LockJob;
+// *********************************************************************************************************************
+/**
+ * Class to hold pending, holding and executing jobs for one key
+ */
+var KeyQueue = /** @class */ (function () {
+    function KeyQueue(key) {
+        /**
+         * Queue of jobs waiting to be executed.
+         * Jobs in this state are governed by the wait_timeout.
+         */
+        this.jobs = [];
+        /**
+         * Active job that is holding this key. This job could be waiting on other keys or executing.
+         */
+        this.active = null;
+        this.key = key;
+    }
+    KeyQueue.prototype.toString = function () {
+        return this.key === KeyQueue.DEFAULT_QUEUE_KEY ? 'JobQueue' : "JobQueue<".concat(this.key, ">");
+    };
+    // We will use this key when user doesn't supply anything
+    KeyQueue.DEFAULT_QUEUE_KEY = '___DEFAULT_QUEUE_KEY___';
+    return KeyQueue;
+}());
+exports.KeyQueue = KeyQueue;
+//# sourceMappingURL=internals.js.map