better-lock 1.0.0 → 2.0.1-beta

package/dist/errors.js

@@ -0,0 +1,131 @@
+"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.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) {
+        var _newTarget = this.constructor;
+        if (incomingStack === void 0) { incomingStack = null; }
+        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, "[" + lockName + "] " + 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 _this = this;
+        var lastChar = message[message.length - 1];
+        if (lastChar !== '.' && lastChar !== '!' && lastChar !== '?') {
+            message += '.';
+        }
+        _this = _super.call(this, lockName, message + ' This is probably a bug inside "better-lock" library') || this;
+        return _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 \"" + argument + "\" must be " + expected + " (got: \"" + 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 = job + " has timed out after " + (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 = job + " has timed out after " + (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) {
+        var _this = this;
+        var keyDesignation = key === internals_1.KeyQueue.DEFAULT_QUEUE_KEY ? '' : " for key \"" + key + "\"";
+        var message = "Too many jobs (" + count + ") are waiting" + keyDesignation + ". The most recent job (" + 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;
+        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, 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;
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { BetterLock as BetterLockUnadorned } from './better_lock';
+import { BetterLockError, BetterLockExecutionTimeoutError, BetterLockInternalError, BetterLockInvalidArgumentError, BetterLockJobAbortedError, BetterLockQueueOverflowError, BetterLockWaitTimeoutError } from './errors';
+import { ILockJobOptions as BetterLockJobOptions, IOptions as BetterLockOptions } from './options';
+import { IErrorName as BetterLockErrorName, IExecutor as BetterLockExecutor, ILockKey as BetterLockKey } from './types';
+export { BetterLockOptions, BetterLockJobOptions, BetterLockExecutor, BetterLockKey, BetterLockErrorName, BetterLockError, BetterLockExecutionTimeoutError, BetterLockInternalError, BetterLockInvalidArgumentError, BetterLockJobAbortedError, BetterLockQueueOverflowError, BetterLockWaitTimeoutError, };
+export declare const BetterLock: typeof BetterLockUnadorned & {
+    BetterLock: typeof BetterLockUnadorned;
+    Error: typeof BetterLockError;
+    InternalError: typeof BetterLockInternalError;
+    InvalidArgumentError: typeof BetterLockInvalidArgumentError;
+    WaitTimeoutError: typeof BetterLockWaitTimeoutError;
+    ExecutionTimeoutError: typeof BetterLockExecutionTimeoutError;
+    QueueOverflowError: typeof BetterLockQueueOverflowError;
+    JobAbortedError: typeof BetterLockJobAbortedError;
+};
+export default BetterLock;

package/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/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,6CAAkE;AAClE,mCAQkB;AAehB,gGAtBA,wBAAe,OAsBA;AACf,gHAtBA,wCAA+B,OAsBA;AAC/B,wGAtBA,gCAAuB,OAsBA;AACvB,+GAtBA,uCAA8B,OAsBA;AAC9B,0GAtBA,kCAAyB,OAsBA;AACzB,6GAtBA,qCAA4B,OAsBA;AAC5B,2GAtBA,mCAA0B,OAsBA;AAG5B,SAAS,aAAa,CACpB,MAAe,EACf,OAAiB;IAEjB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,MAAa,CAAC;AACvB,CAAC;AAEY,QAAA,UAAU,GAAG,aAAa,CAAC,wBAAmB,EAAE;IAC3D,UAAU,EAAE,wBAAmB;IAE/B,KAAK,EAAE,wBAAe;IACtB,aAAa,EAAE,gCAAuB;IACtC,oBAAoB,EAAE,uCAA8B;IACpD,gBAAgB,EAAE,mCAA0B;IAC5C,qBAAqB,EAAE,wCAA+B;IACtD,kBAAkB,EAAE,qCAA4B;IAChD,eAAe,EAAE,kCAAyB;CAC3C,CAAC,CAAC;AAEH,kBAAe,kBAAU,CAAC"}

package/dist/internals.d.ts

@@ -0,0 +1,75 @@
+import { ILockJobOptions } from './options';
+import { ICallback, IExecutor } from './types';
+/**
+ * Class that represents one scheduled job and its state. This is created every time user calls "acquire"
+ */
+export declare class LockJob<TResult> {
+    static _lastId: number;
+    /** ID to uniquely identify this particular job */
+    id: any;
+    /**
+     * List of keys that will be locked. Always an array
+     */
+    keys: Array<string | null>;
+    /**
+     * Number of keys which this job is waiting on. Once this reaches 0, job will be executed
+     */
+    waiting_count: number;
+    /**
+     * Function that will be called inside the lock
+     */
+    executor: IExecutor<TResult>;
+    /**
+     * Function that will be called once job is done, whether it succeeds or times out.
+     * This is supplied by user in callback API, and generated internally otherwise.
+     */
+    callback: ICallback<TResult>;
+    /**
+     * Timestamp when job was created
+     */
+    enqueued_at: Date;
+    /**
+     * Timestamp when job was executed
+     */
+    executed_at: Date;
+    /**
+     * This is set when job ends, in case something holds a reference to it
+     */
+    ended_at: Date;
+    /**
+     * Options that apply to this particular job
+     */
+    options: ILockJobOptions;
+    /**
+     * Id of the wait timer
+     */
+    wait_timeout_id: any;
+    /**
+     * Id of the execution timer
+     */
+    execution_timeout_id: any;
+    /**
+     * Saved incoming stack, for the purpose of extending stack traces
+     */
+    incoming_stack: string;
+    constructor(keys: Array<string | null>, executor: IExecutor<TResult>, callback: ICallback<TResult>, options: ILockJobOptions);
+    toString(): string;
+}
+/**
+ * Class to hold pending, holding and executing jobs for one key
+ */
+export declare class KeyQueue {
+    static readonly DEFAULT_QUEUE_KEY = "___DEFAULT_QUEUE_KEY___";
+    key: string;
+    /**
+     * Queue of jobs waiting to be executed.
+     * Jobs in this state are governed by the wait_timeout.
+     */
+    jobs: LockJob<any>[];
+    /**
+     * Active job that is holding this key. This job could be waiting on other keys or executing.
+     */
+    active: LockJob<any>;
+    constructor(key?: string);
+    toString(): string;
+}

package/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 #" + this.id + " [" + 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<" + 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

package/dist/internals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internals.js","sourceRoot":"","sources":["../src/internals.ts"],"names":[],"mappings":";;;AAGA;;GAEG;AACH;IA8DE,iBACE,IAA0B,EAC1B,QAA4B,EAC5B,QAA4B,EAC5B,OAAwB;QA/D1B,kDAAkD;QAC3C,OAAE,GAAG,SAAS,CAAC;QAuBtB;;WAEG;QACI,gBAAW,GAAS,IAAI,IAAI,EAAE,CAAC;QAEtC;;WAEG;QACI,gBAAW,GAAS,IAAI,CAAC;QAEhC;;WAEG;QACI,aAAQ,GAAS,IAAI,CAAC;QAO7B;;WAEG;QACI,oBAAe,GAAG,IAAI,CAAC;QAE9B;;WAEG;QACI,yBAAoB,GAAG,IAAI,CAAC;QAEnC;;WAEG;QACI,mBAAc,GAAW,IAAI,CAAC;QAQnC,OAAO,CAAC,OAAO,EAAE,CAAC;QAClB,IAAI,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC;QACjC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,0BAAQ,GAAR;QACE,OAAO,UAAQ,IAAI,CAAC,EAAE,UAAK,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAG,CAAC;IACrD,CAAC;IA9EM,eAAO,GAAG,CAAC,CAAC;IA+ErB,cAAC;CAAA,AAhFD,IAgFC;AAhFY,0BAAO;AAkFpB,wHAAwH;AAExH;;GAEG;AACH;IAiBE,kBAAY,GAAY;QAXxB;;;WAGG;QACI,SAAI,GAAmB,EAAE,CAAC;QAEjC;;WAEG;QACI,WAAM,GAAiB,IAAI,CAAC;QAGjC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,2BAAQ,GAAR;QACE,OAAO,IAAI,CAAC,GAAG,KAAK,QAAQ,CAAC,iBAAiB,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,cAAY,IAAI,CAAC,GAAG,MAAG,CAAC;IACxF,CAAC;IAtBD,yDAAyD;IACzC,0BAAiB,GAAG,yBAAyB,CAAC;IAsBhE,eAAC;CAAA,AAxBD,IAwBC;AAxBY,4BAAQ"}

package/dist/options.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Options that apply on LockJob
+ */
+export interface ILockJobOptions {
+    /**
+     * How long can jobs wait in queue before timing out. Overrides BetterLockOptions value.
+     */
+    wait_timeout?: number | null;
+    /**
+     * How long can a job be executing before timing out. Null to disable timeout. Overrides BetterLockOptions value.
+     */
+    execution_timeout?: number | null;
+    /**
+     * In any error produced by BetterLock, extend the stack trace to include incoming trace. Overrides BetterLockOptions value.
+     */
+    extend_stack_traces?: boolean;
+}
+/**
+ * Options that apply on BetterLock instance
+ */
+export interface IOptions extends ILockJobOptions {
+    /**
+     * How long can jobs wait in queue before timing out. Null to disable timeout.
+     */
+    wait_timeout?: number | null;
+    /**
+     * How long can a job be executing before timing out. Null to disable timeout.
+     * If you do that, though, and you have a swallowed callback, the lock can remain locked permanently.
+     */
+    execution_timeout?: number | null;
+    /**
+     * Max queue size for waiting jobs.
+     */
+    queue_size?: number | null;
+    /**
+     * Lock name. This will be written in all logs and error messages, to help you distinguish between different locks
+     */
+    name?: string;
+    /**
+     * Whether to log the internal actions. Set to true to use console.log. Alternatively, provide your own function
+     */
+    log?: boolean | ((msg: string) => void);
+    /**
+     * In any error produced by BetterLock, extend the stack trace to include incoming trace.
+     * Defaults to true.
+     */
+    extend_stack_traces?: boolean;
+    /**
+     * Function that detects whether value returned by executor is a promise.
+     * This will ducktype-sniff the returned value. Depending on your Promise library of choice,
+     * you might want to tighten or loosen this bit.
+     */
+    promise_tester?: (maybePromise: any) => boolean;
+}

package/dist/options.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=options.js.map

package/dist/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":""}

package/dist/tools.d.ts

@@ -0,0 +1,19 @@
+import { ICallback } from './types';
+export declare function isString(val: any): boolean;
+export declare function isFunction(val: any): boolean;
+export declare function isObject(val: any): boolean;
+export declare function isNumber(val: any, includeInfinity?: boolean, includeNaN?: boolean): boolean;
+export declare function noop(): void;
+export declare function makeLog(name: any, doLog: any): (msg: string) => void;
+/**
+ * Create a wrapped promise + callback construct
+ */
+export declare function callbackWithPromise<TResult = any>(): Promise<TResult> & {
+    callback: ICallback<TResult>;
+};
+/**
+ * Assign properties from sources to target, skipping over undefined-s
+ * @param target Target object which will be mutated
+ * @param sources One or more source objects which will provide properties
+ */
+export declare function assign<T>(target: T, sources: T[]): T;

package/dist/tools.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assign = exports.callbackWithPromise = exports.makeLog = exports.noop = exports.isNumber = exports.isObject = exports.isFunction = exports.isString = void 0;
+function isString(val) {
+    return typeof val === 'string';
+}
+exports.isString = isString;
+function isFunction(val) {
+    return typeof val === 'function';
+}
+exports.isFunction = isFunction;
+function isObject(val) {
+    return typeof val === 'object' && val !== null && !Array.isArray(val);
+}
+exports.isObject = isObject;
+function isNumber(val, includeInfinity, includeNaN) {
+    if (includeInfinity === void 0) { includeInfinity = false; }
+    if (includeNaN === void 0) { includeNaN = false; }
+    if (typeof val !== 'number') {
+        return false;
+    }
+    if (!includeInfinity && (val === Number.POSITIVE_INFINITY || val === Number.NEGATIVE_INFINITY)) {
+        return false;
+    }
+    if (!includeNaN && isNaN(val)) {
+        return false;
+    }
+    return true;
+}
+exports.isNumber = isNumber;
+function noop() {
+    // Nothing
+}
+exports.noop = noop;
+function makeLog(name, doLog) {
+    if (!doLog) {
+        return noop;
+    }
+    if (doLog === true) {
+        doLog = console.log.bind(console);
+    }
+    if (name) {
+        name = '[' + name + '] ';
+    }
+    return function log(msg) {
+        if (name) {
+            doLog(name + msg);
+        }
+        else {
+            doLog(msg);
+        }
+    };
+}
+exports.makeLog = makeLog;
+/**
+ * Create a wrapped promise + callback construct
+ */
+function callbackWithPromise() {
+    var callback;
+    var promise = new Promise(function (resolve, reject) {
+        callback = function (err, result) {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(result);
+            }
+        };
+    });
+    callback.promise = promise;
+    return callback;
+}
+exports.callbackWithPromise = callbackWithPromise;
+/**
+ * Assign properties from sources to target, skipping over undefined-s
+ * @param target Target object which will be mutated
+ * @param sources One or more source objects which will provide properties
+ */
+function assign(target, sources) {
+    for (var _i = 0, sources_1 = sources; _i < sources_1.length; _i++) {
+        var source = sources_1[_i];
+        if (!isObject(source)) {
+            // We must have an object to assign
+            continue;
+        }
+        for (var key in source) {
+            if (!source.hasOwnProperty(key)) {
+                continue;
+            }
+            var sourceValue = source[key];
+            if (sourceValue === undefined) {
+                // Do not overwrite undefineds
+                continue;
+            }
+            var targetValue = target[key];
+            if (isObject(sourceValue) && isObject(targetValue)) {
+                // Merge deep.
+                var cloneRoot = targetValue.constructor ? new targetValue.constructor() : {};
+                target[key] = assign(cloneRoot, [targetValue, sourceValue]);
+                continue;
+            }
+            // In all other cases, copy by reference
+            target[key] = sourceValue;
+        }
+    }
+    return target;
+}
+exports.assign = assign;
+//# sourceMappingURL=tools.js.map

package/dist/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+import * as errors from './errors';
+declare type IErrorExports = typeof errors;
+/**
+ * All error names that we can emit
+ */
+export declare type IErrorName = keyof IErrorExports;
+/**
+ * User-supplied callback. We support a "canonical" callback, with just error and result,
+ * but also old-school callbacks, with varargs return values.
+ */
+export declare type ICallback<TResult> = TResult extends any[] ? (err?: Error, ...result: TResult) => void : (err?: Error, result?: TResult) => void;
+/**
+ * Function that user will supply as the thing that will be running inside lock.
+ * It can either accept a done() function, or return a promise.
+ */
+export declare type ICallbackExecutor<TResult> = (lockDone: ICallback<TResult>) => void;
+export declare type IPromiseExecutor<TResult> = () => Promise<TResult>;
+export declare type IExecutor<TResult> = ICallbackExecutor<TResult> | IPromiseExecutor<TResult>;
+/**
+ * Key types that can be used for a lock.
+ */
+export declare type ILockKey = string | number | null | undefined;
+export {};

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "better-lock",
-  "version": "1.0.0",
+  "version": "2.0.1-beta",
   "description": "A (better) node.js lock library",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "test": "nyc mocha --recursive spec"
+    "prepublishOnly": "npm run build",
+    "build": "tsc",
+    "test": "jest",
+    "watch": "jest --watchAll",
+    "lint": "eslint ./src",
+    "coverage": "jest --coverage"
   },
   "repository": {
     "type": "git",
@@ -19,16 +25,32 @@
     "block",
     "sync"
   ],
+  "devDependencies": {
+    "@types/jest": "^26.0.23",
+    "@typescript-eslint/eslint-plugin": "^4.25.0",
+    "@typescript-eslint/parser": "^4.25.0",
+    "eslint": "^7.27.0",
+    "eslint-config-prettier": "^8.3.0",
+    "import-sort-style-module": "^6.0.0",
+    "jest": "^27.0.2",
+    "prettier": "latest",
+    "prettier-plugin-import-sort": "0.0.7",
+    "ts-jest": "^27.0.1",
+    "typescript": "^4.3.2"
+  },
   "author": "Ivan Pantic",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/panta82/better-lock/issues"
   },
   "homepage": "https://github.com/panta82/better-lock#readme",
-  "devDependencies": {
-    "chai": "^4.2.0",
-    "mocha": "^5.2.0",
-    "nyc": "^12.0.2",
-    "prettier": "^1.16.1"
+  "importSort": {
+    ".ts, .tsx": {
+      "style": "module",
+      "parser": "typescript"
+    },
+    ".js, .jsx": {
+      "style": "module"
+    }
   }
 }