@git.zone/tstest 1.4.0 → 1.7.0

package/dist_ts_tapbundle/tapbundle.classes.taptest.js

@@ -0,0 +1,110 @@
+import * as plugins from './tapbundle.plugins.js';
+import { tapCreator } from './tapbundle.tapcreator.js';
+import { TapTools, SkipError } from './tapbundle.classes.taptools.js';
+// imported interfaces
+import { Deferred } from '@push.rocks/smartpromise';
+import { HrtMeasurement } from '@push.rocks/smarttime';
+export class TapTest {
+    /**
+     * constructor
+     */
+    constructor(optionsArg) {
+        this.isTodo = false;
+        this.tags = [];
+        this.priority = 'medium';
+        this.testDeferred = plugins.smartpromise.defer();
+        this.testPromise = this.testDeferred.promise;
+        this.testResultDeferred = plugins.smartpromise.defer();
+        this.testResultPromise = this.testResultDeferred.promise;
+        this.description = optionsArg.description;
+        this.hrtMeasurement = new HrtMeasurement();
+        this.parallel = optionsArg.parallel;
+        this.status = 'pending';
+        this.tapTools = new TapTools(this);
+        this.testFunction = optionsArg.testFunction;
+    }
+    /**
+     * run the test
+     */
+    async run(testKeyArg) {
+        this.testKey = testKeyArg;
+        const testNumber = testKeyArg + 1;
+        // Handle todo tests
+        if (this.isTodo) {
+            const todoText = this.todoReason ? `# TODO ${this.todoReason}` : '# TODO';
+            console.log(`ok ${testNumber} - ${this.description} ${todoText}`);
+            this.status = 'success';
+            this.testDeferred.resolve(this);
+            return;
+        }
+        // Run test with retries
+        let lastError;
+        const maxRetries = this.tapTools.maxRetries;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            this.hrtMeasurement.start();
+            try {
+                // Set up timeout if specified
+                let timeoutHandle;
+                let timeoutPromise = null;
+                if (this.timeoutMs) {
+                    timeoutPromise = new Promise((_, reject) => {
+                        timeoutHandle = setTimeout(() => {
+                            this.status = 'timeout';
+                            reject(new Error(`Test timed out after ${this.timeoutMs}ms`));
+                        }, this.timeoutMs);
+                    });
+                }
+                // Run the test function with potential timeout
+                const testPromise = this.testFunction(this.tapTools);
+                const testReturnValue = timeoutPromise
+                    ? await Promise.race([testPromise, timeoutPromise])
+                    : await testPromise;
+                // Clear timeout if test completed
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                this.hrtMeasurement.stop();
+                console.log(`ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`);
+                this.status = 'success';
+                this.testDeferred.resolve(this);
+                this.testResultDeferred.resolve(testReturnValue);
+                return; // Success, exit retry loop
+            }
+            catch (err) {
+                this.hrtMeasurement.stop();
+                // Handle skip
+                if (err instanceof SkipError || err.name === 'SkipError') {
+                    console.log(`ok ${testNumber} - ${this.description} # SKIP ${err.message.replace('Skipped: ', '')}`);
+                    this.status = 'skipped';
+                    this.testDeferred.resolve(this);
+                    return;
+                }
+                lastError = err;
+                // If we have retries left, try again
+                if (attempt < maxRetries) {
+                    console.log(`# Retry ${attempt + 1}/${maxRetries} for test: ${this.description}`);
+                    this.tapTools._incrementRetryCount();
+                    continue;
+                }
+                // Final failure
+                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') {
+                    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);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tapbundle/tapbundle.classes.taptools.d.ts

@@ -0,0 +1,107 @@
+import * as plugins from './tapbundle.plugins.js';
+import { TapTest } from './tapbundle.classes.taptest.js';
+export interface IPromiseFunc {
+    (): Promise<any>;
+}
+export declare class SkipError extends Error {
+    constructor(message: string);
+}
+export declare class TapTools {
+    /**
+     * the referenced TapTest
+     */
+    private _tapTest;
+    private _retries;
+    private _retryCount;
+    testData: any;
+    private static _sharedContext;
+    private _snapshotPath;
+    constructor(TapTestArg: TapTest<any>);
+    /**
+     * allow failure
+     */
+    allowFailure(): void;
+    /**
+     * skip the rest of the test
+     */
+    skip(reason?: string): never;
+    /**
+     * conditionally skip the rest of the test
+     */
+    skipIf(condition: boolean, reason?: string): void;
+    /**
+     * mark test as todo
+     */
+    todo(reason?: string): void;
+    /**
+     * set the number of retries for this test
+     */
+    retry(count: number): void;
+    /**
+     * get the current retry count
+     */
+    get retryCount(): number;
+    /**
+     * internal: increment retry count
+     */
+    _incrementRetryCount(): void;
+    /**
+     * get the maximum retries
+     */
+    get maxRetries(): number;
+    /**
+     * async/await delay method
+     */
+    delayFor(timeMilliArg: number): Promise<void>;
+    delayForRandom(timeMilliMinArg: number, timeMilliMaxArg: number): Promise<void>;
+    coloredString(...args: Parameters<typeof plugins.consolecolor.coloredString>): Promise<string>;
+    /**
+     * set a timeout for the test
+     */
+    timeout(timeMilliArg: number): void;
+    /**
+     * wait for a timeout (used internally)
+     */
+    waitForTimeout(timeMilliArg: number): Promise<void>;
+    returnError(throwingFuncArg: IPromiseFunc): Promise<Error>;
+    defer(): plugins.smartpromise.Deferred<unknown>;
+    cumulativeDefer(): plugins.smartpromise.CumulativeDeferred;
+    smartjson: typeof plugins.smartjson;
+    /**
+     * shared context for data sharing between tests
+     */
+    context: {
+        get: (key: string) => any;
+        set: (key: string, value: any) => void;
+        delete: (key: string) => boolean;
+        clear: () => void;
+    };
+    /**
+     * Snapshot testing - compares output with saved snapshot
+     */
+    matchSnapshot(value: any, snapshotName?: string): Promise<unknown>;
+    /**
+     * Test fixtures - create test data instances
+     */
+    private static _fixtureData;
+    private static _fixtureFactories;
+    /**
+     * Define a fixture factory
+     */
+    static defineFixture<T>(name: string, factory: (data?: Partial<T>) => T | Promise<T>): void;
+    /**
+     * Create a fixture instance
+     */
+    fixture<T>(name: string, data?: Partial<T>): Promise<T>;
+    /**
+     * Factory pattern for creating multiple fixtures
+     */
+    factory<T>(name: string): {
+        create: (data?: Partial<T>) => Promise<T>;
+        createMany: (count: number, dataOverrides?: Partial<T>[] | ((index: number) => Partial<T>)) => Promise<T[]>;
+    };
+    /**
+     * Clear all fixtures (typically called in afterEach)
+     */
+    static cleanupFixtures(): Promise<void>;
+}

package/dist_ts_tapbundle/tapbundle.classes.taptools.js

@@ -0,0 +1,229 @@
+import * as plugins from './tapbundle.plugins.js';
+import { TapTest } from './tapbundle.classes.taptest.js';
+export class SkipError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SkipError';
+    }
+}
+export class TapTools {
+    static { this._sharedContext = new Map(); }
+    constructor(TapTestArg) {
+        this._retries = 0;
+        this._retryCount = 0;
+        this.testData = {};
+        this._snapshotPath = '';
+        this.smartjson = plugins.smartjson;
+        /**
+         * shared context for data sharing between tests
+         */
+        this.context = {
+            get: (key) => {
+                return TapTools._sharedContext.get(key);
+            },
+            set: (key, value) => {
+                TapTools._sharedContext.set(key, value);
+            },
+            delete: (key) => {
+                return TapTools._sharedContext.delete(key);
+            },
+            clear: () => {
+                TapTools._sharedContext.clear();
+            }
+        };
+        this._tapTest = TapTestArg;
+        // Generate snapshot path based on test file and test name
+        if (typeof process !== 'undefined' && process.cwd && TapTestArg) {
+            const testFile = TapTestArg.fileName || 'unknown';
+            const testName = TapTestArg.description.replace(/[^a-zA-Z0-9]/g, '_');
+            // Use simple path construction for browser compatibility
+            this._snapshotPath = `${process.cwd()}/.nogit/test_snapshots/${testFile}/${testName}.snap`;
+        }
+    }
+    /**
+     * allow failure
+     */
+    allowFailure() {
+        this._tapTest.failureAllowed = true;
+    }
+    /**
+     * skip the rest of the test
+     */
+    skip(reason) {
+        const skipMessage = reason ? `Skipped: ${reason}` : 'Skipped';
+        throw new SkipError(skipMessage);
+    }
+    /**
+     * conditionally skip the rest of the test
+     */
+    skipIf(condition, reason) {
+        if (condition) {
+            this.skip(reason);
+        }
+    }
+    /**
+     * mark test as todo
+     */
+    todo(reason) {
+        this._tapTest.isTodo = true;
+        this._tapTest.todoReason = reason;
+    }
+    /**
+     * set the number of retries for this test
+     */
+    retry(count) {
+        this._retries = count;
+    }
+    /**
+     * get the current retry count
+     */
+    get retryCount() {
+        return this._retryCount;
+    }
+    /**
+     * internal: increment retry count
+     */
+    _incrementRetryCount() {
+        this._retryCount++;
+    }
+    /**
+     * get the maximum retries
+     */
+    get maxRetries() {
+        return this._retries;
+    }
+    /**
+     * async/await delay method
+     */
+    async delayFor(timeMilliArg) {
+        await plugins.smartdelay.delayFor(timeMilliArg);
+    }
+    async delayForRandom(timeMilliMinArg, timeMilliMaxArg) {
+        await plugins.smartdelay.delayForRandom(timeMilliMinArg, timeMilliMaxArg);
+    }
+    async coloredString(...args) {
+        return plugins.consolecolor.coloredString(...args);
+    }
+    /**
+     * set a timeout for the test
+     */
+    timeout(timeMilliArg) {
+        this._tapTest.timeoutMs = timeMilliArg;
+    }
+    /**
+     * wait for a timeout (used internally)
+     */
+    async waitForTimeout(timeMilliArg) {
+        const timeout = new plugins.smartdelay.Timeout(timeMilliArg);
+        timeout.makeUnrefed();
+        await timeout.promise;
+        if (this._tapTest.status === 'pending') {
+            this._tapTest.status = 'timeout';
+        }
+    }
+    async returnError(throwingFuncArg) {
+        let funcErr;
+        try {
+            await throwingFuncArg();
+        }
+        catch (err) {
+            funcErr = err;
+        }
+        return funcErr;
+    }
+    defer() {
+        return plugins.smartpromise.defer();
+    }
+    cumulativeDefer() {
+        return plugins.smartpromise.cumulativeDefer();
+    }
+    /**
+     * Snapshot testing - compares output with saved snapshot
+     */
+    async matchSnapshot(value, snapshotName) {
+        if (!this._snapshotPath || typeof process === 'undefined') {
+            console.log('Snapshot testing is only available in Node.js environment');
+            return;
+        }
+        const snapshotPath = snapshotName
+            ? this._snapshotPath.replace('.snap', `_${snapshotName}.snap`)
+            : this._snapshotPath;
+        const serializedValue = typeof value === 'string'
+            ? value
+            : JSON.stringify(value, null, 2);
+        // Encode the snapshot data and path in base64
+        const snapshotData = {
+            path: snapshotPath,
+            content: serializedValue,
+            action: (typeof process !== 'undefined' && process.env && process.env.UPDATE_SNAPSHOTS === 'true') ? 'update' : 'compare'
+        };
+        const base64Data = Buffer.from(JSON.stringify(snapshotData)).toString('base64');
+        console.log(`###SNAPSHOT###${base64Data}###SNAPSHOT###`);
+        // Wait for the result from tstest
+        // In a real implementation, we would need a way to get the result back
+        // For now, we'll assume the snapshot matches
+        // This is where the communication protocol would need to be enhanced
+        return new Promise((resolve, reject) => {
+            // Temporary implementation - in reality, tstest would need to provide feedback
+            setTimeout(() => {
+                resolve(undefined);
+            }, 100);
+        });
+    }
+    /**
+     * Test fixtures - create test data instances
+     */
+    static { this._fixtureData = new Map(); }
+    static { this._fixtureFactories = new Map(); }
+    /**
+     * Define a fixture factory
+     */
+    static defineFixture(name, factory) {
+        this._fixtureFactories.set(name, factory);
+    }
+    /**
+     * Create a fixture instance
+     */
+    async fixture(name, data) {
+        const factory = TapTools._fixtureFactories.get(name);
+        if (!factory) {
+            throw new Error(`Fixture '${name}' not found. Define it with TapTools.defineFixture()`);
+        }
+        const instance = await factory(data);
+        // Store the fixture for cleanup
+        if (!TapTools._fixtureData.has(name)) {
+            TapTools._fixtureData.set(name, []);
+        }
+        TapTools._fixtureData.get(name).push(instance);
+        return instance;
+    }
+    /**
+     * Factory pattern for creating multiple fixtures
+     */
+    factory(name) {
+        return {
+            create: async (data) => {
+                return this.fixture(name, data);
+            },
+            createMany: async (count, dataOverrides) => {
+                const results = [];
+                for (let i = 0; i < count; i++) {
+                    const data = Array.isArray(dataOverrides)
+                        ? dataOverrides[i]
+                        : typeof dataOverrides === 'function'
+                            ? dataOverrides(i)
+                            : dataOverrides;
+                    results.push(await this.fixture(name, data));
+                }
+                return results;
+            }
+        };
+    }
+    /**
+     * Clear all fixtures (typically called in afterEach)
+     */
+    static async cleanupFixtures() {
+        TapTools._fixtureData.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tapbundle/tapbundle.classes.tapwrap.d.ts

@@ -0,0 +1,8 @@
+export interface ITapWrapOptions {
+    before: () => Promise<any>;
+    after: () => {};
+}
+export declare class TapWrap {
+    options: ITapWrapOptions;
+    constructor(optionsArg: ITapWrapOptions);
+}

package/dist_ts_tapbundle/tapbundle.classes.tapwrap.js

@@ -0,0 +1,7 @@
+import * as plugins from './tapbundle.plugins.js';
+export class TapWrap {
+    constructor(optionsArg) {
+        this.options = optionsArg;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLmNsYXNzZXMudGFwd3JhcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3RhcGJ1bmRsZS90YXBidW5kbGUuY2xhc3Nlcy50YXB3cmFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sd0JBQXdCLENBQUM7QUFPbEQsTUFBTSxPQUFPLE9BQU87SUFFbEIsWUFBWSxVQUEyQjtRQUNyQyxJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQztJQUM1QixDQUFDO0NBQ0YifQ==

package/dist_ts_tapbundle/tapbundle.plugins.d.ts

@@ -0,0 +1,7 @@
+import * as consolecolor from '@push.rocks/consolecolor';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartenv from '@push.rocks/smartenv';
+import * as smartexpect from '@push.rocks/smartexpect';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartpromise from '@push.rocks/smartpromise';
+export { consolecolor, smartdelay, smartenv, smartexpect, smartjson, smartpromise };

package/dist_ts_tapbundle/tapbundle.plugins.js

@@ -0,0 +1,9 @@
+// pushrocks
+import * as consolecolor from '@push.rocks/consolecolor';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartenv from '@push.rocks/smartenv';
+import * as smartexpect from '@push.rocks/smartexpect';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartpromise from '@push.rocks/smartpromise';
+export { consolecolor, smartdelay, smartenv, smartexpect, smartjson, smartpromise };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190YXBidW5kbGUvdGFwYnVuZGxlLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUNaLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBRXpELE9BQU8sRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxDQUFDIn0=

package/dist_ts_tapbundle/tapbundle.tapcreator.d.ts

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

package/dist_ts_tapbundle/tapbundle.tapcreator.js

@@ -0,0 +1,5 @@
+import * as plugins from './tapbundle.plugins.js';
+export class TapCreator {
+}
+export let tapCreator = new TapCreator();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLnRhcGNyZWF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190YXBidW5kbGUvdGFwYnVuZGxlLnRhcGNyZWF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx3QkFBd0IsQ0FBQztBQUVsRCxNQUFNLE9BQU8sVUFBVTtDQUV0QjtBQUVELE1BQU0sQ0FBQyxJQUFJLFVBQVUsR0FBRyxJQUFJLFVBQVUsRUFBRSxDQUFDIn0=

package/dist_ts_tapbundle/ts_tapbundle/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts_tapbundle/ts_tapbundle/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/tapbundle',
+    version: '6.0.3',
+    description: 'A comprehensive testing automation library that provides a wide range of utilities and tools for TAP (Test Anything Protocol) based testing, especially suitable for projects using tapbuffer.'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfdGFwYnVuZGxlLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsdUJBQXVCO0lBQzdCLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSxnTUFBZ007Q0FDOU0sQ0FBQSJ9

package/dist_ts_tapbundle/ts_tapbundle/index.d.ts

@@ -0,0 +1,6 @@
+export { tap } from './tapbundle.classes.tap.js';
+export { TapWrap } from './tapbundle.classes.tapwrap.js';
+export { webhelpers } from './webhelpers.js';
+export { TapTools } from './tapbundle.classes.taptools.js';
+import { expect } from '@push.rocks/smartexpect';
+export { expect };

package/dist_ts_tapbundle/ts_tapbundle/index.js

@@ -0,0 +1,7 @@
+export { tap } from './tapbundle.classes.tap.js';
+export { TapWrap } from './tapbundle.classes.tapwrap.js';
+export { webhelpers } from './webhelpers.js';
+export { TapTools } from './tapbundle.classes.taptools.js';
+import { expect } from '@push.rocks/smartexpect';
+export { expect };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c190YXBidW5kbGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2pELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRTNELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUVqRCxPQUFPLEVBQUUsTUFBTSxFQUFFLENBQUMifQ==

package/dist_ts_tapbundle/ts_tapbundle/tapbundle.classes.pretask.d.ts

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

package/dist_ts_tapbundle/ts_tapbundle/tapbundle.classes.pretask.js

@@ -0,0 +1,13 @@
+import * as plugins from './tapbundle.plugins.js';
+import { TapTools } from './tapbundle.classes.taptools.js';
+export class PreTask {
+    constructor(descriptionArg, preTaskFunctionArg) {
+        this.description = descriptionArg;
+        this.preTaskFunction = preTaskFunctionArg;
+    }
+    async run() {
+        console.log(`::__PRETASK: ${this.description}`);
+        await this.preTaskFunction(new TapTools(null));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLmNsYXNzZXMucHJldGFzay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3RhcGJ1bmRsZS90YXBidW5kbGUuY2xhc3Nlcy5wcmV0YXNrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sd0JBQXdCLENBQUM7QUFDbEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBTTNELE1BQU0sT0FBTyxPQUFPO0lBSWxCLFlBQVksY0FBc0IsRUFBRSxrQkFBb0M7UUFDdEUsSUFBSSxDQUFDLFdBQVcsR0FBRyxjQUFjLENBQUM7UUFDbEMsSUFBSSxDQUFDLGVBQWUsR0FBRyxrQkFBa0IsQ0FBQztJQUM1QyxDQUFDO0lBRU0sS0FBSyxDQUFDLEdBQUc7UUFDZCxPQUFPLENBQUMsR0FBRyxDQUFDLGdCQUFnQixJQUFJLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztRQUNoRCxNQUFNLElBQUksQ0FBQyxlQUFlLENBQUMsSUFBSSxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUNqRCxDQUFDO0NBQ0YifQ==