assertron 7.1.1 → 9.0.0

package/LICENSE

@@ -14,8 +14,8 @@ all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.

package/README.md

@@ -5,41 +5,51 @@
 [![NPM version][npm-image]][npm-url]
 [![NPM downloads][downloads-image]][downloads-url]
 
-[![TravisCI][travis-image]][travis-url]
-[![CircleCI][circleci-image]][circleci-url]
+[![Github NodeJS][github-nodejs]][github-action-url]
 [![Codecov][codecov-image]][codecov-url]
 [![Coverage Status][coveralls-image]][coveralls-url]
 
-[![Greenkeeper badge](https://badges.greenkeeper.io/unional/assertron.svg)](https://greenkeeper.io/)
-[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+[![Semantic Release][semantic-release-image]][semantic-release-url]
+
+[![Visual Studio Code][vscode-image]][vscode-url]
 
 A supplementary assertion library that runs on both NodeJS and browser.
 
 ## assertron
 
-`assertron` provides additional or improved assertion functions of the `assert` module.
+`assertron` provides a collection of assertion methods.
 
-```ts
-import { assertron } from 'assertron'
+### assertron.false(value)
 
-assertron.throws(Promise.reject(new Error('foo')))
-assertron.throws(() => { throw new Error('foo') })
-assertron.throws(() => Promise.reject(new Error('foo')))
+Asserts the provided value is false.
 
-assertron.pathEqual('dir/sub-dir/file.txt', 'dir\\sub-dir\\file.txt')
-```
+### assertron.falsy(value)
+
+Asserts the provided value is falsy.
+
+### assertron.pathEqual(actual, expected)
+
+Asserts the two paths are equal regardless of operating system differences.
+
+### assertron.rejects(promise)
+
+Asserts the promise rejects.
 
 ### assertron.repeat(fn, times)
 
 Repeat the specified function n times and return the last result.
 If the result is a promise, it will run the function sequentially.
 
+### assertron.resolves(promise)
+
+Asserts the promise resolves.
+
 ### assertron.satisfies(actual, expected)
 
 `assertron.satisfies()` checks if `actual` meets the requirements specified by `expected`.
 Each property in `expected` can be a value, a `RegExp`, or a predicate function.
 It uses `satisfier` internally to check for validity.
-Check out [`sateisfier`](https://github.com/unional/satisfier) for more detail.
+Check out [`satisfier`](https://github.com/unional/satisfier) for more detail.
 
 ```ts
 import a from 'assertron' // assertron is also exported as default.
@@ -56,9 +66,33 @@ a.satisfies({ a: 'foo' }, { a: /boo/ })
 a.satisfies({ a: 1 }, { a: () => false })
 ```
 
+### assertron.throws(...)
+
+Asserts the promise, function, or async function throws (or rejects) an error.
+
+```ts
+import { assertron } from 'assertron'
+
+await assertron.throws(Promise.reject(new Error('foo')))
+assertron.throws(() => { throw new Error('foo') })
+await assertron.throws(() => Promise.reject(new Error('foo')))
+
+const e1 = await assertron.throws(Promise.reject(new SpecificError('foo')), SpecificError)
+const e2 = assertron.throws(() => { throw new SpecificError('foo') }, SpecificError)
+const e3 = await assertron.throws(() => Promise.reject(new SpecificError('foo')), SpecificError)
+```
+
+### assertron.true(value)
+
+Asserts the provided value is true.
+
+### assertron.truthy(value)
+
+Asserts the provided value is truthy.
+
 ## AssertOrder
 
-Enable tests to check if code are run in certain order.
+Assert the code is executed in the expected order.
 
 ### order.once(step: number)
 
@@ -94,7 +128,7 @@ boo()
 
 ### order.atLeastOnce(step: number)
 
-Assert step `step` have executed at least once.
+Assert the `step` executed at least once.
 
 ```ts
 import { AssertOrder } from 'assertron'
@@ -138,19 +172,16 @@ for (let i = 1; i <= 4; i++) {
 }
 ```
 
-There are more methods available. Use TypeScript to discover them!
+There are other methods available. Use TypeScript to discover them!
 
 ## Contribute
 
 ```sh
-# right after fork
-npm install
+yarn
 
-# begin making changes
+# start making changes
 git checkout -b <branch>
-npm run watch
-
-# edit `webpack.config.dev.js` to exclude dependencies for the global build.
+yarn watch
 
 # after making change(s)
 git commit -m "<commit message>"
@@ -164,43 +195,27 @@ git push
 There are a few useful commands you can use during development.
 
 ```sh
-# Run tests (and lint) automatically whenever you save a file.
-npm run watch
-
-# Run tests with coverage stats (but won't fail you if coverage does not meet criteria)
-npm run test
-
-# Manually verify the project.
-# This will be ran during 'npm preversion' so you normally don't need to run this yourself.
-npm run verify
+yarn test
 
-# Build the project.
-# You normally don't need to do this.
-npm run build
+yarn watch
 
-# Run tslint
-# You normally don't need to do this as `npm run watch` and `npm version` will automatically run lint for you.
-npm run lint
+yarn verify
 ```
 
-Generated by `generator-unional@0.0.1`
-
 [npm-image]: https://img.shields.io/npm/v/assertron.svg?style=flat
 [npm-url]: https://npmjs.org/package/assertron
 [downloads-image]: https://img.shields.io/npm/dm/assertron.svg?style=flat
 [downloads-url]: https://npmjs.org/package/assertron
 
-[travis-image]: https://img.shields.io/travis/unional/assertron/master.svg?style=flat
-[travis-url]: https://travis-ci.org/unional/assertron?branch=master
-[circleci-image]: https://circleci.com/gh/unional/assertron/tree/master.svg?style=shield
-[circleci-url]: https://circleci.com/gh/unional/assertron/tree/master
-
+[github-nodejs]: https://github.com/unional/assertron/workflows/nodejs/badge.svg
+[github-action-url]: https://github.com/unional/assertron/actions
 [codecov-image]: https://codecov.io/gh/unional/assertron/branch/master/graph/badge.svg
 [codecov-url]: https://codecov.io/gh/unional/assertron
 [coveralls-image]: https://coveralls.io/repos/github/unional/assertron/badge.svg
 [coveralls-url]: https://coveralls.io/github/unional/assertron
 
-[green-keeper-image]: https://badges.greenkeeper.io/unional/assertron.svg
-[green-keeper-url]: https://greenkeeper.io/
 [semantic-release-image]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
 [semantic-release-url]: https://github.com/semantic-release/semantic-release
+
+[vscode-image]: https://img.shields.io/badge/vscode-ready-green.svg
+[vscode-url]: https://code.visualstudio.com/

package/{dist-es2015 → cjs}/assert-order/AssertOrder.d.ts

@@ -2,7 +2,7 @@ export declare class AssertOrder {
     /**
      * Gets the current expecting step.
      */
-    readonly currentStep: number;
+    get currentStep(): number;
     private state;
     constructor(plan?: number);
     /**
@@ -30,7 +30,7 @@ export declare class AssertOrder {
     on(step: number, assert: (step: number) => void): void;
     atLeastOnce(step: number): number;
     any(steps: number[]): number;
-    onAny(steps: number[], ...asserts: Function[]): void;
+    onAny(steps: number[], ...asserts: Array<(...args: any[]) => any>): void;
     end(timeout: number): Promise<number>;
     end(): number;
     exactly(step: number, times: number): number;
@@ -38,3 +38,4 @@ export declare class AssertOrder {
     wait(step: number, callback: () => void): void;
     private assert;
 }
+//# sourceMappingURL=AssertOrder.d.ts.map

package/cjs/assert-order/AssertOrder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssertOrder.d.ts","sourceRoot":"","sources":["../../src/assert-order/AssertOrder.ts"],"names":[],"mappings":"AAMA,qBAAa,WAAW;IACtB;;OAEG;IACH,IAAI,WAAW,WAEd;IAED,OAAO,CAAC,KAAK,CAAc;gBACf,IAAI,CAAC,EAAE,MAAM;IAIzB;;;OAGG;IACH,EAAE,CAAC,IAAI,EAAE,MAAM;IAIf;;;OAGG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM;IAMhB;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM;IAIjB;;OAEG;IACH,IAAI;IAIJ;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM;IAKjB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;IAM/C,WAAW,CAAC,IAAI,EAAE,MAAM;IAaxB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE;IAQnB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,EAAE,KAAK,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;IAoBjE,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IACrC,GAAG,IAAI,MAAM;IAmBb,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAWnC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IACjC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAO9C,OAAO,CAAC,MAAM;CAKf"}

package/cjs/assert-order/AssertOrder.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertOrder = void 0;
+var InvalidOrder_1 = require("./InvalidOrder");
+var StateMachine_1 = require("./StateMachine");
+// order.atLeast(step, count) // expected to be executed at least `count` times
+// order.atMost(step, count) // exected to be executed at most `count` times
+var AssertOrder = /** @class */ (function () {
+    function AssertOrder(plan) {
+        this.state = new StateMachine_1.StateMachine(plan);
+    }
+    Object.defineProperty(AssertOrder.prototype, "currentStep", {
+        /**
+         * Gets the current expecting step.
+         */
+        get: function () {
+            return this.state.step;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Asserts the current step is `step`.
+     * @param step expected step.
+     */
+    AssertOrder.prototype.is = function (step) {
+        this.assert('is', step);
+    };
+    /**
+     * Asserts the current step is not `step`.
+     * @param step not expected step.
+     */
+    AssertOrder.prototype.not = function (step) {
+        if (this.state.isValid(step)) {
+            throw new InvalidOrder_1.InvalidOrder(this.state.get(), 'not', [step], { ssf: this.not });
+        }
+    };
+    /**
+     * Reset to specified step.
+     */
+    AssertOrder.prototype.jump = function (step) {
+        this.state.jump(step);
+    };
+    /**
+     * Move to next step.
+     */
+    AssertOrder.prototype.move = function () {
+        this.state.move();
+    };
+    /**
+     * Asserts the specified step will run once.
+     */
+    AssertOrder.prototype.once = function (step) {
+        this.assert('once', step);
+        this.state.move();
+    };
+    AssertOrder.prototype.on = function (step, assert) {
+        this.state.on(step, function () {
+            assert(step);
+        });
+    };
+    AssertOrder.prototype.atLeastOnce = function (step) {
+        var nextStep = step + 1;
+        if (this.state.step === step) {
+            this.state.move();
+            return this.state.moveSubStep();
+        }
+        else if (this.state.step === nextStep && this.state.subStep > 0) {
+            return this.state.moveSubStep();
+        }
+        else
+            throw new InvalidOrder_1.InvalidOrder(this.state.get(), 'atLeastOnce', [step], { ssf: this.atLeastOnce });
+    };
+    AssertOrder.prototype.any = function (steps) {
+        var index = steps.indexOf(this.state.step);
+        if (index === -1)
+            throw new InvalidOrder_1.InvalidOrder(this.state.get(), 'any', [steps], { ssf: this.any });
+        this.state.move();
+        return steps[index];
+    };
+    AssertOrder.prototype.onAny = function (steps) {
+        var _this = this;
+        var asserts = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            asserts[_i - 1] = arguments[_i];
+        }
+        steps.forEach(function (step) {
+            _this.state.on(step, function () {
+                var firstError;
+                var hasPass = false;
+                asserts.forEach(function (assert) {
+                    try {
+                        assert(step);
+                        hasPass = true;
+                    }
+                    catch (err) {
+                        if (!firstError)
+                            firstError = err;
+                    }
+                });
+                if (!hasPass)
+                    throw firstError;
+            });
+        });
+        return;
+    };
+    AssertOrder.prototype.end = function (timeout) {
+        var _this = this;
+        if (timeout) {
+            return new Promise(function (r) {
+                setTimeout(r, timeout);
+            }).then(function () {
+                return _this.end();
+            });
+        }
+        if (!this.state.isMaxStepDefined()) {
+            this.state.stopAccepting();
+            return this.state.getTimeTaken();
+        }
+        if (this.state.isAccepting()) {
+            throw new InvalidOrder_1.InvalidOrder(this.state.get(), 'end', [], { ssf: this.end });
+        }
+    };
+    AssertOrder.prototype.exactly = function (step, times) {
+        if (this.state.isNotValid(step))
+            throw new InvalidOrder_1.InvalidOrder(this.state.get(), 'exactly', [step, times], { ssf: this.exactly });
+        if (this.state.maxSubStep === undefined) {
+            this.state.maxSubStep = times;
+            this.state.minSubStep = times;
+        }
+        return this.state.moveSubStep();
+    };
+    AssertOrder.prototype.wait = function (step, callback) {
+        var _this = this;
+        if (callback)
+            this.on(step, callback);
+        else
+            return new Promise(function (a) { _this.on(step, a); });
+    };
+    AssertOrder.prototype.assert = function (method, step) {
+        if (this.state.isNotValid(step)) {
+            throw new InvalidOrder_1.InvalidOrder(this.state.get(), method, [step], { ssf: this[method] });
+        }
+    };
+    return AssertOrder;
+}());
+exports.AssertOrder = AssertOrder;
+//# sourceMappingURL=data:application/json;base64,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

package/cjs/assert-order/InvalidOrder.d.ts

@@ -0,0 +1,9 @@
+import { AssertionError } from '../errors';
+import { State } from './types';
+export declare class InvalidOrder extends AssertionError {
+    state: State;
+    method: string;
+    args: any[];
+    constructor(state: State, method: string, args: any[], options: AssertionError.Options);
+}
+//# sourceMappingURL=InvalidOrder.d.ts.map

package/cjs/assert-order/InvalidOrder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InvalidOrder.d.ts","sourceRoot":"","sources":["../../src/assert-order/InvalidOrder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/B,qBAAa,YAAa,SAAQ,cAAc;IAC3B,KAAK,EAAE,KAAK;IAAS,MAAM,EAAE,MAAM;IAAS,IAAI,EAAE,GAAG,EAAE;gBAAvD,KAAK,EAAE,KAAK,EAAS,MAAM,EAAE,MAAM,EAAS,IAAI,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,cAAc,CAAC,OAAO;CAG5G"}

package/cjs/assert-order/InvalidOrder.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidOrder = void 0;
+var tslib_1 = require("tslib");
+var errors_1 = require("../errors");
+var InvalidOrder = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(InvalidOrder, _super);
+    function InvalidOrder(state, method, args, options) {
+        var _this = _super.call(this, method === 'end' ? getEndMessage(state) : getExpectingMessage(state, method, args), options) || this;
+        _this.state = state;
+        _this.method = method;
+        _this.args = args;
+        return _this;
+    }
+    return InvalidOrder;
+}(errors_1.AssertionError));
+exports.InvalidOrder = InvalidOrder;
+function getEndMessage(state) {
+    return "Planned for ".concat(state.maxStep, " step but expecting step ").concat(state.step, " when 'end()' is called");
+}
+function getExpectingMessage(state, method, args) {
+    return "Expecting ".concat(getExpectingCalls(state), ", but received '").concat(method, "(").concat(getMethodArgs(args), ")'");
+}
+function getExpectingCalls(state) {
+    var message;
+    if (state.subStep === 0) {
+        var methods = ['is', 'once', 'any'];
+        message = methods.map(function (m) { return "'".concat(m, "(").concat(['any'].indexOf(m) === -1 ? state.step : "[".concat(state.step, "]"), ")'"); }).join(', ');
+    }
+    else {
+        var methods = ['exactly'];
+        message = methods.map(function (m) { return "'".concat(m, "(").concat(state.step, ", ").concat(state.maxSubStep, ")'"); }).join(', ');
+    }
+    return message;
+}
+function getMethodArgs(args) {
+    return args.map(function (a) { return Array.isArray(a) ? "[".concat(a.join(', '), "]") : a; }).join(', ');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{dist-es5 → cjs}/assert-order/StateMachine.d.ts

@@ -1,23 +1,22 @@
-import { State } from './interfaces';
+import { State } from './types';
 export declare class StateMachine {
-    listeners: {};
+    listeners: Record<number, Array<() => void>>;
     step: number;
     maxStep?: number;
     subStep: number;
     minSubStep?: number;
     maxSubStep?: number;
-    private startTick;
     constructor(maxStep?: number);
     jump(step: number): number;
     move(): number;
     moveSubStep(): number;
     get(): State;
-    on(step: number, listener: any): void;
+    on(step: number, listener: () => void): void;
     isNotValid(step: number): boolean;
     isValid(step: number): boolean;
     isMaxStepDefined(): boolean;
     stopAccepting(): void;
     isAccepting(): boolean;
-    getTimeTaken(): any;
-    private getStartTick;
+    getTimeTaken(): number;
 }
+//# sourceMappingURL=StateMachine.d.ts.map

package/cjs/assert-order/StateMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateMachine.d.ts","sourceRoot":"","sources":["../../src/assert-order/StateMachine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AA4C/B,qBAAa,YAAY;IACvB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,CAAK;IACjD,IAAI,SAAI;IACR,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB,OAAO,SAAI;IACX,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;gBACP,OAAO,CAAC,EAAE,MAAM;IAI5B,IAAI,CAAC,IAAI,EAAE,MAAM;IAKjB,IAAI;IASJ,WAAW;IAMX,GAAG,IAAI,KAAK;IAUZ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI;IAGrC,UAAU,CAAC,IAAI,EAAE,MAAM;IAGvB,OAAO,CAAC,IAAI,EAAE,MAAM;IAGpB,gBAAgB;IAGhB,aAAa;IAGb,WAAW;IAIX,YAAY;CAGb"}

package/cjs/assert-order/StateMachine.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachine = void 0;
+var tslib_1 = require("tslib");
+var is_node_1 = (0, tslib_1.__importDefault)(require("is-node"));
+// istanbul ignore next
+function nodeVersionIsOrAbove(major, minor, patch) {
+    if (minor === void 0) { minor = 0; }
+    if (patch === void 0) { patch = 0; }
+    // without this, systemJS will complain `process is not defined`
+    if (!global.process)
+        return false;
+    var versionString = process.version.startsWith('v') ? process.version.slice(1) : process.version;
+    var _a = versionString.split('.').map(function (s) { return parseInt(s, 10); }), actualMajor = _a[0], actualMinor = _a[1], actualPatch = _a[2];
+    var checking = major * 1000 * 1000 + minor * 1000 + patch;
+    var actual = actualMajor * 1000 * 1000 + actualMinor * 1000 + actualPatch;
+    return actual >= checking;
+}
+// istanbul ignore next
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+var performance = is_node_1.default && nodeVersionIsOrAbove(8, 5) ? require('perf_hooks').performance : undefined;
+var timeTracker;
+// istanbul ignore else
+if (process && typeof process.hrtime === 'function') {
+    var tick_1;
+    timeTracker = {
+        start: function () { tick_1 = process.hrtime(); },
+        taken: function () {
+            var _a = process.hrtime(tick_1), second = _a[0], nanoSecond = _a[1];
+            return second * 1000 + nanoSecond / 1e6;
+        }
+    };
+}
+else if (performance && typeof performance.now === 'function') {
+    var tick_2;
+    timeTracker = {
+        start: function () { tick_2 = performance.now(); },
+        taken: function () { return performance.now() - tick_2; }
+    };
+}
+else {
+    var tick_3;
+    timeTracker = {
+        start: function () { tick_3 = new Date().valueOf(); },
+        taken: function () { return new Date().valueOf() - tick_3; }
+    };
+}
+var StateMachine = /** @class */ (function () {
+    function StateMachine(maxStep) {
+        this.listeners = {};
+        this.step = 1;
+        this.subStep = 0;
+        this.maxStep = maxStep;
+        timeTracker.start();
+    }
+    StateMachine.prototype.jump = function (step) {
+        this.step = step;
+        this.subStep = 0;
+        return this.step;
+    };
+    StateMachine.prototype.move = function () {
+        var listeners = this.listeners[this.step];
+        this.step = this.step + 1;
+        this.subStep = 0;
+        if (listeners) {
+            listeners.forEach(function (l) { return l(); });
+        }
+        return this.step;
+    };
+    StateMachine.prototype.moveSubStep = function () {
+        var subStep = ++this.subStep;
+        if (this.maxSubStep === this.subStep)
+            this.move();
+        return subStep;
+    };
+    StateMachine.prototype.get = function () {
+        var _a = this, step = _a.step, subStep = _a.subStep, maxStep = _a.maxStep, minSubStep = _a.minSubStep, maxSubStep = _a.maxSubStep;
+        return {
+            step: step,
+            maxStep: maxStep,
+            subStep: subStep,
+            minSubStep: minSubStep,
+            maxSubStep: maxSubStep
+        };
+    };
+    StateMachine.prototype.on = function (step, listener) {
+        this.listeners[step] = [listener];
+    };
+    StateMachine.prototype.isNotValid = function (step) {
+        return step !== this.step || (this.maxStep !== undefined && this.maxStep < step);
+    };
+    StateMachine.prototype.isValid = function (step) {
+        return step === this.step;
+    };
+    StateMachine.prototype.isMaxStepDefined = function () {
+        return this.maxStep !== undefined;
+    };
+    StateMachine.prototype.stopAccepting = function () {
+        this.maxStep = this.step - 1;
+    };
+    StateMachine.prototype.isAccepting = function () {
+        // istanbul ignore next
+        return this.maxStep ? this.maxStep >= this.step : true;
+    };
+    StateMachine.prototype.getTimeTaken = function () {
+        return timeTracker.taken();
+    };
+    return StateMachine;
+}());
+exports.StateMachine = StateMachine;
+//# sourceMappingURL=data:application/json;base64,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

package/cjs/assert-order/index.d.ts

@@ -0,0 +1,4 @@
+export * from './AssertOrder';
+export * from './InvalidOrder';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/cjs/assert-order/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/assert-order/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,SAAS,CAAA"}

package/cjs/assert-order/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./AssertOrder"), exports);
+(0, tslib_1.__exportStar)(require("./InvalidOrder"), exports);
+(0, tslib_1.__exportStar)(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXNzZXJ0LW9yZGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDZEQUE2QjtBQUM3Qiw4REFBOEI7QUFDOUIsdURBQXVCIn0=

package/{dist-es2015/assert-order/interfaces.d.ts → cjs/assert-order/types.d.ts}

@@ -5,3 +5,4 @@ export interface State {
     minSubStep?: number;
     maxSubStep?: number;
 }
+//# sourceMappingURL=types.d.ts.map

package/cjs/assert-order/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/assert-order/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/cjs/assert-order/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXNzZXJ0LW9yZGVyL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/{dist-es2015 → cjs}/assertron/assertron.d.ts

@@ -18,3 +18,4 @@ export declare const assertron: {
     true(value: any): void;
     truthy: typeof truthy;
 };
+//# sourceMappingURL=assertron.d.ts.map

package/cjs/assertron/assertron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertron.d.ts","sourceRoot":"","sources":["../../src/assertron/assertron.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,eAAO,MAAM,SAAS;iBACP,GAAG;;;;;;;;gBAWJ,GAAG;;CAKhB,CAAA"}