4.0.4

.gitignore

@@ -15,8 +15,6 @@ node_modules/
 
 # builds
 dist/
-dist_web/
-dist_serve/
-dist_ts_web/
+dist_*/
 
 # custom

.gitlab-ci.yml

@@ -19,22 +19,35 @@ mirror:
   stage: security
   script:
     - npmci git mirror
+  only:
+    - tags
   tags:
     - lossless
     - docker
     - notpriv
 
-snyk:
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
     - npmci npm prepare
-    - npmci command npm install -g snyk
-    - npmci command npm install --ignore-scripts
-    - npmci command snyk test
+    - npmci command npm install --production --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=prod --production
   tags:
-    - lossless
     - docker
-    - notpriv
+
+auditDevDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=dev
+  tags:
+    - docker
+  allow_failure: true
 
 # ====================
 # test stage
@@ -49,9 +62,7 @@ testStable:
     - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - priv
 
 testBuild:
   stage: test
@@ -62,9 +73,7 @@ testBuild:
     - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - notpriv
 
 release:
   stage: release
@@ -84,6 +93,8 @@ release:
 codequality:
   stage: metadata
   allow_failure: true
+  only:
+    - tags
   script:
     - npmci command npm install -g tslint typescript
     - npmci npm prepare

.snyk

@@ -1,15 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.12.0
-# ignores vulnerabilities until expiry date; change duration by modifying expiry date
-ignore:
-  'npm:shelljs:20140723':
-    - smartdelay > typings-global > smartshell > shelljs:
-        reason: None given
-        expires: '2018-07-28T21:47:33.536Z'
-    - early > typings-global > smartshell > shelljs:
-        reason: None given
-        expires: '2018-07-28T21:47:33.537Z'
-    - early > beautycolor > typings-global > smartshell > shelljs:
-        reason: None given
-        expires: '2018-07-28T21:47:33.537Z'
-patch: {}

.vscode/launch.json

@@ -0,0 +1,29 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "current file",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "${relativeFile}"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    },
+    {
+      "name": "test.ts",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "test/test.ts"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

README.md

@@ -1,76 +0,0 @@
-# @pushrocks/tapbundle
-tap bundled for tapbuffer
-
-## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/tapbundle)
-* [gitlab.com (source)](https://gitlab.com/pushrocks/tapbundle)
-* [github.com (source mirror)](https://github.com/pushrocks/tapbundle)
-* [docs (typedoc)](https://pushrocks.gitlab.io/tapbundle/)
-
-## Status for master
-[![build status](https://gitlab.com/pushrocks/tapbundle/badges/master/build.svg)](https://gitlab.com/pushrocks/tapbundle/commits/master)
-[![coverage report](https://gitlab.com/pushrocks/tapbundle/badges/master/coverage.svg)](https://gitlab.com/pushrocks/tapbundle/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/tapbundle.svg)](https://www.npmjs.com/package/@pushrocks/tapbundle)
-[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/tapbundle/badge.svg)](https://snyk.io/test/npm/@pushrocks/tapbundle)
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
-
-## Usage
-
-Use TypeScript for best in class instellisense.
-
-A few words on TypeScript
-
-### Included in this package
-
-- tap compatible testing framework written in TypeScript
-- a collection of test tools
-- **code** testing framework with typings
-
-### Write your first tests
-
-```javascript
-import { tap, expect } from 'tapbundle'; // has typings in place
-
-import * as myAwesomeModuleToTest from '../dist/index'; // '../dist/index' is the standard path for npmts modules
-
-tap.test('my awesome description', async tools => {
-  // tools are optional parameter
-  tools.timeout(2000); // test will fail if it takes longer than 2000 millisenconds
-});
-
-let myTest2 = tap.test('my awesome test 2', async tools => {
-  myAwsomeModuleToTest.doSomethingAsync(); // we don't wait here
-  await tools.delayFor(3000); // yay! :) promise based timeouts :)
-  console.log('This gets logged 3000 ms into the test');
-});
-
-tap.test('my awesome test 3', async tools => {
-  expect(true).to.be.true; // will not throw
-  await expect(tools.delayFor(2000)).to.eventually.be.fulfilled; // yay expect promises :)
-  expect((await myTest2.promise).hrtMeasurement.milliSeconds > 1000).to.be.true; // access other tests metadata :)
-});
-
-let myTest4 = tap.testParallel('my awesome test 4', async tools => {
-  await tools.delayFor(4000);
-  console.log('logs to console after 4 seconds into this test');
-});
-
-tap.test('my awesome test 5', async () => {
-  expect(myTest4.status).to.equal('pending'); // since this test will likely finish before myTest4.
-});
-
-tap.start(); // start the test, will automtically plan tests for you (so the tap parser knows when tests exit bofore they are finished)
-```
-
-## Contribution
-
-We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
-
-For further information read the linked docs at the top of this readme.
-
-> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
-
-[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

npmextra.json

@@ -9,6 +9,7 @@
     }
   },
   "gitzone": {
+    "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
       "gitscope": "pushrocks",

package.json

@@ -1,13 +1,13 @@
 {
   "name": "@pushrocks/tapbundle",
   "private": false,
-  "version": "3.2.3",
+  "version": "4.0.4",
   "description": "tap bundled for tapbuffer",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild --web)"
   },
   "repository": {
     "type": "git",
@@ -20,30 +20,35 @@
   },
   "homepage": "https://gitlab.com/pushrocks/tapbundle#README",
   "dependencies": {
-    "@pushrocks/smartdelay": "^2.0.9",
-    "@pushrocks/smartenv": "^4.0.10",
-    "@pushrocks/smartpromise": "^3.0.2",
-    "@pushrocks/smarttime": "^3.0.19",
-    "smartchai": "^2.0.1"
+    "@open-wc/testing-helpers": "^2.0.4",
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartenv": "^4.0.16",
+    "@pushrocks/smartexpect": "^1.0.12",
+    "@pushrocks/smartpromise": "^3.1.6",
+    "@pushrocks/smarttime": "^3.0.45"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.24",
-    "@gitzone/tsrun": "^1.2.12",
-    "@gitzone/tstest": "^1.0.36",
-    "@types/node": "^14.0.19",
-    "randomstring": "^1.1.5",
-    "tslint": "^6.1.2",
+    "@gitzone/tsbuild": "^2.1.29",
+    "@gitzone/tsrun": "^1.2.18",
+    "@gitzone/tstest": "^1.0.64",
+    "@types/node": "^17.0.18",
+    "randomstring": "^1.2.2",
+    "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },
   "files": [
     "ts/**/*",
     "ts_web/**/*",
     "dist/**/*",
-    "dist_web/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
     "dist_ts_web/**/*",
     "assets/**/*",
     "cli.js",
     "npmextra.json",
     "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
   ]
 }

readme.md

@@ -0,0 +1,84 @@
+# @pushrocks/tapbundle
+tap bundled for tapbuffer
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/tapbundle)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/tapbundle)
+* [github.com (source mirror)](https://github.com/pushrocks/tapbundle)
+* [docs (typedoc)](https://pushrocks.gitlab.io/tapbundle/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/tapbundle/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/tapbundle/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/tapbundle)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/tapbundle)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/tapbundle)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/tapbundle)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/tapbundle)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+
+## Usage
+
+Use TypeScript for best in class instellisense.
+
+A few words on TypeScript
+
+### Included in this package
+
+* tap compatible testing framework written in TypeScript
+* `expect` and `expectAsync` from the package `@pushrocks/smartexpect`
+
+### Write your first tests
+
+```typescript
+import { tap, expect, expectAsync } from 'tapbundle'; // has typings in place
+
+import * as myAwesomeModuleToTest from '../dist/index'; // '../dist/index' is the standard path for npmts modules
+
+tap.test('my awesome description', async (tools) => {
+  // tools are optional parameter
+  tools.timeout(2000); // test will fail if it takes longer than 2000 millisenconds
+});
+
+const myTest2 = tap.test('my awesome test 2', async (tools) => {
+  myAwsomeModuleToTest.doSomethingAsync(); // we don't wait here
+  await tools.delayFor(3000); // yay! :) promise based timeouts :)
+  console.log('This gets logged 3000 ms into the test');
+});
+
+tap.test('my awesome test 3', async (tools) => {
+  expect(true).toBeTrue(); // will not throw
+  await expectAsync(tools.delayFor(2000)).toBeUndefined(); // yay expect promises :)
+  expectAsync(myTest2.promise)  // access other tests metadata :)
+    .property('hrtMeasurement') // and drill down into properties
+    .property('milliSeconds').toBeGreaterThan(1000);
+});
+
+const myTest4 = tap.testParallel('my awesome test 4', async (tools) => {
+  await tools.delayFor(4000);
+  console.log('logs to console after 4 seconds into this test');
+});
+
+tap.test('my awesome test 5', async () => {
+  expect(myTest4.status).toEqual('pending'); // since this test will likely finish before myTest4.
+});
+
+tap.start(); // start the test, will automtically plan tests for you (so the tap parser knows when tests exit bofore they are finished)
+```
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+For further information read the linked docs at the top of this readme.
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

test/test.browser.ts

@@ -1,37 +1,42 @@
-import { tap, expect } from '../ts/index';
+import { tap, expect, webhelpers } from '../ts/index';
 
-tap.preTask('hi there', async () => {
+tap.preTask('custompretask', async () => {
   console.log('this is a pretask');
 });
 
-const test1 = tap.test('my first test -> expect true to be true', async () => {
-  return expect(true).to.be.true;
+tap.test('should have access to webhelpers', async () => {
+  const myElement = await webhelpers.fixture(webhelpers.html`<div></div>`);
+  expect(myElement).toBeInstanceOf(HTMLElement);
+  console.log(myElement);
 });
 
-const test2 = tap.test('my second test', async tools => {
+const test1 = tap.test('my first test -> expect true to be true', async () => {
+  return expect(true).toBeTrue();
+});
+
+const test2 = tap.test('my second test', async (tools) => {
   await tools.delayFor(50);
 });
 
 const test3 = tap.test(
   'my third test -> test2 should take longer than test1 and endure at least 1000ms',
   async () => {
-    expect((await test1).hrtMeasurement.milliSeconds < (await test2).hrtMeasurement.milliSeconds).to
-      .be.true;
-    expect((await test2).hrtMeasurement.milliSeconds > 10).to.be.true;
+    expect((await test1).hrtMeasurement.milliSeconds < (await test2).hrtMeasurement.milliSeconds).toBeTrue();
+    expect((await test2).hrtMeasurement.milliSeconds > 10).toBeTrue();
   }
 );
 
-const test4 = tap.skip.test('my 4th test -> should fail', async tools => {
+const test4 = tap.skip.test('my 4th test -> should fail', async (tools) => {
   tools.allowFailure();
-  expect(false).to.be.true;
+  expect(false).toBeTrue();
 });
 
-const test5 = tap.test('my 5th test -> should pass in about 500ms', async tools => {
+const test5 = tap.test('my 5th test -> should pass in about 500ms', async (tools) => {
   tools.timeout(1000);
   await tools.delayFor(500);
 });
 
-const test6 = tap.skip.test('my 6th test -> should fail after 1000ms', async tools => {
+const test6 = tap.skip.test('my 6th test -> should fail after 1000ms', async (tools) => {
   tools.allowFailure();
   tools.timeout(1000);
   await tools.delayFor(100);

test/test.iterationleak.ts

@@ -1,21 +0,0 @@
-import { tap, expect } from '../ts/index';
-import * as randomstring from 'randomstring';
-
-const test1 = tap.test('my first test -> expect true to be true', async tools => {
-  await tools.checkIterationLeak(async () => {
-    const domain = randomstring.generate(1000);
-  });
-});
-
-const outsideArray = [];
-
-const test2 = tap.test('should throw', async tools => {
-  const err = await tools.returnError(async () => {
-    await tools.checkIterationLeak(async () => {
-      outsideArray.push(randomstring.generate(1000));
-    });
-  });
-  expect(err).to.be.undefined;
-});
-
-tap.start();

test/test.tapwrap.ts

@@ -1,10 +1,5 @@
-import { tap, expect } from '../ts/index';
+import { tap, expect, TapWrap } from '../ts/index';
 
-const tapwrap = tap.wrap(async () => {
-  tap.test('should do something', async () => {
-    console.log('test1');
-  });
-  tap.start();
-});
+tap.test('should run a test', async () => {});
 
-tapwrap.run();
+tap.start();

test/test.ts

@@ -2,36 +2,40 @@ import { tap, expect } from '../ts/index';
 
 tap.preTask('hi there', async () => {
   console.log('this is a pretask');
-})
-
-const test1 = tap.test('my first test -> expect true to be true', async () => {
-  return expect(true).to.be.true;
 });
 
-const test2 = tap.test('my second test', async tools => {
+const test1 = tap.test('my first test -> expect true to be true', async () => {
+  return expect(true).toBeTrue();
+});
+
+const test2 = tap.test('my second test', async (tools) => {
   await tools.delayFor(1000);
 });
 
 const test3 = tap.test(
   'my third test -> test2 should take longer than test1 and endure at least 1000ms',
   async () => {
-    expect((await test1).hrtMeasurement.milliSeconds < (await test2).hrtMeasurement.milliSeconds).to
-      .be.true;
-    expect((await test2).hrtMeasurement.milliSeconds > 1000).to.be.true;
+    expect(
+      (await test1.testPromise).hrtMeasurement.milliSeconds <
+        (await test2).hrtMeasurement.milliSeconds
+    ).toBeTrue();
+    expect((await test2.testPromise).hrtMeasurement.milliSeconds > 1000).toBeTrue();
   }
 );
 
-const test4 = tap.skip.test('my 4th test -> should fail', async tools => {
+const test4 = tap.test('my 4th test -> should fail', async (tools) => {
   tools.allowFailure();
-  expect(false).to.be.true;
+  expect(false).toBeFalse();
+  return 'hello';
 });
 
-const test5 = tap.test('my 5th test -> should pass in about 500ms', async tools => {
+const test5 = tap.test('my 5th test -> should pass in about 500ms', async (tools) => {
+  const test4Result = await test4.testResultPromise;
   tools.timeout(1000);
   await tools.delayFor(500);
 });
 
-const test6 = tap.skip.test('my 6th test -> should fail after 1000ms', async tools => {
+const test6 = tap.skip.test('my 6th test -> should fail after 1000ms', async (tools) => {
   tools.allowFailure();
   tools.timeout(1000);
   await tools.delayFor(2000);

ts/index.ts

@@ -1,2 +1,10 @@
-export { expect } from 'smartchai';
 export { tap } from './tapbundle.classes.tap';
+export { TapWrap } from './tapbundle.classes.tapwrap';
+export { webhelpers } from './webhelpers';
+
+import { expect, expectAsync } from '@pushrocks/smartexpect';
+
+export {
+  expect,
+  expectAsync
+}

ts/tapbundle.classes.pretask.ts

@@ -1,7 +1,6 @@
 import * as plugins from './tapbundle.plugins';
 import { TapTools } from './tapbundle.classes.taptools';
 
-
 export interface IPreTaskFunction {
   (tapTools?: TapTools): Promise<any>;
 }
@@ -15,8 +14,8 @@ export class PreTask {
     this.preTaskFunction = preTaskFunctionArg;
   }
 
-  public async run () {
+  public async run() {
     console.log(`::__PRETASK: ${this.description}`);
     await this.preTaskFunction(new TapTools(null));
   }
-}
+}

ts/tapbundle.classes.tap.ts

@@ -2,48 +2,47 @@ import * as plugins from './tapbundle.plugins';
 
 import { IPreTaskFunction, PreTask } from './tapbundle.classes.pretask';
 import { TapTest, ITestFunction } from './tapbundle.classes.taptest';
-import { TapWrap, ITapWrapFunction } from './tapbundle.classes.tapwrap';
-export class Tap {
+export class Tap <T> {
   /**
    * skips a test
    * tests marked with tap.skip.test() are never executed
    */
   public skip = {
-    test: (descriptionArg: string, functionArg: ITestFunction) => {
+    test: (descriptionArg: string, functionArg: ITestFunction<T>) => {
       console.log(`skipped test: ${descriptionArg}`);
     },
-    testParallel: (descriptionArg: string, functionArg: ITestFunction) => {
+    testParallel: (descriptionArg: string, functionArg: ITestFunction<T>) => {
       console.log(`skipped test: ${descriptionArg}`);
-    }
+    },
   };
 
   /**
    * only executes tests marked as ONLY
    */
   public only = {
-    test: (descriptionArg: string, testFunctionArg: ITestFunction) => {
+    test: (descriptionArg: string, testFunctionArg: ITestFunction<T>) => {
       this.test(descriptionArg, testFunctionArg, 'only');
-    }
+    },
   };
 
   private _tapPreTasks: PreTask[] = [];
-  private _tapTests: TapTest[] = [];
-  private _tapTestsOnly: TapTest[] = [];
+  private _tapTests: TapTest<any>[] = [];
+  private _tapTestsOnly: TapTest<any>[] = [];
 
   /**
    * 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
    */
-  public async test(
+  public test(
     testDescription: string,
-    testFunction: ITestFunction,
+    testFunction: ITestFunction<T>,
     modeArg: 'normal' | 'only' | 'skip' = 'normal'
-  ) {
-    const localTest = new TapTest({
+  ): TapTest<T> {
+    const localTest = new TapTest<T>({
       description: testDescription,
       testFunction,
-      parallel: false
+      parallel: false,
     });
     if (modeArg === 'normal') {
       this._tapTests.push(localTest);
@@ -53,28 +52,21 @@ export class Tap {
     return localTest;
   }
 
-  public preTask (descriptionArg: string, functionArg: IPreTaskFunction) {
+  public preTask(descriptionArg: string, functionArg: IPreTaskFunction) {
     this._tapPreTasks.push(new PreTask(descriptionArg, functionArg));
   }
 
-  /**
-   * wraps function
-   */
-  public wrap(functionArg: ITapWrapFunction) {
-    return new 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
    */
-  public testParallel(testDescription: string, testFunction: ITestFunction) {
+  public testParallel(testDescription: string, testFunction: ITestFunction<T>) {
     this._tapTests.push(
       new TapTest({
         description: testDescription,
         testFunction,
-        parallel: true
+        parallel: true,
       })
     );
   }
@@ -85,7 +77,9 @@ export class Tap {
   public async start(optionsArg?: { throwOnError: boolean }) {
     // lets set the tapbundle promise
     const smartenvInstance = new plugins.smartenv.Smartenv();
-    smartenvInstance.isBrowser ? globalThis.tapbundleDeferred = plugins.smartpromise.defer() : null;
+    smartenvInstance.isBrowser
+      ? ((globalThis as any).tapbundleDeferred = plugins.smartpromise.defer())
+      : null;
 
     // lets continue with running the tests
     const promiseArray: Array<Promise<any>> = [];
@@ -142,14 +136,17 @@ export class Tap {
     }
 
     if (optionsArg && optionsArg.throwOnError && failReasons.length > 0) {
-      process.exit(1);
+      if (!smartenvInstance.isBrowser) process.exit(1);
+    }
+    if (smartenvInstance.isBrowser) {
+      (globalThis as any).tapbundleDeferred.resolve();
     }
   }
 
   /**
    * handle errors
    */
-  public threw(err) {
+  public threw(err: Error) {
     console.log(err);
   }
 }

ts/tapbundle.classes.taptest.ts

@@ -9,23 +9,25 @@ import { HrtMeasurement } from '@pushrocks/smarttime';
 // interfaces
 export type TTestStatus = 'success' | 'error' | 'pending' | 'errorAfterSuccess' | 'timeout';
 
-export type ITestFunction = (tapTools?: TapTools) => Promise<any>;
+export interface ITestFunction <T> { (tapTools?: TapTools): Promise<T> };
 
-export class TapTest {
+export class TapTest <T = unknown> {
   public description: string;
   public failureAllowed: boolean;
   public hrtMeasurement: HrtMeasurement;
   public parallel: boolean;
   public status: TTestStatus;
   public tapTools: TapTools;
-  public testFunction: ITestFunction;
+  public testFunction: ITestFunction<T>;
   public testKey: number; // the testKey the position in the test qeue. Set upon calling .run()
-  public testDeferred: Deferred<TapTest> = plugins.smartpromise.defer();
-  public testPromise: Promise<TapTest> = this.testDeferred.promise;
+  private testDeferred: Deferred<TapTest<T>> = plugins.smartpromise.defer();
+  public testPromise: Promise<TapTest<T>> = this.testDeferred.promise;
+  private testResultDeferred: Deferred<T> = plugins.smartpromise.defer();
+  public testResultPromise: Promise<T> = this.testResultDeferred.promise;
   /**
    * constructor
    */
-  constructor(optionsArg: { description: string; testFunction: ITestFunction; parallel: boolean }) {
+  constructor(optionsArg: { description: string; testFunction: ITestFunction<T>; parallel: boolean }) {
     this.description = optionsArg.description;
     this.hrtMeasurement = new HrtMeasurement();
     this.parallel = optionsArg.parallel;
@@ -42,8 +44,7 @@ export class TapTest {
     this.testKey = testKeyArg;
     const testNumber = testKeyArg + 1;
     try {
-      
-      await this.testFunction(this.tapTools);
+      const testReturnValue = await this.testFunction(this.tapTools);
       if (this.status === 'timeout') {
         throw new Error('Test succeeded, but timed out...');
       }
@@ -53,12 +54,14 @@ export class TapTest {
       );
       this.status = 'success';
       this.testDeferred.resolve(this);
-    } catch (err) {
+      this.testResultDeferred.resolve(testReturnValue);
+    } catch (err: any) {
       this.hrtMeasurement.stop();
       console.log(
         `not ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`
       );
       this.testDeferred.resolve(this);
+      this.testResultDeferred.resolve(err);
 
       // if the test has already succeeded before
       if (this.status === 'success') {

ts/tapbundle.classes.taptools.ts

@@ -11,7 +11,7 @@ export class TapTools {
    */
   private _tapTest: TapTest;
 
-  constructor(TapTestArg) {
+  constructor(TapTestArg: TapTest<any>) {
     this._tapTest = TapTestArg;
   }
 
@@ -25,11 +25,11 @@ export class TapTools {
   /**
    * async/await delay method
    */
-  public async delayFor(timeMilliArg) {
+  public async delayFor(timeMilliArg: number) {
     await plugins.smartdelay.delayFor(timeMilliArg);
   }
 
-  public async delayForRandom(timeMilliMinArg, timeMilliMaxArg) {
+  public async delayForRandom(timeMilliMinArg: number, timeMilliMaxArg: number) {
     await plugins.smartdelay.delayForRandom(timeMilliMinArg, timeMilliMaxArg);
   }
 
@@ -42,15 +42,11 @@ export class TapTools {
     }
   }
 
-  public async checkIterationLeak(iterationfuncArg: IPromiseFunc) {
-    console.log('iteration leakage checks disabled for now due to incompatibilities with node v12');
-  }
-
   public async returnError(throwingFuncArg: IPromiseFunc) {
     let funcErr: Error;
     try {
       await throwingFuncArg();
-    } catch (err) {
+    } catch (err: any) {
       funcErr = err;
     }
     return funcErr;

ts/tapbundle.classes.tapwrap.ts

@@ -1,25 +1,13 @@
 import * as plugins from './tapbundle.plugins';
 
-export interface ITapWrapFunction {
-  (): Promise<any>;
+export interface ITapWrapOptions {
+  before: () => Promise<any>;
+  after: () => {};
 }
 
 export class TapWrap {
-  wrapFunction: ITapWrapFunction;
-
-  /**
-   * the constructor
-   */
-  constructor(wrapFunctionArg: ITapWrapFunction) {
-    // nothing here
-    this.wrapFunction = wrapFunctionArg;
-  }
-
-  /**
-   * run the wrapFunction
-   */
-  async run() {
-    // TODO: make sure it makes sense what we do here.
-    await this.wrapFunction();
+  public options: ITapWrapOptions;
+  constructor(optionsArg: ITapWrapOptions) {
+    this.options = optionsArg;
   }
 }

ts/tapbundle.plugins.ts

@@ -1,11 +1,7 @@
 // pushrocks
 import * as smartdelay from '@pushrocks/smartdelay';
 import * as smartenv from '@pushrocks/smartenv';
+import * as smartexpect from '@pushrocks/smartexpect';
 import * as smartpromise from '@pushrocks/smartpromise';
 
-export { smartdelay, smartenv, smartpromise };
-
-// third party
-/* import * as leakage from 'leakage';
-
-export { leakage }; */
+export { smartdelay, smartenv, smartexpect, smartpromise };

ts/webhelpers.ts

@@ -0,0 +1,25 @@
+import * as plugins from './tapbundle.plugins';
+import type { fixture, html } from '@open-wc/testing-helpers';
+import { tap } from './tapbundle.classes.tap';
+
+class WebHelpers {
+  html: typeof html;
+  fixture: typeof fixture;
+
+  constructor() {
+    const smartenv = new plugins.smartenv.Smartenv();
+    if(smartenv.isBrowser) {
+      this.enable();
+    }
+  }
+
+  public enable() {
+    tap.preTask('enable webhelpers', async () => {
+      const webhelpers = await import('@open-wc/testing-helpers')
+      this.html = webhelpers.html;
+      this.fixture = webhelpers.fixture;
+    })
+  }
+}
+
+export const webhelpers = new WebHelpers();