From 19ecca01797661a9b2f1725d1197aac6ade79837 Mon Sep 17 00:00:00 2001 From: Phil Kunz Date: Wed, 8 Jul 2020 00:15:44 +0000 Subject: [PATCH] fix(core): update --- dist_ts/index.d.ts | 2 + dist_ts/index.js | 7 ++ dist_ts/tapbundle.classes.pretask.d.ts | 10 ++ dist_ts/tapbundle.classes.pretask.js | 16 +++ dist_ts/tapbundle.classes.tap.d.ts | 50 ++++++++ dist_ts/tapbundle.classes.tap.js | 160 ++++++++++++++++++++++++ dist_ts/tapbundle.classes.taptest.d.ts | 29 +++++ dist_ts/tapbundle.classes.taptest.js | 78 ++++++++++++ dist_ts/tapbundle.classes.taptools.d.ts | 24 ++++ dist_ts/tapbundle.classes.taptools.js | 69 ++++++++++ dist_ts/tapbundle.classes.tapwrap.d.ts | 14 +++ dist_ts/tapbundle.classes.tapwrap.js | 21 ++++ dist_ts/tapbundle.plugins.d.ts | 4 + dist_ts/tapbundle.plugins.js | 34 +++++ dist_ts/tapbundle.tapcreator.d.ts | 3 + dist_ts/tapbundle.tapcreator.js | 8 ++ package.json | 2 +- 17 files changed, 530 insertions(+), 1 deletion(-) create mode 100644 dist_ts/index.d.ts create mode 100644 dist_ts/index.js create mode 100644 dist_ts/tapbundle.classes.pretask.d.ts create mode 100644 dist_ts/tapbundle.classes.pretask.js create mode 100644 dist_ts/tapbundle.classes.tap.d.ts create mode 100644 dist_ts/tapbundle.classes.tap.js create mode 100644 dist_ts/tapbundle.classes.taptest.d.ts create mode 100644 dist_ts/tapbundle.classes.taptest.js create mode 100644 dist_ts/tapbundle.classes.taptools.d.ts create mode 100644 dist_ts/tapbundle.classes.taptools.js create mode 100644 dist_ts/tapbundle.classes.tapwrap.d.ts create mode 100644 dist_ts/tapbundle.classes.tapwrap.js create mode 100644 dist_ts/tapbundle.plugins.d.ts create mode 100644 dist_ts/tapbundle.plugins.js create mode 100644 dist_ts/tapbundle.tapcreator.d.ts create mode 100644 dist_ts/tapbundle.tapcreator.js diff --git a/dist_ts/index.d.ts b/dist_ts/index.d.ts new file mode 100644 index 0000000..44e5086 --- /dev/null +++ b/dist_ts/index.d.ts @@ -0,0 +1,2 @@ +export { expect } from 'smartchai'; +export { tap } from './tapbundle.classes.tap'; diff --git a/dist_ts/index.js b/dist_ts/index.js new file mode 100644 index 0000000..e3b161f --- /dev/null +++ b/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= \ No newline at end of file diff --git a/dist_ts/tapbundle.classes.pretask.d.ts b/dist_ts/tapbundle.classes.pretask.d.ts new file mode 100644 index 0000000..12328e6 --- /dev/null +++ b/dist_ts/tapbundle.classes.pretask.d.ts @@ -0,0 +1,10 @@ +import { TapTools } from './tapbundle.classes.taptools'; +export interface IPreTaskFunction { + (tapTools?: TapTools): Promise; +} +export declare class PreTask { + description: string; + preTaskFunction: IPreTaskFunction; + constructor(descriptionArg: string, preTaskFunctionArg: IPreTaskFunction); + run(): Promise; +} diff --git a/dist_ts/tapbundle.classes.pretask.js b/dist_ts/tapbundle.classes.pretask.js new file mode 100644 index 0000000..36288da --- /dev/null +++ b/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= \ No newline at end of file diff --git a/dist_ts/tapbundle.classes.tap.d.ts b/dist_ts/tapbundle.classes.tap.d.ts new file mode 100644 index 0000000..5d0f680 --- /dev/null +++ b/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; + 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; + /** + * handle errors + */ + threw(err: any): void; +} +export declare let tap: Tap; diff --git a/dist_ts/tapbundle.classes.tap.js b/dist_ts/tapbundle.classes.tap.js new file mode 100644 index 0000000..ec0edc1 --- /dev/null +++ b/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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 \ No newline at end of file diff --git a/dist_ts/tapbundle.classes.taptest.d.ts b/dist_ts/tapbundle.classes.taptest.d.ts new file mode 100644 index 0000000..f194c6b --- /dev/null +++ b/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; +export declare class TapTest { + description: string; + failureAllowed: boolean; + hrtMeasurement: HrtMeasurement; + parallel: boolean; + status: TTestStatus; + tapTools: TapTools; + testFunction: ITestFunction; + testKey: number; + testDeferred: Deferred; + testPromise: Promise; + /** + * constructor + */ + constructor(optionsArg: { + description: string; + testFunction: ITestFunction; + parallel: boolean; + }); + /** + * run the test + */ + run(testKeyArg: number): Promise; +} diff --git a/dist_ts/tapbundle.classes.taptest.js b/dist_ts/tapbundle.classes.taptest.js new file mode 100644 index 0000000..2bfe21e --- /dev/null +++ b/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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 \ No newline at end of file diff --git a/dist_ts/tapbundle.classes.taptools.d.ts b/dist_ts/tapbundle.classes.taptools.d.ts new file mode 100644 index 0000000..163057b --- /dev/null +++ b/dist_ts/tapbundle.classes.taptools.d.ts @@ -0,0 +1,24 @@ +import * as plugins from './tapbundle.plugins'; +export interface IPromiseFunc { + (): Promise; +} +export declare class TapTools { + /** + * the referenced TapTest + */ + private _tapTest; + constructor(TapTestArg: any); + /** + * allow failure + */ + allowFailure(): void; + /** + * async/await delay method + */ + delayFor(timeMilliArg: any): Promise; + delayForRandom(timeMilliMinArg: any, timeMilliMaxArg: any): Promise; + timeout(timeMilliArg: number): Promise; + checkIterationLeak(iterationfuncArg: IPromiseFunc): Promise; + returnError(throwingFuncArg: IPromiseFunc): Promise; + defer(): plugins.smartpromise.Deferred; +} diff --git a/dist_ts/tapbundle.classes.taptools.js b/dist_ts/tapbundle.classes.taptools.js new file mode 100644 index 0000000..3fe90c7 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/dist_ts/tapbundle.classes.tapwrap.d.ts b/dist_ts/tapbundle.classes.tapwrap.d.ts new file mode 100644 index 0000000..37c3503 --- /dev/null +++ b/dist_ts/tapbundle.classes.tapwrap.d.ts @@ -0,0 +1,14 @@ +export interface ITapWrapFunction { + (): Promise; +} +export declare class TapWrap { + wrapFunction: ITapWrapFunction; + /** + * the constructor + */ + constructor(wrapFunctionArg: ITapWrapFunction); + /** + * run the wrapFunction + */ + run(): Promise; +} diff --git a/dist_ts/tapbundle.classes.tapwrap.js b/dist_ts/tapbundle.classes.tapwrap.js new file mode 100644 index 0000000..de68f55 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/dist_ts/tapbundle.plugins.d.ts b/dist_ts/tapbundle.plugins.d.ts new file mode 100644 index 0000000..f026290 --- /dev/null +++ b/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 }; diff --git a/dist_ts/tapbundle.plugins.js b/dist_ts/tapbundle.plugins.js new file mode 100644 index 0000000..e8c9c7a --- /dev/null +++ b/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= \ No newline at end of file diff --git a/dist_ts/tapbundle.tapcreator.d.ts b/dist_ts/tapbundle.tapcreator.d.ts new file mode 100644 index 0000000..b7a3550 --- /dev/null +++ b/dist_ts/tapbundle.tapcreator.d.ts @@ -0,0 +1,3 @@ +export declare class TapCreator { +} +export declare let tapCreator: TapCreator; diff --git a/dist_ts/tapbundle.tapcreator.js b/dist_ts/tapbundle.tapcreator.js new file mode 100644 index 0000000..b7c4c4e --- /dev/null +++ b/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== \ No newline at end of file diff --git a/package.json b/package.json index 9cb107c..5013a3c 100644 --- a/package.json +++ b/package.json @@ -7,7 +7,7 @@ "typings": "dist/index.d.ts", "scripts": { "test": "(tstest test/)", - "build": "(tsbuild)" + "build": "(tsbuild --web)" }, "repository": { "type": "git",