@git.zone/tstest 2.3.8 → 2.4.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/tstest',
-    version: '2.3.8',
+    version: '2.4.0',
     description: 'a test utility to run tests that match test/**/*.ts'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHFEQUFxRDtDQUNuRSxDQUFBIn0=

package/dist_ts/tstest.classes.migration.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Migration result for a single file
+ */
+export interface MigrationResult {
+    /**
+     * Original file path
+     */
+    oldPath: string;
+    /**
+     * New file path after migration
+     */
+    newPath: string;
+    /**
+     * Whether the migration was performed
+     */
+    migrated: boolean;
+    /**
+     * Error message if migration failed
+     */
+    error?: string;
+}
+/**
+ * Migration summary
+ */
+export interface MigrationSummary {
+    /**
+     * Total number of legacy files found
+     */
+    totalLegacyFiles: number;
+    /**
+     * Number of files successfully migrated
+     */
+    migratedCount: number;
+    /**
+     * Number of files that failed to migrate
+     */
+    errorCount: number;
+    /**
+     * Individual migration results
+     */
+    results: MigrationResult[];
+    /**
+     * Whether this was a dry run
+     */
+    dryRun: boolean;
+}
+/**
+ * Migration options
+ */
+export interface MigrationOptions {
+    /**
+     * Base directory to search for test files
+     * Default: process.cwd()
+     */
+    baseDir?: string;
+    /**
+     * Glob pattern for finding test files
+     * Default: '** /*test*.ts' (without space)
+     */
+    pattern?: string;
+    /**
+     * Dry run mode - don't actually rename files
+     * Default: true
+     */
+    dryRun?: boolean;
+    /**
+     * Verbose output
+     * Default: false
+     */
+    verbose?: boolean;
+}
+/**
+ * Migration class for renaming legacy test files to new naming convention
+ *
+ * Migrations:
+ * - .browser.ts → .chromium.ts
+ * - .both.ts → .node+chromium.ts
+ * - .both.nonci.ts → .node+chromium.nonci.ts
+ * - .browser.nonci.ts → .chromium.nonci.ts
+ */
+export declare class Migration {
+    private options;
+    constructor(options?: MigrationOptions);
+    /**
+     * Find all legacy test files in the base directory
+     */
+    findLegacyFiles(): Promise<string[]>;
+    /**
+     * Migrate a single file
+     */
+    private migrateFile;
+    /**
+     * Check if a directory is a git repository
+     */
+    private isGitRepository;
+    /**
+     * Run the migration
+     */
+    run(): Promise<MigrationSummary>;
+    /**
+     * Create a migration report without performing the migration
+     */
+    generateReport(): Promise<string>;
+}

package/dist_ts/tstest.classes.migration.js

@@ -0,0 +1,200 @@
+import * as plugins from './tstest.plugins.js';
+import { coloredString as cs } from '@push.rocks/consolecolor';
+import { parseTestFilename, getLegacyMigrationTarget, isLegacyFilename } from './tstest.classes.runtime.parser.js';
+/**
+ * Migration class for renaming legacy test files to new naming convention
+ *
+ * Migrations:
+ * - .browser.ts → .chromium.ts
+ * - .both.ts → .node+chromium.ts
+ * - .both.nonci.ts → .node+chromium.nonci.ts
+ * - .browser.nonci.ts → .chromium.nonci.ts
+ */
+export class Migration {
+    constructor(options = {}) {
+        this.options = {
+            baseDir: options.baseDir || process.cwd(),
+            pattern: options.pattern || '**/test*.ts',
+            dryRun: options.dryRun !== undefined ? options.dryRun : true,
+            verbose: options.verbose || false,
+        };
+    }
+    /**
+     * Find all legacy test files in the base directory
+     */
+    async findLegacyFiles() {
+        const files = await plugins.smartfile.fs.listFileTree(this.options.baseDir, this.options.pattern);
+        const legacyFiles = [];
+        for (const file of files) {
+            const fileName = plugins.path.basename(file);
+            if (isLegacyFilename(fileName)) {
+                const absolutePath = plugins.path.isAbsolute(file)
+                    ? file
+                    : plugins.path.join(this.options.baseDir, file);
+                legacyFiles.push(absolutePath);
+            }
+        }
+        return legacyFiles;
+    }
+    /**
+     * Migrate a single file
+     */
+    async migrateFile(filePath) {
+        const fileName = plugins.path.basename(filePath);
+        const dirName = plugins.path.dirname(filePath);
+        try {
+            // Get the new filename
+            const newFileName = getLegacyMigrationTarget(fileName);
+            if (!newFileName) {
+                return {
+                    oldPath: filePath,
+                    newPath: filePath,
+                    migrated: false,
+                    error: 'File is not a legacy file',
+                };
+            }
+            const newPath = plugins.path.join(dirName, newFileName);
+            // Check if target file already exists
+            if (await plugins.smartfile.fs.fileExists(newPath)) {
+                return {
+                    oldPath: filePath,
+                    newPath,
+                    migrated: false,
+                    error: `Target file already exists: ${newPath}`,
+                };
+            }
+            if (!this.options.dryRun) {
+                // Check if we're in a git repository
+                const isGitRepo = await this.isGitRepository(this.options.baseDir);
+                if (isGitRepo) {
+                    // Use git mv to preserve history
+                    const smartshell = new plugins.smartshell.Smartshell({
+                        executor: 'bash',
+                        pathDirectories: [],
+                    });
+                    const gitCommand = `cd "${this.options.baseDir}" && git mv "${filePath}" "${newPath}"`;
+                    const result = await smartshell.exec(gitCommand);
+                    if (result.exitCode !== 0) {
+                        throw new Error(`git mv failed: ${result.stderr}`);
+                    }
+                }
+                else {
+                    // Not a git repository - cannot migrate without git
+                    throw new Error('Migration requires a git repository. We have git!');
+                }
+            }
+            return {
+                oldPath: filePath,
+                newPath,
+                migrated: true,
+            };
+        }
+        catch (error) {
+            return {
+                oldPath: filePath,
+                newPath: filePath,
+                migrated: false,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Check if a directory is a git repository
+     */
+    async isGitRepository(dir) {
+        try {
+            const gitDir = plugins.path.join(dir, '.git');
+            return await plugins.smartfile.fs.isDirectory(gitDir);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Run the migration
+     */
+    async run() {
+        const legacyFiles = await this.findLegacyFiles();
+        console.log('');
+        console.log(cs('='.repeat(60), 'blue'));
+        console.log(cs('Test File Migration Tool', 'blue'));
+        console.log(cs('='.repeat(60), 'blue'));
+        console.log('');
+        if (this.options.dryRun) {
+            console.log(cs('🔍 DRY RUN MODE - No files will be modified', 'orange'));
+            console.log('');
+        }
+        console.log(`Found ${legacyFiles.length} legacy test file(s)`);
+        console.log('');
+        const results = [];
+        let migratedCount = 0;
+        let errorCount = 0;
+        for (const file of legacyFiles) {
+            const result = await this.migrateFile(file);
+            results.push(result);
+            if (result.migrated) {
+                migratedCount++;
+                const oldName = plugins.path.basename(result.oldPath);
+                const newName = plugins.path.basename(result.newPath);
+                if (this.options.dryRun) {
+                    console.log(cs(`  Would migrate:`, 'cyan'));
+                }
+                else {
+                    console.log(cs(`  ✓ Migrated:`, 'green'));
+                }
+                console.log(`    ${oldName}`);
+                console.log(cs(`    → ${newName}`, 'green'));
+                console.log('');
+            }
+            else if (result.error) {
+                errorCount++;
+                console.log(cs(`  ✗ Failed: ${plugins.path.basename(result.oldPath)}`, 'red'));
+                console.log(cs(`    ${result.error}`, 'red'));
+                console.log('');
+            }
+        }
+        console.log(cs('='.repeat(60), 'blue'));
+        console.log(`Summary:`);
+        console.log(`  Total legacy files: ${legacyFiles.length}`);
+        console.log(`  Successfully migrated: ${migratedCount}`);
+        console.log(`  Errors: ${errorCount}`);
+        console.log(cs('='.repeat(60), 'blue'));
+        if (this.options.dryRun && legacyFiles.length > 0) {
+            console.log('');
+            console.log(cs('To apply these changes, run:', 'orange'));
+            console.log(cs('  tstest migrate --write', 'orange'));
+        }
+        console.log('');
+        return {
+            totalLegacyFiles: legacyFiles.length,
+            migratedCount,
+            errorCount,
+            results,
+            dryRun: this.options.dryRun,
+        };
+    }
+    /**
+     * Create a migration report without performing the migration
+     */
+    async generateReport() {
+        const legacyFiles = await this.findLegacyFiles();
+        let report = '';
+        report += 'Test File Migration Report\n';
+        report += '='.repeat(60) + '\n';
+        report += '\n';
+        report += `Found ${legacyFiles.length} legacy test file(s)\n`;
+        report += '\n';
+        for (const file of legacyFiles) {
+            const fileName = plugins.path.basename(file);
+            const newFileName = getLegacyMigrationTarget(fileName);
+            if (newFileName) {
+                report += `${fileName}\n`;
+                report += `  → ${newFileName}\n`;
+                report += '\n';
+            }
+        }
+        report += '='.repeat(60) + '\n';
+        return report;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tstest.classes.migration.js","sourceRoot":"","sources":["../ts/tstest.classes.migration.ts"],"names":[],"mappings":"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"}

package/dist_ts/tstest.classes.runtime.adapter.d.ts

@@ -0,0 +1,172 @@
+import type { Runtime } from './tstest.classes.runtime.parser.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+/**
+ * Runtime-specific configuration options
+ */
+export interface RuntimeOptions {
+    /**
+     * Environment variables to pass to the runtime
+     */
+    env?: Record<string, string>;
+    /**
+     * Additional command-line arguments
+     */
+    extraArgs?: string[];
+    /**
+     * Working directory for test execution
+     */
+    cwd?: string;
+    /**
+     * Timeout in milliseconds (0 = no timeout)
+     */
+    timeout?: number;
+}
+/**
+ * Deno-specific configuration options
+ */
+export interface DenoOptions extends RuntimeOptions {
+    /**
+     * Permissions to grant to Deno
+     * Default: ['--allow-read', '--allow-env']
+     */
+    permissions?: string[];
+    /**
+     * Path to deno.json config file
+     */
+    configPath?: string;
+    /**
+     * Path to import map file
+     */
+    importMap?: string;
+}
+/**
+ * Chromium-specific configuration options
+ */
+export interface ChromiumOptions extends RuntimeOptions {
+    /**
+     * Chromium launch arguments
+     */
+    launchArgs?: string[];
+    /**
+     * Headless mode (default: true)
+     */
+    headless?: boolean;
+    /**
+     * Port range for HTTP server
+     */
+    portRange?: {
+        min: number;
+        max: number;
+    };
+}
+/**
+ * Command configuration returned by createCommand()
+ */
+export interface RuntimeCommand {
+    /**
+     * The main command executable (e.g., 'node', 'deno', 'bun')
+     */
+    command: string;
+    /**
+     * Command-line arguments
+     */
+    args: string[];
+    /**
+     * Environment variables
+     */
+    env?: Record<string, string>;
+    /**
+     * Working directory
+     */
+    cwd?: string;
+}
+/**
+ * Runtime availability check result
+ */
+export interface RuntimeAvailability {
+    /**
+     * Whether the runtime is available
+     */
+    available: boolean;
+    /**
+     * Version string if available
+     */
+    version?: string;
+    /**
+     * Error message if not available
+     */
+    error?: string;
+}
+/**
+ * Abstract base class for runtime adapters
+ * Each runtime (Node, Chromium, Deno, Bun) implements this interface
+ */
+export declare abstract class RuntimeAdapter {
+    /**
+     * Runtime identifier
+     */
+    abstract readonly id: Runtime;
+    /**
+     * Human-readable display name
+     */
+    abstract readonly displayName: string;
+    /**
+     * Check if this runtime is available on the system
+     * @returns Availability information including version
+     */
+    abstract checkAvailable(): Promise<RuntimeAvailability>;
+    /**
+     * Create the command configuration for executing a test
+     * @param testFile - Absolute path to the test file
+     * @param options - Runtime-specific options
+     * @returns Command configuration
+     */
+    abstract createCommand(testFile: string, options?: RuntimeOptions): RuntimeCommand;
+    /**
+     * Execute a test file and return a TAP parser
+     * @param testFile - Absolute path to the test file
+     * @param index - Test index (for display)
+     * @param total - Total number of tests (for display)
+     * @param options - Runtime-specific options
+     * @returns TAP parser with test results
+     */
+    abstract run(testFile: string, index: number, total: number, options?: RuntimeOptions): Promise<TapParser>;
+    /**
+     * Get the default options for this runtime
+     * Can be overridden by subclasses
+     */
+    protected getDefaultOptions(): RuntimeOptions;
+    /**
+     * Merge user options with defaults
+     */
+    protected mergeOptions<T extends RuntimeOptions>(userOptions?: T): T;
+}
+/**
+ * Registry for runtime adapters
+ * Manages all available runtime implementations
+ */
+export declare class RuntimeAdapterRegistry {
+    private adapters;
+    /**
+     * Register a runtime adapter
+     */
+    register(adapter: RuntimeAdapter): void;
+    /**
+     * Get an adapter by runtime ID
+     */
+    get(runtime: Runtime): RuntimeAdapter | undefined;
+    /**
+     * Get all registered adapters
+     */
+    getAll(): RuntimeAdapter[];
+    /**
+     * Check which runtimes are available on the system
+     */
+    checkAvailability(): Promise<Map<Runtime, RuntimeAvailability>>;
+    /**
+     * Get adapters for a list of runtimes, in order
+     * @param runtimes - Ordered list of runtimes
+     * @returns Adapters in the same order, skipping any that aren't registered
+     */
+    getAdaptersForRuntimes(runtimes: Runtime[]): RuntimeAdapter[];
+}

package/dist_ts/tstest.classes.runtime.adapter.js

@@ -0,0 +1,85 @@
+import * as plugins from './tstest.plugins.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+/**
+ * Abstract base class for runtime adapters
+ * Each runtime (Node, Chromium, Deno, Bun) implements this interface
+ */
+export class RuntimeAdapter {
+    /**
+     * Get the default options for this runtime
+     * Can be overridden by subclasses
+     */
+    getDefaultOptions() {
+        return {
+            timeout: 0,
+            extraArgs: [],
+            env: {},
+        };
+    }
+    /**
+     * Merge user options with defaults
+     */
+    mergeOptions(userOptions) {
+        const defaults = this.getDefaultOptions();
+        return {
+            ...defaults,
+            ...userOptions,
+            env: { ...defaults.env, ...userOptions?.env },
+            extraArgs: [...(defaults.extraArgs || []), ...(userOptions?.extraArgs || [])],
+        };
+    }
+}
+/**
+ * Registry for runtime adapters
+ * Manages all available runtime implementations
+ */
+export class RuntimeAdapterRegistry {
+    constructor() {
+        this.adapters = new Map();
+    }
+    /**
+     * Register a runtime adapter
+     */
+    register(adapter) {
+        this.adapters.set(adapter.id, adapter);
+    }
+    /**
+     * Get an adapter by runtime ID
+     */
+    get(runtime) {
+        return this.adapters.get(runtime);
+    }
+    /**
+     * Get all registered adapters
+     */
+    getAll() {
+        return Array.from(this.adapters.values());
+    }
+    /**
+     * Check which runtimes are available on the system
+     */
+    async checkAvailability() {
+        const results = new Map();
+        for (const [runtime, adapter] of this.adapters) {
+            const availability = await adapter.checkAvailable();
+            results.set(runtime, availability);
+        }
+        return results;
+    }
+    /**
+     * Get adapters for a list of runtimes, in order
+     * @param runtimes - Ordered list of runtimes
+     * @returns Adapters in the same order, skipping any that aren't registered
+     */
+    getAdaptersForRuntimes(runtimes) {
+        const adapters = [];
+        for (const runtime of runtimes) {
+            const adapter = this.get(runtime);
+            if (adapter) {
+                adapters.push(adapter);
+            }
+        }
+        return adapters;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tstest.classes.runtime.bun.d.ts

@@ -0,0 +1,30 @@
+import { RuntimeAdapter, type RuntimeOptions, type RuntimeCommand, type RuntimeAvailability } from './tstest.classes.runtime.adapter.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+import { TsTestLogger } from './tstest.logging.js';
+import type { Runtime } from './tstest.classes.runtime.parser.js';
+/**
+ * Bun runtime adapter
+ * Executes tests using the Bun runtime with native TypeScript support
+ */
+export declare class BunRuntimeAdapter extends RuntimeAdapter {
+    private logger;
+    private smartshellInstance;
+    private timeoutSeconds;
+    private filterTags;
+    readonly id: Runtime;
+    readonly displayName: string;
+    constructor(logger: TsTestLogger, smartshellInstance: any, // SmartShell instance from @push.rocks/smartshell
+    timeoutSeconds: number | null, filterTags: string[]);
+    /**
+     * Check if Bun is available
+     */
+    checkAvailable(): Promise<RuntimeAvailability>;
+    /**
+     * Create command configuration for Bun test execution
+     */
+    createCommand(testFile: string, options?: RuntimeOptions): RuntimeCommand;
+    /**
+     * Execute a test file in Bun
+     */
+    run(testFile: string, index: number, total: number, options?: RuntimeOptions): Promise<TapParser>;
+}