@git.zone/tstest 1.4.0 → 1.7.0

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.classes.taptools.js

@@ -0,0 +1,241 @@
+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(); }
+    static { this._pathHelpers = null; }
+    static setPathHelpers(helpers) {
+        TapTools._pathHelpers = helpers;
+    }
+    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
+        // Snapshot path will be set by Node.js environment if available
+        if (TapTools._pathHelpers && typeof process !== 'undefined' && process.cwd) {
+            const testFile = TapTestArg.fileName || 'unknown';
+            const testName = TapTestArg.description.replace(/[^a-zA-Z0-9]/g, '_');
+            this._snapshotPath = TapTools._pathHelpers.join(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 || !TapTools._pathHelpers) {
+            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);
+        try {
+            // Try to read existing snapshot
+            const existingSnapshot = await plugins.smartfile.fs.toStringSync(snapshotPath);
+            if (existingSnapshot !== serializedValue) {
+                // Check if we should update snapshots
+                if (process.env.UPDATE_SNAPSHOTS === 'true') {
+                    await plugins.smartfile.fs.ensureDir(TapTools._pathHelpers.dirname(snapshotPath));
+                    await plugins.smartfile.memory.toFs(serializedValue, snapshotPath);
+                    console.log(`Snapshot updated: ${snapshotPath}`);
+                }
+                else {
+                    throw new Error(`Snapshot mismatch for ${snapshotPath}\n\nExpected:\n${existingSnapshot}\n\nReceived:\n${serializedValue}`);
+                }
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Snapshot doesn't exist yet, create it
+                await plugins.smartfile.fs.ensureDir(TapTools._pathHelpers.dirname(snapshotPath));
+                await plugins.smartfile.memory.toFs(serializedValue, snapshotPath);
+                console.log(`Snapshot created: ${snapshotPath}`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    /**
+     * 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,{"version":3,"file":"tapbundle.classes.taptools.js","sourceRoot":"","sources":["../../ts_tapbundle/tapbundle.classes.taptools.ts"],"names":[],"mappings":"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"}

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.plugins.d.ts

@@ -0,0 +1,8 @@
+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 smartfile from '@push.rocks/smartfile';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartpromise from '@push.rocks/smartpromise';
+export { consolecolor, smartdelay, smartenv, smartexpect, smartfile, smartjson, smartpromise };

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.plugins.js

@@ -0,0 +1,10 @@
+// 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 smartfile from '@push.rocks/smartfile';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartpromise from '@push.rocks/smartpromise';
+export { consolecolor, smartdelay, smartenv, smartexpect, smartfile, smartjson, smartpromise };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c190YXBidW5kbGUvdGFwYnVuZGxlLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUNaLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFFekQsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLFdBQVcsRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxDQUFDIn0=

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.tapcreator.d.ts

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

package/dist_ts_tapbundle_node/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLnRhcGNyZWF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c190YXBidW5kbGUvdGFwYnVuZGxlLnRhcGNyZWF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx3QkFBd0IsQ0FBQztBQUVsRCxNQUFNLE9BQU8sVUFBVTtDQUV0QjtBQUVELE1BQU0sQ0FBQyxJQUFJLFVBQVUsR0FBRyxJQUFJLFVBQVUsRUFBRSxDQUFDIn0=

package/dist_ts_tapbundle_node/ts_tapbundle_node/classes.pathinject.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Initialize path helpers for the TapTools class
+ * This provides Node.js-specific path operations to the browser-compatible tapbundle
+ */
+export declare const initializePathHelpers: () => void;

package/dist_ts_tapbundle_node/ts_tapbundle_node/classes.pathinject.js

@@ -0,0 +1,13 @@
+import * as plugins from './plugins.js';
+import { TapTools } from '../ts_tapbundle/tapbundle.classes.taptools.js';
+/**
+ * Initialize path helpers for the TapTools class
+ * This provides Node.js-specific path operations to the browser-compatible tapbundle
+ */
+export const initializePathHelpers = () => {
+    TapTools.setPathHelpers({
+        join: (...args) => plugins.path.join(...args),
+        dirname: (path) => plugins.path.dirname(path)
+    });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5wYXRoaW5qZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfdGFwYnVuZGxlX25vZGUvY2xhc3Nlcy5wYXRoaW5qZWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSwrQ0FBK0MsQ0FBQztBQUV6RTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxHQUFHLEVBQUU7SUFDeEMsUUFBUSxDQUFDLGNBQWMsQ0FBQztRQUN0QixJQUFJLEVBQUUsQ0FBQyxHQUFHLElBQWMsRUFBRSxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUM7UUFDdkQsT0FBTyxFQUFFLENBQUMsSUFBWSxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUM7S0FDdEQsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDIn0=

package/dist_ts_tapbundle_node/ts_tapbundle_node/classes.tapnodetools.d.ts

@@ -0,0 +1,25 @@
+import { TestFileProvider } from './classes.testfileprovider.js';
+import * as plugins from './plugins.js';
+declare class TapNodeTools {
+    private smartshellInstance;
+    testFileProvider: TestFileProvider;
+    constructor();
+    private qenv;
+    getQenv(): Promise<plugins.qenv.Qenv>;
+    getEnvVarOnDemand(envVarNameArg: string): Promise<string>;
+    runCommand(commandArg: string): Promise<any>;
+    createHttpsCert(commonName?: string, allowSelfSigned?: boolean): Promise<{
+        key: string;
+        cert: string;
+    }>;
+    /**
+     * create and return a smartmongo instance
+     */
+    createSmartmongo(): Promise<import("@push.rocks/smartmongo").SmartMongo>;
+    /**
+     * create and return a smarts3 instance
+     */
+    createSmarts3(): Promise<import("@push.rocks/smarts3").Smarts3>;
+}
+export declare const tapNodeTools: TapNodeTools;
+export {};

package/dist_ts_tapbundle_node/ts_tapbundle_node/classes.tapnodetools.js

@@ -0,0 +1,81 @@
+import { TestFileProvider } from './classes.testfileprovider.js';
+import * as plugins from './plugins.js';
+class TapNodeTools {
+    constructor() {
+        this.testFileProvider = new TestFileProvider();
+    }
+    async getQenv() {
+        this.qenv = this.qenv || new plugins.qenv.Qenv('./', '.nogit/');
+        return this.qenv;
+    }
+    async getEnvVarOnDemand(envVarNameArg) {
+        const qenv = await this.getQenv();
+        return qenv.getEnvVarOnDemand(envVarNameArg);
+    }
+    async runCommand(commandArg) {
+        if (!this.smartshellInstance) {
+            this.smartshellInstance = new plugins.smartshell.Smartshell({
+                executor: 'bash',
+            });
+        }
+        const result = await this.smartshellInstance.exec(commandArg);
+        return result;
+    }
+    async createHttpsCert(commonName = 'localhost', allowSelfSigned = true) {
+        if (allowSelfSigned) {
+            // set node to allow self-signed certificates
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+        }
+        // Generate a key pair
+        const keys = plugins.smartcrypto.nodeForge.pki.rsa.generateKeyPair(2048);
+        // Create a self-signed certificate
+        const cert = plugins.smartcrypto.nodeForge.pki.createCertificate();
+        cert.publicKey = keys.publicKey;
+        cert.serialNumber = '01';
+        cert.validity.notBefore = new Date();
+        cert.validity.notAfter = new Date();
+        cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
+        const attrs = [
+            { name: 'commonName', value: commonName },
+            { name: 'countryName', value: 'US' },
+            { shortName: 'ST', value: 'California' },
+            { name: 'localityName', value: 'San Francisco' },
+            { name: 'organizationName', value: 'My Company' },
+            { shortName: 'OU', value: 'Dev' },
+        ];
+        cert.setSubject(attrs);
+        cert.setIssuer(attrs);
+        // Sign the certificate with its own private key (self-signed)
+        cert.sign(keys.privateKey, plugins.smartcrypto.nodeForge.md.sha256.create());
+        // PEM encode the private key and certificate
+        const pemKey = plugins.smartcrypto.nodeForge.pki.privateKeyToPem(keys.privateKey);
+        const pemCert = plugins.smartcrypto.nodeForge.pki.certificateToPem(cert);
+        return {
+            key: pemKey,
+            cert: pemCert,
+        };
+    }
+    /**
+     * create and return a smartmongo instance
+     */
+    async createSmartmongo() {
+        const smartmongoMod = await import('@push.rocks/smartmongo');
+        const smartmongoInstance = new smartmongoMod.SmartMongo();
+        await smartmongoInstance.start();
+        return smartmongoInstance;
+    }
+    /**
+     * create and return a smarts3 instance
+     */
+    async createSmarts3() {
+        const smarts3Mod = await import('@push.rocks/smarts3');
+        const smarts3Instance = new smarts3Mod.Smarts3({
+            port: 3003,
+            cleanSlate: true,
+        });
+        await smarts3Instance.start();
+        return smarts3Instance;
+    }
+}
+export const tapNodeTools = new TapNodeTools();
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tapbundle_node/ts_tapbundle_node/classes.testfileprovider.d.ts

@@ -0,0 +1,6 @@
+export declare const fileUrls: {
+    dockerAlpineImage: string;
+};
+export declare class TestFileProvider {
+    getDockerAlpineImageAsLocalTarball(): Promise<string>;
+}

package/dist_ts_tapbundle_node/ts_tapbundle_node/classes.testfileprovider.js

@@ -0,0 +1,16 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+export const fileUrls = {
+    dockerAlpineImage: 'https://code.foss.global/testassets/docker/raw/branch/main/alpine.tar',
+};
+export class TestFileProvider {
+    async getDockerAlpineImageAsLocalTarball() {
+        const filePath = plugins.path.join(paths.testFilesDir, 'alpine.tar');
+        // fetch the docker alpine image
+        const response = await plugins.smartrequest.getBinary(fileUrls.dockerAlpineImage);
+        await plugins.smartfile.fs.ensureDir(paths.testFilesDir);
+        await plugins.smartfile.memory.toFs(response.body, filePath);
+        return filePath;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy50ZXN0ZmlsZXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfdGFwYnVuZGxlX25vZGUvY2xhc3Nlcy50ZXN0ZmlsZXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxLQUFLLE1BQU0sWUFBWSxDQUFDO0FBRXBDLE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRztJQUN0QixpQkFBaUIsRUFBRSx1RUFBdUU7Q0FDM0YsQ0FBQTtBQUVELE1BQU0sT0FBTyxnQkFBZ0I7SUFDcEIsS0FBSyxDQUFDLGtDQUFrQztRQUM3QyxNQUFNLFFBQVEsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsWUFBWSxFQUFFLFlBQVksQ0FBQyxDQUFBO1FBQ3BFLGdDQUFnQztRQUNoQyxNQUFNLFFBQVEsR0FBRyxNQUFNLE9BQU8sQ0FBQyxZQUFZLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO1FBQ2xGLE1BQU0sT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUN6RCxNQUFNLE9BQU8sQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQzdELE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7Q0FDRiJ9

package/dist_ts_tapbundle_node/ts_tapbundle_node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './classes.tapnodetools.js';
+export * from './classes.pathinject.js';

package/dist_ts_tapbundle_node/ts_tapbundle_node/index.js

@@ -0,0 +1,3 @@
+export * from './classes.tapnodetools.js';
+export * from './classes.pathinject.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c190YXBidW5kbGVfbm9kZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMseUJBQXlCLENBQUMifQ==

package/dist_ts_tapbundle_node/ts_tapbundle_node/paths.d.ts

@@ -0,0 +1,2 @@
+export declare const cwd: string;
+export declare const testFilesDir: string;

package/dist_ts_tapbundle_node/ts_tapbundle_node/paths.js

@@ -0,0 +1,4 @@
+import * as plugins from './plugins.js';
+export const cwd = process.cwd();
+export const testFilesDir = plugins.path.join(cwd, './.nogit/testfiles/');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c190YXBidW5kbGVfbm9kZS9wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4QyxNQUFNLENBQUMsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO0FBQ2pDLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUscUJBQXFCLENBQUMsQ0FBQyJ9

package/dist_ts_tapbundle_node/ts_tapbundle_node/plugins.d.ts

@@ -0,0 +1,11 @@
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+export { crypto, fs, path, };
+import * as qenv from '@push.rocks/qenv';
+import * as smartcrypto from '@push.rocks/smartcrypto';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartshell from '@push.rocks/smartshell';
+export { qenv, smartcrypto, smartfile, smartpath, smartrequest, smartshell, };

package/dist_ts_tapbundle_node/ts_tapbundle_node/plugins.js

@@ -0,0 +1,14 @@
+// node native
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+export { crypto, fs, path, };
+// @push.rocks scope
+import * as qenv from '@push.rocks/qenv';
+import * as smartcrypto from '@push.rocks/smartcrypto';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartshell from '@push.rocks/smartshell';
+export { qenv, smartcrypto, smartfile, smartpath, smartrequest, smartshell, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3RhcGJ1bmRsZV9ub2RlL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFBRSxNQUFNLEVBQUMsRUFBRSxFQUFFLElBQUksR0FBRyxDQUFDO0FBRTVCLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssSUFBSSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pDLE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUVyRCxPQUFPLEVBQUUsSUFBSSxFQUFFLFdBQVcsRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxVQUFVLEdBQUcsQ0FBQyJ9

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@git.zone/tstest",
-  "version": "1.4.0",
+  "version": "1.7.0",
   "private": false,
   "description": "a test utility to run tests that match test/**/*.ts",
-  "main": "dist_ts/index.js",
-  "typings": "dist_ts/index.d.ts",
+  "exports": {
+    ".": "./dist_ts/index.js",
+    "./tapbundle": "./dist_ts_tapbundle/index.js",
+    "./tapbundle_node": "./dist_ts_tapbundle_node/index.js"
+  },
   "type": "module",
   "author": "Lossless GmbH",
   "license": "MIT",
@@ -20,13 +23,22 @@
     "@git.zone/tsbundle": "^2.2.5",
     "@git.zone/tsrun": "^1.3.3",
     "@push.rocks/consolecolor": "^2.0.2",
+    "@push.rocks/qenv": "^6.1.0",
     "@push.rocks/smartbrowser": "^2.0.8",
+    "@push.rocks/smartcrypto": "^2.0.4",
     "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartenv": "^5.0.12",
+    "@push.rocks/smartexpect": "^2.4.2",
     "@push.rocks/smartfile": "^11.2.0",
-    "@push.rocks/smartlog": "^3.0.9",
+    "@push.rocks/smartjson": "^5.0.20",
+    "@push.rocks/smartlog": "^3.1.1",
+    "@push.rocks/smartmongo": "^2.0.12",
+    "@push.rocks/smartpath": "^5.0.18",
     "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smartrequest": "^2.1.0",
+    "@push.rocks/smarts3": "^2.2.5",
     "@push.rocks/smartshell": "^3.2.3",
-    "@push.rocks/tapbundle": "^6.0.3",
+    "@push.rocks/smarttime": "^4.1.1",
     "@types/ws": "^8.18.1",
     "figures": "^6.1.0",
     "ws": "^8.18.2"
@@ -47,11 +59,12 @@
     "last 1 chrome versions"
   ],
   "scripts": {
-    "test": "(npm run cleanUp && npm run prepareTest && npm run tstest)",
-    "prepareTest": "git clone https://gitlab.com/sandboxzone/sandbox-npmts.git .nogit/sandbox-npmts && cd .nogit/sandbox-npmts && npm install",
-    "tstest": "cd .nogit/sandbox-npmts && node ../../cli.ts.js test/ --web",
-    "cleanUp": "rm -rf .nogit/sandbox-npmts",
-    "build": "(tsbuild --web --allowimplicitany  --skiplibcheck)",
+    "test": "pnpm run build && pnpm run test:tapbundle:verbose && pnpm run test:tstest:verbose",
+    "test:tapbundle": "tsx ./cli.child.ts \"test/tapbundle/**/*.ts\"",
+    "test:tapbundle:verbose": "tsx ./cli.child.ts \"test/tapbundle/**/*.ts\" --verbose",
+    "test:tstest": "tsx ./cli.child.ts \"test/tstest/**/*.ts\"",
+    "test:tstest:verbose": "tsx ./cli.child.ts \"test/tstest/**/*.ts\" --verbose",
+    "build": "(tsbuild tsfolders)",
     "buildDocs": "tsdoc"
   }
 }

package/readme.hints.md

@@ -0,0 +1,62 @@
+# Architecture Overview
+
+## Project Structure
+
+This project integrates tstest with tapbundle through a modular architecture:
+
+1. **tstest** (`/ts/`) - The test runner that discovers and executes test files
+2. **tapbundle** (`/ts_tapbundle/`) - The TAP testing framework for writing tests
+3. **tapbundle_node** (`/ts_tapbundle_node/`) - Node.js-specific testing utilities
+
+## How Components Work Together
+
+### Test Execution Flow
+
+1. **CLI Entry Point** (`cli.js` � `cli.ts.js` � `cli.child.ts`)
+   - The CLI uses tsx to run TypeScript files directly
+   - Accepts glob patterns to find test files
+   - Supports options like `--verbose`, `--quiet`, `--web`
+
+2. **Test Discovery**
+   - tstest scans for test files matching the provided pattern
+   - Defaults to `test/**/*.ts` when no pattern is specified
+   - Supports both file and directory modes
+
+3. **Test Runner**
+   - Each test file imports `tap` and `expect` from tapbundle
+   - Tests are written using `tap.test()` with async functions
+   - Browser tests are compiled with esbuild and run in Chromium via Puppeteer
+
+### Key Integration Points
+
+1. **Import Structure**
+   - Test files import from local tapbundle: `import { tap, expect } from '../../ts_tapbundle/index.js'`
+   - Node-specific tests also import from tapbundle_node: `import { tapNodeTools } from '../../ts_tapbundle_node/index.js'`
+
+2. **WebHelpers**
+   - Browser tests can use webhelpers for DOM manipulation
+   - `webhelpers.html` - Template literal for creating HTML strings
+   - `webhelpers.fixture` - Creates DOM elements from HTML strings
+   - Automatically detects browser environment and only enables in browser context
+
+3. **Build System**
+   - Uses `tsbuild tsfolders` to compile TypeScript
+   - Maintains separate output directories: `/dist_ts/`, `/dist_ts_tapbundle/`, `/dist_ts_tapbundle_node/`
+   - Compilation order is resolved automatically based on dependencies
+
+### Test Scripts
+
+The package.json defines several test scripts:
+- `test` - Builds and runs all tests (tapbundle and tstest)
+- `test:tapbundle` - Runs tapbundle framework tests
+- `test:tstest` - Runs tstest's own tests
+- Both support `:verbose` variants for detailed output
+
+### Environment Detection
+
+The framework automatically detects the runtime environment:
+- Node.js tests run directly via tsx
+- Browser tests are compiled and served via a local server
+- WebHelpers are only enabled in browser environment
+
+This architecture allows for seamless testing across both Node.js and browser environments while maintaining a clean separation of concerns.