fix(core): update

dist_ts/index.d.ts

@@ -0,0 +1,2 @@
+export { expect } from 'smartchai';
+export { tap } from './tapbundle.classes.tap';

dist_ts/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var smartchai_1 = require("smartchai");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return smartchai_1.expect; } });
+var tapbundle_classes_tap_1 = require("./tapbundle.classes.tap");
+Object.defineProperty(exports, "tap", { enumerable: true, get: function () { return tapbundle_classes_tap_1.tap; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHVDQUFtQztBQUExQixtR0FBQSxNQUFNLE9BQUE7QUFDZixpRUFBOEM7QUFBckMsNEdBQUEsR0FBRyxPQUFBIn0=

dist_ts/tapbundle.classes.pretask.d.ts

@@ -0,0 +1,10 @@
+import { TapTools } from './tapbundle.classes.taptools';
+export interface IPreTaskFunction {
+    (tapTools?: TapTools): Promise<any>;
+}
+export declare class PreTask {
+    description: string;
+    preTaskFunction: IPreTaskFunction;
+    constructor(descriptionArg: string, preTaskFunctionArg: IPreTaskFunction);
+    run(): Promise<void>;
+}

dist_ts/tapbundle.classes.pretask.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreTask = void 0;
+const tapbundle_classes_taptools_1 = require("./tapbundle.classes.taptools");
+class PreTask {
+    constructor(descriptionArg, preTaskFunctionArg) {
+        this.description = descriptionArg;
+        this.preTaskFunction = preTaskFunctionArg;
+    }
+    async run() {
+        console.log(`::__PRETASK: ${this.description}`);
+        await this.preTaskFunction(new tapbundle_classes_taptools_1.TapTools(null));
+    }
+}
+exports.PreTask = PreTask;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLmNsYXNzZXMucHJldGFzay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3RhcGJ1bmRsZS5jbGFzc2VzLnByZXRhc2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsNkVBQXdEO0FBT3hELE1BQWEsT0FBTztJQUlsQixZQUFZLGNBQXNCLEVBQUUsa0JBQW9DO1FBQ3RFLElBQUksQ0FBQyxXQUFXLEdBQUcsY0FBYyxDQUFDO1FBQ2xDLElBQUksQ0FBQyxlQUFlLEdBQUcsa0JBQWtCLENBQUM7SUFDNUMsQ0FBQztJQUVNLEtBQUssQ0FBQyxHQUFHO1FBQ2QsT0FBTyxDQUFDLEdBQUcsQ0FBQyxnQkFBZ0IsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUM7UUFDaEQsTUFBTSxJQUFJLENBQUMsZUFBZSxDQUFDLElBQUkscUNBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ2pELENBQUM7Q0FDRjtBQWJELDBCQWFDIn0=

dist_ts/tapbundle.classes.tap.d.ts

@@ -0,0 +1,50 @@
+import { IPreTaskFunction } from './tapbundle.classes.pretask';
+import { TapTest, ITestFunction } from './tapbundle.classes.taptest';
+import { TapWrap, ITapWrapFunction } from './tapbundle.classes.tapwrap';
+export declare class Tap {
+    /**
+     * skips a test
+     * tests marked with tap.skip.test() are never executed
+     */
+    skip: {
+        test: (descriptionArg: string, functionArg: ITestFunction) => void;
+        testParallel: (descriptionArg: string, functionArg: ITestFunction) => void;
+    };
+    /**
+     * only executes tests marked as ONLY
+     */
+    only: {
+        test: (descriptionArg: string, testFunctionArg: ITestFunction) => void;
+    };
+    private _tapPreTasks;
+    private _tapTests;
+    private _tapTestsOnly;
+    /**
+     * Normal test function, will run one by one
+     * @param testDescription - A description of what the test does
+     * @param testFunction - A Function that returns a Promise and resolves or rejects
+     */
+    test(testDescription: string, testFunction: ITestFunction, modeArg?: 'normal' | 'only' | 'skip'): Promise<TapTest>;
+    preTask(descriptionArg: string, functionArg: IPreTaskFunction): void;
+    /**
+     * wraps function
+     */
+    wrap(functionArg: ITapWrapFunction): TapWrap;
+    /**
+     * A parallel test that will not be waited for before the next starts.
+     * @param testDescription - A description of what the test does
+     * @param testFunction - A Function that returns a Promise and resolves or rejects
+     */
+    testParallel(testDescription: string, testFunction: ITestFunction): void;
+    /**
+     * starts the test evaluation
+     */
+    start(optionsArg?: {
+        throwOnError: boolean;
+    }): Promise<void>;
+    /**
+     * handle errors
+     */
+    threw(err: any): void;
+}
+export declare let tap: Tap;

dist_ts/tapbundle.classes.tap.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tap = exports.Tap = void 0;
+const plugins = __importStar(require("./tapbundle.plugins"));
+const tapbundle_classes_pretask_1 = require("./tapbundle.classes.pretask");
+const tapbundle_classes_taptest_1 = require("./tapbundle.classes.taptest");
+const tapbundle_classes_tapwrap_1 = require("./tapbundle.classes.tapwrap");
+class Tap {
+    constructor() {
+        /**
+         * skips a test
+         * tests marked with tap.skip.test() are never executed
+         */
+        this.skip = {
+            test: (descriptionArg, functionArg) => {
+                console.log(`skipped test: ${descriptionArg}`);
+            },
+            testParallel: (descriptionArg, functionArg) => {
+                console.log(`skipped test: ${descriptionArg}`);
+            }
+        };
+        /**
+         * only executes tests marked as ONLY
+         */
+        this.only = {
+            test: (descriptionArg, testFunctionArg) => {
+                this.test(descriptionArg, testFunctionArg, 'only');
+            }
+        };
+        this._tapPreTasks = [];
+        this._tapTests = [];
+        this._tapTestsOnly = [];
+    }
+    /**
+     * Normal test function, will run one by one
+     * @param testDescription - A description of what the test does
+     * @param testFunction - A Function that returns a Promise and resolves or rejects
+     */
+    async test(testDescription, testFunction, modeArg = 'normal') {
+        const localTest = new tapbundle_classes_taptest_1.TapTest({
+            description: testDescription,
+            testFunction,
+            parallel: false
+        });
+        if (modeArg === 'normal') {
+            this._tapTests.push(localTest);
+        }
+        else if (modeArg === 'only') {
+            this._tapTestsOnly.push(localTest);
+        }
+        return localTest;
+    }
+    preTask(descriptionArg, functionArg) {
+        this._tapPreTasks.push(new tapbundle_classes_pretask_1.PreTask(descriptionArg, functionArg));
+    }
+    /**
+     * wraps function
+     */
+    wrap(functionArg) {
+        return new tapbundle_classes_tapwrap_1.TapWrap(functionArg);
+    }
+    /**
+     * A parallel test that will not be waited for before the next starts.
+     * @param testDescription - A description of what the test does
+     * @param testFunction - A Function that returns a Promise and resolves or rejects
+     */
+    testParallel(testDescription, testFunction) {
+        this._tapTests.push(new tapbundle_classes_taptest_1.TapTest({
+            description: testDescription,
+            testFunction,
+            parallel: true
+        }));
+    }
+    /**
+     * starts the test evaluation
+     */
+    async start(optionsArg) {
+        // lets set the tapbundle promise
+        const smartenvInstance = new plugins.smartenv.Smartenv();
+        smartenvInstance.isBrowser ? globalThis.tapbundleDeferred = plugins.smartpromise.defer() : null;
+        // lets continue with running the tests
+        const promiseArray = [];
+        // safeguard against empty test array
+        if (this._tapTests.length === 0) {
+            console.log('no tests specified. Ending here!');
+            // TODO: throw proper error
+            return;
+        }
+        // determine which tests to run
+        let concerningTests;
+        if (this._tapTestsOnly.length > 0) {
+            concerningTests = this._tapTestsOnly;
+        }
+        else {
+            concerningTests = this._tapTests;
+        }
+        // lets run the pretasks
+        for (const preTask of this._tapPreTasks) {
+            await preTask.run();
+        }
+        console.log(`1..${concerningTests.length}`);
+        for (let testKey = 0; testKey < concerningTests.length; testKey++) {
+            const currentTest = concerningTests[testKey];
+            const testPromise = currentTest.run(testKey);
+            if (currentTest.parallel) {
+                promiseArray.push(testPromise);
+            }
+            else {
+                await testPromise;
+            }
+        }
+        await Promise.all(promiseArray);
+        // when tests have been run and all promises are fullfilled
+        const failReasons = [];
+        const executionNotes = [];
+        // collect failed tests
+        for (const tapTest of concerningTests) {
+            if (tapTest.status !== 'success') {
+                failReasons.push(`Test ${tapTest.testKey + 1} failed with status ${tapTest.status}:\n` +
+                    `|| ${tapTest.description}\n` +
+                    `|| for more information please take a look the logs above`);
+            }
+        }
+        // render fail Reasons
+        for (const failReason of failReasons) {
+            console.log(failReason);
+        }
+        if (optionsArg && optionsArg.throwOnError && failReasons.length > 0) {
+            process.exit(1);
+        }
+    }
+    /**
+     * handle errors
+     */
+    threw(err) {
+        console.log(err);
+    }
+}
+exports.Tap = Tap;
+exports.tap = new Tap();
+//# sourceMappingURL=data:application/json;base64,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

dist_ts/tapbundle.classes.taptest.d.ts

@@ -0,0 +1,29 @@
+import { TapTools } from './tapbundle.classes.taptools';
+import { Deferred } from '@pushrocks/smartpromise';
+import { HrtMeasurement } from '@pushrocks/smarttime';
+export declare type TTestStatus = 'success' | 'error' | 'pending' | 'errorAfterSuccess' | 'timeout';
+export declare type ITestFunction = (tapTools?: TapTools) => Promise<any>;
+export declare class TapTest {
+    description: string;
+    failureAllowed: boolean;
+    hrtMeasurement: HrtMeasurement;
+    parallel: boolean;
+    status: TTestStatus;
+    tapTools: TapTools;
+    testFunction: ITestFunction;
+    testKey: number;
+    testDeferred: Deferred<TapTest>;
+    testPromise: Promise<TapTest>;
+    /**
+     * constructor
+     */
+    constructor(optionsArg: {
+        description: string;
+        testFunction: ITestFunction;
+        parallel: boolean;
+    });
+    /**
+     * run the test
+     */
+    run(testKeyArg: number): Promise<void>;
+}

dist_ts/tapbundle.classes.taptest.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TapTest = void 0;
+const plugins = __importStar(require("./tapbundle.plugins"));
+const tapbundle_classes_taptools_1 = require("./tapbundle.classes.taptools");
+const smarttime_1 = require("@pushrocks/smarttime");
+class TapTest {
+    /**
+     * constructor
+     */
+    constructor(optionsArg) {
+        this.testDeferred = plugins.smartpromise.defer();
+        this.testPromise = this.testDeferred.promise;
+        this.description = optionsArg.description;
+        this.hrtMeasurement = new smarttime_1.HrtMeasurement();
+        this.parallel = optionsArg.parallel;
+        this.status = 'pending';
+        this.tapTools = new tapbundle_classes_taptools_1.TapTools(this);
+        this.testFunction = optionsArg.testFunction;
+    }
+    /**
+     * run the test
+     */
+    async run(testKeyArg) {
+        this.hrtMeasurement.start();
+        this.testKey = testKeyArg;
+        const testNumber = testKeyArg + 1;
+        try {
+            await this.testFunction(this.tapTools);
+            if (this.status === 'timeout') {
+                throw new Error('Test succeeded, but timed out...');
+            }
+            this.hrtMeasurement.stop();
+            console.log(`ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`);
+            this.status = 'success';
+            this.testDeferred.resolve(this);
+        }
+        catch (err) {
+            this.hrtMeasurement.stop();
+            console.log(`not ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`);
+            this.testDeferred.resolve(this);
+            // if the test has already succeeded before
+            if (this.status === 'success') {
+                this.status = 'errorAfterSuccess';
+                console.log('!!! ALERT !!!: weird behaviour, since test has been already successfull');
+            }
+            else {
+                this.status = 'error';
+            }
+            // if the test is allowed to fail
+            if (this.failureAllowed) {
+                console.log(`please note: failure allowed!`);
+            }
+            console.log(err);
+        }
+    }
+}
+exports.TapTest = TapTest;
+//# sourceMappingURL=data:application/json;base64,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

dist_ts/tapbundle.classes.taptools.d.ts

@@ -0,0 +1,24 @@
+import * as plugins from './tapbundle.plugins';
+export interface IPromiseFunc {
+    (): Promise<any>;
+}
+export declare class TapTools {
+    /**
+     * the referenced TapTest
+     */
+    private _tapTest;
+    constructor(TapTestArg: any);
+    /**
+     * allow failure
+     */
+    allowFailure(): void;
+    /**
+     * async/await delay method
+     */
+    delayFor(timeMilliArg: any): Promise<void>;
+    delayForRandom(timeMilliMinArg: any, timeMilliMaxArg: any): Promise<void>;
+    timeout(timeMilliArg: number): Promise<void>;
+    checkIterationLeak(iterationfuncArg: IPromiseFunc): Promise<void>;
+    returnError(throwingFuncArg: IPromiseFunc): Promise<Error>;
+    defer(): plugins.smartpromise.Deferred<unknown>;
+}

dist_ts/tapbundle.classes.taptools.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TapTools = void 0;
+const plugins = __importStar(require("./tapbundle.plugins"));
+class TapTools {
+    constructor(TapTestArg) {
+        this._tapTest = TapTestArg;
+    }
+    /**
+     * allow failure
+     */
+    allowFailure() {
+        this._tapTest.failureAllowed = true;
+    }
+    /**
+     * async/await delay method
+     */
+    async delayFor(timeMilliArg) {
+        await plugins.smartdelay.delayFor(timeMilliArg);
+    }
+    async delayForRandom(timeMilliMinArg, timeMilliMaxArg) {
+        await plugins.smartdelay.delayForRandom(timeMilliMinArg, timeMilliMaxArg);
+    }
+    async timeout(timeMilliArg) {
+        const timeout = new plugins.smartdelay.Timeout(timeMilliArg);
+        timeout.makeUnrefed();
+        await timeout.promise;
+        if (this._tapTest.status === 'pending') {
+            this._tapTest.status = 'timeout';
+        }
+    }
+    async checkIterationLeak(iterationfuncArg) {
+        console.log('iteration leakage checks disabled for now due to incompatibilities with node v12');
+    }
+    async returnError(throwingFuncArg) {
+        let funcErr;
+        try {
+            await throwingFuncArg();
+        }
+        catch (err) {
+            funcErr = err;
+        }
+        return funcErr;
+    }
+    defer() {
+        return plugins.smartpromise.defer();
+    }
+}
+exports.TapTools = TapTools;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLmNsYXNzZXMudGFwdG9vbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90YXBidW5kbGUuY2xhc3Nlcy50YXB0b29scy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNkRBQStDO0FBTy9DLE1BQWEsUUFBUTtJQU1uQixZQUFZLFVBQVU7UUFDcEIsSUFBSSxDQUFDLFFBQVEsR0FBRyxVQUFVLENBQUM7SUFDN0IsQ0FBQztJQUVEOztPQUVHO0lBQ0ksWUFBWTtRQUNqQixJQUFJLENBQUMsUUFBUSxDQUFDLGNBQWMsR0FBRyxJQUFJLENBQUM7SUFDdEMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLFFBQVEsQ0FBQyxZQUFZO1FBQ2hDLE1BQU0sT0FBTyxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDbEQsQ0FBQztJQUVNLEtBQUssQ0FBQyxjQUFjLENBQUMsZUFBZSxFQUFFLGVBQWU7UUFDMUQsTUFBTSxPQUFPLENBQUMsVUFBVSxDQUFDLGNBQWMsQ0FBQyxlQUFlLEVBQUUsZUFBZSxDQUFDLENBQUM7SUFDNUUsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPLENBQUMsWUFBb0I7UUFDdkMsTUFBTSxPQUFPLEdBQUcsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUM3RCxPQUFPLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDdEIsTUFBTSxPQUFPLENBQUMsT0FBTyxDQUFDO1FBQ3RCLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEtBQUssU0FBUyxFQUFFO1lBQ3RDLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQztTQUNsQztJQUNILENBQUM7SUFFTSxLQUFLLENBQUMsa0JBQWtCLENBQUMsZ0JBQThCO1FBQzVELE9BQU8sQ0FBQyxHQUFHLENBQUMsa0ZBQWtGLENBQUMsQ0FBQztJQUNsRyxDQUFDO0lBRU0sS0FBSyxDQUFDLFdBQVcsQ0FBQyxlQUE2QjtRQUNwRCxJQUFJLE9BQWMsQ0FBQztRQUNuQixJQUFJO1lBQ0YsTUFBTSxlQUFlLEVBQUUsQ0FBQztTQUN6QjtRQUFDLE9BQU8sR0FBRyxFQUFFO1lBQ1osT0FBTyxHQUFHLEdBQUcsQ0FBQztTQUNmO1FBQ0QsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztJQUVNLEtBQUs7UUFDVixPQUFPLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDdEMsQ0FBQztDQUNGO0FBdERELDRCQXNEQyJ9

dist_ts/tapbundle.classes.tapwrap.d.ts

@@ -0,0 +1,14 @@
+export interface ITapWrapFunction {
+    (): Promise<any>;
+}
+export declare class TapWrap {
+    wrapFunction: ITapWrapFunction;
+    /**
+     * the constructor
+     */
+    constructor(wrapFunctionArg: ITapWrapFunction);
+    /**
+     * run the wrapFunction
+     */
+    run(): Promise<void>;
+}

dist_ts/tapbundle.classes.tapwrap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TapWrap = void 0;
+class TapWrap {
+    /**
+     * the constructor
+     */
+    constructor(wrapFunctionArg) {
+        // nothing here
+        this.wrapFunction = wrapFunctionArg;
+    }
+    /**
+     * run the wrapFunction
+     */
+    async run() {
+        // TODO: make sure it makes sense what we do here.
+        await this.wrapFunction();
+    }
+}
+exports.TapWrap = TapWrap;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLmNsYXNzZXMudGFwd3JhcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3RhcGJ1bmRsZS5jbGFzc2VzLnRhcHdyYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBTUEsTUFBYSxPQUFPO0lBR2xCOztPQUVHO0lBQ0gsWUFBWSxlQUFpQztRQUMzQyxlQUFlO1FBQ2YsSUFBSSxDQUFDLFlBQVksR0FBRyxlQUFlLENBQUM7SUFDdEMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsS0FBSyxDQUFDLEdBQUc7UUFDUCxrREFBa0Q7UUFDbEQsTUFBTSxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDNUIsQ0FBQztDQUNGO0FBbEJELDBCQWtCQyJ9

dist_ts/tapbundle.plugins.d.ts

@@ -0,0 +1,4 @@
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartenv from '@pushrocks/smartenv';
+import * as smartpromise from '@pushrocks/smartpromise';
+export { smartdelay, smartenv, smartpromise };

dist_ts/tapbundle.plugins.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.smartpromise = exports.smartenv = exports.smartdelay = void 0;
+// pushrocks
+const smartdelay = __importStar(require("@pushrocks/smartdelay"));
+exports.smartdelay = smartdelay;
+const smartenv = __importStar(require("@pushrocks/smartenv"));
+exports.smartenv = smartenv;
+const smartpromise = __importStar(require("@pushrocks/smartpromise"));
+exports.smartpromise = smartpromise;
+// third party
+/* import * as leakage from 'leakage';
+
+export { leakage }; */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90YXBidW5kbGUucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsWUFBWTtBQUNaLGtFQUFvRDtBQUkzQyxnQ0FBVTtBQUhuQiw4REFBZ0Q7QUFHM0IsNEJBQVE7QUFGN0Isc0VBQXdEO0FBRXpCLG9DQUFZO0FBRTNDLGNBQWM7QUFDZDs7c0JBRXNCIn0=

dist_ts/tapbundle.tapcreator.d.ts

@@ -0,0 +1,3 @@
+export declare class TapCreator {
+}
+export declare let tapCreator: TapCreator;

dist_ts/tapbundle.tapcreator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tapCreator = exports.TapCreator = void 0;
+class TapCreator {
+}
+exports.TapCreator = TapCreator;
+exports.tapCreator = new TapCreator();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLnRhcGNyZWF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90YXBidW5kbGUudGFwY3JlYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQSxNQUFhLFVBQVU7Q0FFdEI7QUFGRCxnQ0FFQztBQUVVLFFBQUEsVUFBVSxHQUFHLElBQUksVUFBVSxFQUFFLENBQUMifQ==

package.json

@@ -7,7 +7,7 @@
   "typings": "dist/index.d.ts",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild --web)"
   },
   "repository": {
     "type": "git",