ui5-test-runner 5.13.1 → 6.0.0-beta.1

package/dist/platform/logger/output/BaseLoggerOutput.js

@@ -0,0 +1,158 @@
+import { FileSystem, Path, Terminal } from '../../index.js';
+import { LogLevel } from '../types.js';
+import { ProgressBar } from '../../../utils/shared/ProgressBar.js';
+import { formatDuration } from '../../../utils/shared/string.js';
+import { assert } from '../../assert.js';
+const icons = {
+    [LogLevel.debug]: Terminal.BLUE + '<o>',
+    [LogLevel.info]: '   ',
+    [LogLevel.warn]: Terminal.YELLOW + '/!\\',
+    [LogLevel.error]: Terminal.RED + '(X)',
+    [LogLevel.fatal]: Terminal.RED + 'o*!'
+};
+const DO_NOT_RENDER_SOURCE = [
+    'browser',
+    'browser/console',
+    'browser/network',
+    'metric',
+    'progress'
+];
+export class BaseLoggerOutput {
+    _configuration;
+    _startedAt;
+    constructor(configuration, startedAt) {
+        this._configuration = configuration;
+        this._startedAt = startedAt;
+    }
+    formatTimestamp(timestamp) {
+        return formatDuration(timestamp - this._startedAt);
+    }
+    render(attributes) {
+        const { level, timestamp, source, message, data, error } = attributes;
+        if (!DO_NOT_RENDER_SOURCE.includes(source) && level !== LogLevel.debug) {
+            return [
+                icons[level],
+                Terminal.MAGENTA,
+                this.formatTimestamp(timestamp),
+                Terminal.WHITE,
+                ' ',
+                message,
+                data ? ` ${JSON.stringify(data)}` : '',
+                error ? ` ${Terminal.RED}${error.name} ${error.message}` : '',
+                '\n'
+            ].join('');
+        }
+    }
+    addToReport(rawText) {
+        FileSystem.writeFileSync(Path.join(this._configuration.reportDir, 'output.txt'), rawText, {
+            encoding: 'utf8',
+            flag: 'a'
+        });
+    }
+    _pageProgressMap = {};
+    get pageIds() {
+        return Object.keys(this._pageProgressMap)
+            .map(Number)
+            .toSorted((a, b) => a - b);
+    }
+    get pageProgressMap() {
+        return this._pageProgressMap;
+    }
+    _overallProgressBar = new ProgressBar();
+    get overallProgressBar() {
+        return this._overallProgressBar;
+    }
+    _overallprogressSnapshot = {
+        totalNumberOfExecutedTests: 0,
+        totalNumberOfErrors: 0,
+        totalNumberOfTests: 0
+    };
+    _updateOverallProgressSnapshot(data) {
+        if (data.type !== 'unknown') {
+            this._overallprogressSnapshot.totalNumberOfExecutedTests += data.value;
+            this._overallprogressSnapshot.totalNumberOfErrors += data.errors;
+            this._overallprogressSnapshot.totalNumberOfTests += data.max;
+        }
+    }
+    _overallprogress = {
+        totalNumberOfExecutedTests: 0,
+        totalNumberOfErrors: 0,
+        totalNumberOfTests: 0
+    };
+    _updateOverallProgress() {
+        const overallProgress = { ...this._overallprogressSnapshot };
+        for (const pageProgress of Object.values(this._pageProgressMap)) {
+            if (pageProgress.type !== 'unknown') {
+                overallProgress.totalNumberOfExecutedTests += pageProgress.bar.value;
+                overallProgress.totalNumberOfErrors += pageProgress.errors;
+                overallProgress.totalNumberOfTests += pageProgress.bar.max;
+            }
+        }
+        this._overallprogress = overallProgress;
+    }
+    get overallProgress() {
+        return this._overallprogress;
+    }
+    _lastOverallStatus = '';
+    _startedAtMap = {};
+    renderAttributes(attributes) {
+        if (attributes.source === 'progress') {
+            const { pageId } = attributes;
+            let pageProgress;
+            let progressBar;
+            if (pageId === undefined) {
+                progressBar = this._overallProgressBar;
+            }
+            else {
+                pageProgress = this._pageProgressMap[pageId];
+                if (!pageProgress) {
+                    pageProgress = {
+                        bar: new ProgressBar(),
+                        type: 'unknown',
+                        errors: 0
+                    };
+                    this._pageProgressMap[pageId] = pageProgress;
+                    this._startedAtMap[pageId] = Date.now();
+                    this.addToReport(`   ${this.formatTimestamp(attributes.timestamp)} >> ${attributes.message} [${pageId}]
+`);
+                }
+                const data = attributes.data;
+                pageProgress.type = data.type;
+                pageProgress.errors = data.errors;
+                progressBar = pageProgress.bar;
+            }
+            progressBar.update(attributes);
+            if (pageId && 'remove' in attributes.data) {
+                delete this._pageProgressMap[pageId];
+                const startedAt = this._startedAtMap[pageId];
+                delete this._startedAtMap[pageId];
+                assert(startedAt !== undefined);
+                const duration = Date.now() - startedAt;
+                this
+                    .addToReport(`   ${this.formatTimestamp(attributes.timestamp)} << ${attributes.message} (${formatDuration(duration)}) [${pageId}]
+`);
+                this._updateOverallProgressSnapshot(attributes.data);
+            }
+            this._updateOverallProgress();
+            if (pageId === undefined && progressBar.label !== this._lastOverallStatus) {
+                this._lastOverallStatus = progressBar.label;
+                this.addToReport(`
+   ${this.formatTimestamp(attributes.timestamp)}|${this._lastOverallStatus}
+   -----+${''.padStart(this._lastOverallStatus.length, '-')}
+`);
+            }
+            return false;
+        }
+        return true;
+    }
+    addAttributesToLoggerOutput(attributes) {
+        if (this.renderAttributes(attributes)) {
+            const rendered = this.render(attributes);
+            if (rendered) {
+                const raw = Terminal.stripVTControlCharacters(rendered);
+                this.addTextToLoggerOutput(rendered, raw);
+                this.addToReport(raw);
+            }
+        }
+    }
+}

package/dist/platform/logger/output/InteractiveLoggerOutput.js

@@ -0,0 +1,102 @@
+import { Terminal } from '../../index.js';
+import { BaseLoggerOutput } from './BaseLoggerOutput.js';
+const TICKS_INTERVAL = 250;
+const TICKS_PICTURES = ['[|]', '[/]', '[-]', String.raw `[\]`];
+const TICKS_COLORS = [Terminal.BLUE, Terminal.CYAN, Terminal.MAGENTA, Terminal.CYAN, Terminal.YELLOW, Terminal.CYAN];
+export class InteractiveLoggerOutput extends BaseLoggerOutput {
+    _noColor;
+    _ticksInterval;
+    _tick = 0;
+    _terminalWidth = Terminal.width;
+    _linesToErase = [];
+    _texts = [];
+    constructor(configuration, startedAt) {
+        super(configuration, startedAt);
+        this._noColor = !!process.env['NO_COLOR'];
+        Terminal.hideCursor();
+        this._ticksInterval = setInterval(this.tick.bind(this), TICKS_INTERVAL);
+    }
+    _clean() {
+        let count = 0;
+        for (const width of this._linesToErase) {
+            if (width > this._terminalWidth) {
+                count += Math.ceil(width / this._terminalWidth);
+            }
+            else {
+                ++count;
+            }
+        }
+        Terminal.eraseToEnd(count);
+        this._linesToErase = [];
+    }
+    terminalResized(width) {
+        this._terminalWidth = width;
+        this._clean();
+        this._progress();
+    }
+    addTextToLoggerOutput(formatted, raw) {
+        this._texts.push(this._noColor ? raw : formatted);
+    }
+    _progress() {
+        const texts = [...this._texts];
+        const linesToErase = [];
+        this._texts.length = 0;
+        for (const pageId of this.pageIds) {
+            const pageProgress = this.pageProgressMap[pageId];
+            const rendered = pageProgress.bar.render(this._terminalWidth - 4);
+            let status = '   ';
+            if (pageProgress.errors) {
+                status = `${Terminal.RED}${Math.min(pageProgress.errors, 999).toString().padEnd(3, ' ')}${Terminal.WHITE}`;
+            }
+            else if (pageProgress.type === 'opa') {
+                status = `${Terminal.GREEN}OPA${Terminal.WHITE}`;
+            }
+            else if (pageProgress.type === 'qunit') {
+                status = `${Terminal.GREEN}QNT${Terminal.WHITE}`;
+            }
+            texts.push(status + rendered + '\n');
+            linesToErase.push(3 + rendered.length);
+        }
+        let testStatus = '';
+        if (this.overallProgress.totalNumberOfTests !== 0) {
+            const { totalNumberOfExecutedTests: executed, totalNumberOfErrors: errors, totalNumberOfTests: total } = this.overallProgress;
+            const success = executed - errors;
+            const errorStatus = errors > 0 ? `${Terminal.WHITE}+${Terminal.RED}${errors}` : '';
+            testStatus = ` (Tests: ${Terminal.GREEN}${success}${errorStatus}${Terminal.WHITE}/${total})`;
+        }
+        const rendered = this.overallProgressBar.render(this._terminalWidth - 4 - testStatus.length);
+        if (this._noColor) {
+            texts.push([
+                TICKS_PICTURES[this._tick % TICKS_PICTURES.length],
+                Terminal.stripVTControlCharacters(rendered + testStatus),
+                '\n'
+            ].join(''));
+        }
+        else {
+            texts.push([
+                TICKS_COLORS[this._tick % TICKS_COLORS.length],
+                TICKS_PICTURES[this._tick % TICKS_PICTURES.length],
+                Terminal.WHITE,
+                rendered,
+                testStatus,
+                '\n'
+            ].join(''));
+        }
+        linesToErase.push(3 + rendered.length);
+        this._clean();
+        Terminal.write(texts.join(''));
+        for (const line of linesToErase) {
+            this._linesToErase.push(line);
+        }
+    }
+    tick() {
+        ++this._tick;
+        this._progress();
+    }
+    closeLoggerOutput() {
+        clearInterval(this._ticksInterval);
+        this._progress();
+        this._clean();
+        Terminal.showCursor();
+    }
+}

package/dist/platform/logger/output/StaticLoggerOutput.js

@@ -0,0 +1,32 @@
+import { Terminal } from '../../index.js';
+import { BaseLoggerOutput } from './BaseLoggerOutput.js';
+export class StaticLoggerOutput extends BaseLoggerOutput {
+    _progressReportInterval;
+    constructor(configuration, startedAt) {
+        super(configuration, startedAt);
+        this._progressReportInterval = setInterval(this.progressReport.bind(this), configuration.outputInterval);
+    }
+    progressReport() {
+        const pageIds = this.pageIds;
+        if (pageIds.length > 0) {
+            this.addToReport(`
+   ${this.formatTimestamp(Date.now())}|Progress
+   -----+--------
+`);
+        }
+        for (const pageId of pageIds) {
+            const pageProgress = this.pageProgressMap[pageId];
+            const rendered = pageProgress.bar.render(80);
+            this.addToReport(rendered + '\n');
+        }
+    }
+    terminalResized() { }
+    addTextToLoggerOutput() { }
+    addToReport(rawText) {
+        super.addToReport(rawText);
+        Terminal.write(rawText);
+    }
+    closeLoggerOutput() {
+        clearInterval(this._progressReportInterval);
+    }
+}

package/dist/platform/logger/output/factory.js

@@ -0,0 +1,10 @@
+import { InteractiveLoggerOutput } from './InteractiveLoggerOutput.js';
+import { StaticLoggerOutput } from './StaticLoggerOutput.js';
+export const LoggerOutputFactory = {
+    build(configuration, startedAt) {
+        const { ci } = configuration;
+        return ci
+            ? new StaticLoggerOutput(configuration, startedAt)
+            : new InteractiveLoggerOutput(configuration, startedAt);
+    }
+};

package/dist/platform/logger/output.js

@@ -0,0 +1,58 @@
+import { Thread } from '../Thread.js';
+import '../logger.js';
+import { LoggerOutputFactory } from './output/factory.js';
+const fromHexaCode = (value) => ({
+    r: Number.parseInt(value.slice(1, 3), 16),
+    g: Number.parseInt(value.slice(3, 5), 16),
+    b: Number.parseInt(value.slice(5, 7), 16)
+});
+export const workerMain = ({ configuration, startedAt }) => {
+    const loggerOutput = LoggerOutputFactory.build(configuration, startedAt);
+    const channel = Thread.createBroadcastChannel('logger');
+    channel.onmessage = (event) => {
+        const { data: message } = event;
+        if (message.command === 'terminate') {
+            channel.close();
+            loggerOutput.closeLoggerOutput();
+        }
+        else if (message.command === 'log') {
+            loggerOutput.addAttributesToLoggerOutput(message);
+        }
+        else if (message.command === 'terminal-resized') {
+            loggerOutput.terminalResized(message.width);
+        }
+    };
+    const from = fromHexaCode('#FF5A37');
+    const to = fromHexaCode('#FFA42C');
+    const background = '\u001B[40m';
+    const diff = {
+        r: to.r - from.r,
+        g: to.g - from.g,
+        b: to.b - from.b
+    };
+    const rawLogo = String.raw `   _,     ,_           _ ____        _            _
+ .'/   _,  \'.   _   _(_) ___|      | |_ ___  ___| |_      _ __ _   _ _ __  _ __   ___ _ __
+|  \__< )__/  | | | | | |___ \ _____| __/ _ \/ __| __|____| '__| | | | '_ \| '_ \ / _ \ '__|
+\             / | |_| | |___) |_____| ||  __/\__ \ ||_____| |  | |_| | | | | | | |  __/ |
+ '-..(___)..-'   \__,_|_|____/       \__\___||___/\__|    |_|   \__,_|_| |_|_| |_|\___|_|`;
+    const width = Math.max(...rawLogo.split('\n').map((line) => line.length));
+    const logo = rawLogo
+        .split('\n')
+        .map((line) => background +
+        [...line.padEnd(width, ' ')]
+            .map((c, index) => {
+            const r = Math.floor(from.r + (diff.r * index) / width);
+            const g = Math.floor(from.g + (diff.g * index) / width);
+            const b = Math.floor(from.b + (diff.b * index) / width);
+            return `\u001B[38;2;${r};${g};${b}m` + c;
+        })
+            .join('') +
+        '\u001B[0m')
+        .join('\n');
+    loggerOutput.addToReport(rawLogo + '\n');
+    loggerOutput.addTextToLoggerOutput(logo + '\u001B[0m\n', rawLogo + '\n');
+    channel.postMessage({
+        command: 'ready',
+        source: 'output'
+    });
+};

package/dist/platform/logger/proxy.js

@@ -0,0 +1,6 @@
+export let logger;
+const breakDependencyLoopToLogger = async () => {
+    const module = await import('../logger.js');
+    logger = module.logger;
+};
+void breakDependencyLoopToLogger();

package/dist/platform/logger/toInternalLogAttributes.js

@@ -0,0 +1,22 @@
+import { Host } from '../Host.js';
+import { Thread } from '../Thread.js';
+export const toInternalLogAttributes = (attributes, level) => {
+    if (attributes.processId !== undefined) {
+        return {
+            timestamp: Date.now(),
+            level,
+            threadId: 0,
+            isMainThread: false,
+            ...attributes,
+            processId: attributes.processId
+        };
+    }
+    return {
+        timestamp: Date.now(),
+        level,
+        processId: Host.pid,
+        threadId: Thread.threadId,
+        isMainThread: Thread.isMainThread,
+        ...attributes
+    };
+};

package/dist/platform/logger/types.js

@@ -0,0 +1,7 @@
+export const LogLevel = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    fatal: 4
+};

package/dist/platform/logger.js

@@ -0,0 +1,138 @@
+import { Exit, ExitShutdownError } from './Exit.js';
+import { Host } from './Host.js';
+import { Terminal } from './Terminal.js';
+import { Thread } from './Thread.js';
+import { LogLevel } from './logger/types.js';
+import { toInternalLogAttributes } from './logger/toInternalLogAttributes.js';
+import assert from 'node:assert/strict';
+import { toPlainObject } from '../utils/shared/object.js';
+import { toIError } from '../utils/shared/toIError.js';
+const startedAt = Date.now();
+let channel;
+let loggerWorker;
+let consoleWorker;
+const buffer = [];
+const waitingFor = ['allCompressed', 'output'];
+let ready = !Thread.isMainThread;
+let metricsMonitorInterval;
+const terminalResized = (width) => {
+    channel?.postMessage({
+        command: 'terminal-resized',
+        width
+    });
+};
+const start = () => {
+    channel = Thread.createBroadcastChannel('logger');
+    metricsMonitorInterval = setInterval(() => {
+        logger.debug({
+            source: 'metric',
+            message: '',
+            data: {
+                cpu: Thread.threadCpuUsage(),
+                mem: Host.memoryUsage()
+            }
+        });
+    }, 1000);
+    channel.onmessage = (event) => {
+        const { data: message } = event;
+        if (message.command === 'ready' && Thread.isMainThread) {
+            terminalResized(Terminal.width);
+            const index = waitingFor.indexOf(message.source);
+            waitingFor.splice(index, 1);
+            ready = waitingFor.length === 0;
+            if (ready && buffer.length > 0) {
+                for (const buffered of buffer) {
+                    channel.postMessage({
+                        command: 'log',
+                        ...buffered
+                    });
+                }
+                buffer.length = 0;
+            }
+        }
+        else if (message.command === 'terminate') {
+            clearInterval(metricsMonitorInterval);
+            channel.close();
+        }
+    };
+};
+const log = (level, attributes) => {
+    const allAttributes = toInternalLogAttributes(attributes, level);
+    if (attributes.error) {
+        allAttributes.error = toIError(attributes.error);
+    }
+    if (ready && !stopping) {
+        channel.postMessage({
+            command: 'log',
+            ...allAttributes
+        });
+    }
+    else {
+        buffer.push(allAttributes);
+    }
+};
+if (!Thread.isMainThread) {
+    start();
+}
+let stopping;
+export const logger = {
+    start(configuration) {
+        assert.ok(Thread.isMainThread, 'Call logger.start only in main thread');
+        assert.ok(!loggerWorker && !consoleWorker, 'Call logger.start only once');
+        start();
+        loggerWorker = Thread.createWorker('platform/logger/allCompressed', {
+            configuration: toPlainObject(configuration)
+        });
+        consoleWorker = Thread.createWorker('platform/logger/output', {
+            configuration: toPlainObject(configuration),
+            startedAt
+        });
+        if (!configuration.ci) {
+            Terminal.setRawMode((data) => {
+                if (data.length === 1 && data[0] === 3) {
+                    logger.warn({ source: 'job', message: 'User requested interruption' });
+                    Exit.sigInt();
+                }
+            });
+            Terminal.onResize(terminalResized);
+        }
+    },
+    debug(attributes) {
+        log(LogLevel.debug, attributes);
+    },
+    info(attributes) {
+        log(LogLevel.info, attributes);
+    },
+    warn(attributes) {
+        log(LogLevel.warn, attributes);
+    },
+    error(attributes) {
+        log(attributes.error && attributes.error instanceof ExitShutdownError ? LogLevel.debug : LogLevel.error, attributes);
+    },
+    fatal(attributes) {
+        log(LogLevel.fatal, attributes);
+    },
+    async stop() {
+        assert.ok(Thread.isMainThread, 'Call logger.stop only in main thread');
+        if (stopping) {
+            return await stopping;
+        }
+        const { promise, resolve } = Promise.withResolvers();
+        stopping = promise;
+        clearInterval(metricsMonitorInterval);
+        if (loggerWorker && consoleWorker) {
+            while (waitingFor.length > 0) {
+                await new Promise((resolve) => setTimeout(resolve, 250));
+            }
+            const { promise: loggerPromise, resolve: loggerExited } = Promise.withResolvers();
+            const { promise: consolePromise, resolve: consoleExited } = Promise.withResolvers();
+            loggerWorker.on('exit', loggerExited);
+            consoleWorker.on('exit', consoleExited);
+            channel.postMessage({ command: 'terminate' });
+            await Promise.all([loggerPromise, consolePromise]);
+            channel.close();
+        }
+        Terminal.setRawMode(false);
+        resolve();
+    }
+};

package/dist/platform/mock.js

@@ -0,0 +1,104 @@
+import { vi } from 'vitest';
+import { join } from 'node:path';
+const mockStaticMethodsOfExportedClasses = (actual) => {
+    const mocked = { ...actual };
+    for (const exportName in mocked) {
+        const exportValue = mocked[exportName];
+        if (typeof exportValue === 'function') {
+            const exportClass = exportValue;
+            for (const staticName of Object.getOwnPropertyNames(exportValue)) {
+                const staticValue = exportClass[staticName];
+                if (typeof staticValue === 'function') {
+                    exportClass[staticName] = vi.fn();
+                }
+            }
+        }
+    }
+    return mocked;
+};
+vi.mock(import('./constants.js'), async (importActual) => {
+    const mocked = await importActual();
+    return {
+        ...mocked,
+        __developmentMode: false
+    };
+});
+export const __unregisterExitAsyncTask = vi.fn();
+export let __lastRegisteredExitAsyncTask;
+vi.mock(import('./Exit.js'), async (importActual) => {
+    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const { Exit } = mocked;
+    vi.mocked(Exit.registerAsyncTask).mockImplementation((task) => {
+        __lastRegisteredExitAsyncTask = task;
+        return { [Symbol.dispose]: __unregisterExitAsyncTask };
+    });
+    return mocked;
+});
+vi.mock(import('./FileSystem.js'), async (importActual) => {
+    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const { FileSystem } = mocked;
+    const writeStream = {
+        write: vi.fn().mockImplementation((_, callback) => callback()),
+        end: vi.fn()
+    };
+    vi.mocked(FileSystem.createWriteStream).mockReturnValue(writeStream);
+    const readStream = {};
+    vi.mocked(FileSystem.createReadStream).mockReturnValue(readStream);
+    return mocked;
+});
+vi.mock(import('./Host.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
+vi.mock(import('./Http.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
+const logger = {
+    start: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    fatal: vi.fn(),
+    stop: vi.fn()
+};
+vi.mock(import('./logger.js'), () => ({ logger }));
+vi.mock(import('./Path.js'), async (importActual) => {
+    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const { Path } = mocked;
+    vi.mocked(Path.isAbsolute).mockImplementation((path) => path.startsWith('/'));
+    vi.mocked(Path.join).mockImplementation((...arguments_) => join(...arguments_).replaceAll('\\', '/'));
+    return mocked;
+});
+vi.mock(import('./Process.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));
+export let __lastTerminalRawModeCallback = false;
+vi.mock(import('./Terminal.js'), async (importActual) => {
+    const actual = await importActual();
+    const originalstripVTControlCharacters = actual.Terminal.stripVTControlCharacters;
+    const mocked = mockStaticMethodsOfExportedClasses(actual);
+    const { Terminal } = mocked;
+    vi.mocked(Terminal.setRawMode).mockImplementation((callback) => {
+        __lastTerminalRawModeCallback = callback;
+    });
+    vi.mocked(Terminal.stripVTControlCharacters).mockImplementation(originalstripVTControlCharacters);
+    return mocked;
+});
+vi.mock(import('./Thread.js'), async (importActual) => {
+    const mocked = mockStaticMethodsOfExportedClasses(await importActual());
+    const { Thread } = mocked;
+    const channel = {
+        postMessage: vi.fn().mockImplementation((data) => {
+            channel.onmessage?.({ data });
+        }),
+        onmessage: undefined,
+        close: vi.fn()
+    };
+    vi.mocked(Thread.createBroadcastChannel).mockReturnValue(channel);
+    const eventTarget = new EventTarget();
+    const worker = eventTarget;
+    Object.assign(worker, {
+        on: eventTarget.addEventListener.bind(eventTarget),
+        postMessage: vi.fn()
+    });
+    vi.mocked(Thread.createWorker).mockReturnValue(worker);
+    return mocked;
+});
+vi.mock(import('./version.js'), () => ({
+    version: vi.fn().mockResolvedValue('ui5-test-runner@1.2.3')
+}));
+vi.mock(import('./ZLib.js'), async (importActual) => mockStaticMethodsOfExportedClasses(await importActual()));

package/dist/platform/version.js

@@ -0,0 +1,8 @@
+import { FileSystem } from './FileSystem.js';
+import { __sourcesRoot } from './constants.js';
+import { Path } from './Path.js';
+import { memoize } from '../utils/shared/memoize.js';
+export const version = memoize(async () => {
+    const { name, version } = JSON.parse(await FileSystem.readFile(Path.join(__sourcesRoot, '../package.json'), 'utf8'));
+    return `${name}@${version}`;
+});

package/dist/platform/workerBootstrap.js

@@ -0,0 +1,21 @@
+import { workerData } from 'node:worker_threads';
+import { logger } from './logger.js';
+const main = async () => {
+    const { path, data } = workerData;
+    logger.debug({ source: 'thread', message: `Worker starting...`, data: { path, data } });
+    const { workerMain } = (await import(path));
+    try {
+        await workerMain(data);
+    }
+    catch (error) {
+        logger.fatal({ source: 'thread', message: `An error occurred`, error, data: { path } });
+    }
+    finally {
+        logger.debug({
+            source: 'thread',
+            message: `Main completed (it does not mean the worker is offline)`,
+            data: { path }
+        });
+    }
+};
+void main();