@nu-art/build-and-install 0.400.14 → 0.401.1

package/workspace/Workspace.d.ts

@@ -0,0 +1,95 @@
+import { AnyConstructor, Logger } from '@nu-art/ts-common';
+import { BaiParams } from '../core/params.js';
+import { UnitsMapper } from '../units/discovery/UnitsMapper.js';
+import { UnitsDependencyMapper } from '../dependencies/UnitsDependencyMapper.js';
+import { BaseUnit, ProjectUnit, Unit_NodeProject } from '../units/index.js';
+/**
+ * Central workspace manager for all units in the build system.
+ *
+ * **Unit Categories**:
+ * - **Scanned Units**: All units discovered from workspace file system scan
+ * - **Active Units**: Units selected for execution (compile/test/lint) based on runtime params
+ * - **Project Units**: Active units + their transitive dependencies (needed for prepare/install)
+ *
+ * **Key Responsibilities**:
+ * - Unit discovery and storage
+ * - Dependency resolution and tree building
+ * - Unit lookup by key/type
+ * - Active/project unit derivation based on runtime params
+ *
+ * **Dependency Management**:
+ * - Uses `UnitsDependencyMapper` to resolve transitive dependencies
+ * - Builds dependency tree in layers (dependencies first, dependents last)
+ * - Filters dependencies to only include units that exist in workspace
+ *
+ * **Runtime Params Impact**:
+ * - `--use-package`: Filters active units to match regex patterns
+ * - `--build-tree`: Includes transitive dependencies in active units
+ * - Without flags: All units are active and project units
+ */
+export declare class Workspace extends Logger {
+    private _projectUnits;
+    private _activeUnits;
+    private _projectUnitKeys;
+    private unitsDependencyMapper?;
+    private unitKeyToUnitMap;
+    /**
+     * All project units (subset of scanned units that are ProjectUnits)
+     */
+    get projectUnits(): ReadonlyArray<ProjectUnit>;
+    /**
+     * Keys of units selected for execution
+     */
+    get activeUnits(): ReadonlyArray<string>;
+    /**
+     * Keys of project units (active units + their transitive dependencies)
+     */
+    get projectUnitKeys(): ReadonlyArray<string>;
+    /**
+     * Scan units from the workspace using the provided UnitsMapper
+     */
+    scanUnits(path: string, unitsMapper: UnitsMapper): Promise<void>;
+    /**
+     * Add additional project units (e.g., from applicative configuration)
+     * can only be called before scanUnits()
+     */
+    addProjectUnits(projectUnits: ProjectUnit[]): void;
+    /**
+     * Initialize the dependency mapper with project units
+     */
+    initializeDependencyMapper(globalOutputFolder: string): void;
+    /**
+     * Derive active and project units based on runtime parameters
+     * This must be called after initializeDependencyMapper()
+     */
+    deriveActiveAndProjectUnits(runtimeParams: BaiParams): {
+        activeUnits: string[];
+        projectUnits: string[];
+    };
+    /**
+     * Get a unit by its key
+     */
+    getUnitByKey<T extends BaseUnit>(key: string): T | undefined;
+    getUnitByKey<T extends BaseUnit>(key: string, className: AnyConstructor<T>): T;
+    /**
+     * Get multiple units by their keys, optionally filtered by class type
+     */
+    getUnitsByKeys<T extends BaseUnit>(keys: string[], className?: AnyConstructor<T>): T[];
+    /**
+     * Get the root NodeProject unit
+     */
+    getNodeProjectUnit(): Unit_NodeProject | undefined;
+    /**
+     * Build dependency tree for the given project unit keys
+     * Returns layers of units ordered from bottom (no dependencies) to top
+     */
+    buildDependencyTree(projectUnitKeys: string[]): Promise<ProjectUnit[][]>;
+    /**
+     * Get transitive dependencies for given unit keys
+     */
+    getTransitiveDependencies(keys: string[]): string[];
+    /**
+     * Get the dependency mapper (for runtime context)
+     */
+    getDependencyMapper(): UnitsDependencyMapper;
+}

package/workspace/Workspace.js

@@ -0,0 +1,192 @@
+import { _keys, arrayToMap, BadImplementationException, flatArray, ImplementationMissingException, Logger } from '@nu-art/ts-common';
+import { UnitsDependencyMapper } from '../dependencies/UnitsDependencyMapper.js';
+import { ProjectUnit, Unit_NodeProject } from '../units/index.js';
+/**
+ * Central workspace manager for all units in the build system.
+ *
+ * **Unit Categories**:
+ * - **Scanned Units**: All units discovered from workspace file system scan
+ * - **Active Units**: Units selected for execution (compile/test/lint) based on runtime params
+ * - **Project Units**: Active units + their transitive dependencies (needed for prepare/install)
+ *
+ * **Key Responsibilities**:
+ * - Unit discovery and storage
+ * - Dependency resolution and tree building
+ * - Unit lookup by key/type
+ * - Active/project unit derivation based on runtime params
+ *
+ * **Dependency Management**:
+ * - Uses `UnitsDependencyMapper` to resolve transitive dependencies
+ * - Builds dependency tree in layers (dependencies first, dependents last)
+ * - Filters dependencies to only include units that exist in workspace
+ *
+ * **Runtime Params Impact**:
+ * - `--use-package`: Filters active units to match regex patterns
+ * - `--build-tree`: Includes transitive dependencies in active units
+ * - Without flags: All units are active and project units
+ */
+export class Workspace extends Logger {
+    _projectUnits = [];
+    _activeUnits = [];
+    _projectUnitKeys = [];
+    unitsDependencyMapper;
+    unitKeyToUnitMap = {};
+    /**
+     * All project units (subset of scanned units that are ProjectUnits)
+     */
+    get projectUnits() {
+        return this._projectUnits;
+    }
+    /**
+     * Keys of units selected for execution
+     */
+    get activeUnits() {
+        return this._activeUnits;
+    }
+    /**
+     * Keys of project units (active units + their transitive dependencies)
+     */
+    get projectUnitKeys() {
+        return this._projectUnitKeys;
+    }
+    /**
+     * Scan units from the workspace using the provided UnitsMapper
+     */
+    async scanUnits(path, unitsMapper) {
+        this.logDebug(`Resolving units from: ${path}`);
+        const scannedUnits = await unitsMapper.resolveUnits(path);
+        Object.freeze(scannedUnits);
+        this.unitKeyToUnitMap = arrayToMap(scannedUnits, unit => unit.config.key, this.unitKeyToUnitMap);
+        this._projectUnits.push(...scannedUnits.filter(unit => unit.isInstanceOf(ProjectUnit)));
+        Object.freeze(this._projectUnits);
+    }
+    /**
+     * Add additional project units (e.g., from applicative configuration)
+     * can only be called before scanUnits()
+     */
+    addProjectUnits(projectUnits) {
+        // Check for duplicates
+        const unitKeysToAdd = projectUnits.map(u => u.config.key);
+        this.logVerbose(`Adding units:`, unitKeysToAdd);
+        if (projectUnits.length > 0) {
+            this._projectUnits.push(...projectUnits);
+            // Update lookup map
+            for (const unit of projectUnits) {
+                this.logDebug(`Adding project unit: ${unit.config.key}`);
+                this.unitKeyToUnitMap[unit.config.key] = unit;
+            }
+        }
+    }
+    /**
+     * Initialize the dependency mapper with project units
+     */
+    initializeDependencyMapper(globalOutputFolder) {
+        const unitsDependencies = this._projectUnits.map(unit => ({
+            key: unit.config.key,
+            dependsOn: _keys(unit.config.dependencies).filter(key => !!this.unitKeyToUnitMap[key])
+        }));
+        this.unitsDependencyMapper = new UnitsDependencyMapper(unitsDependencies, globalOutputFolder);
+    }
+    /**
+     * Derive active and project units based on runtime parameters
+     * This must be called after initializeDependencyMapper()
+     */
+    deriveActiveAndProjectUnits(runtimeParams) {
+        if (!this.unitsDependencyMapper) {
+            throw new BadImplementationException('Dependency mapper must be initialized before deriving units. Call initializeDependencyMapper() first.');
+        }
+        const unitKeySet = new Set();
+        const allUnits = [];
+        for (const unit of flatArray(this._projectUnits)) {
+            if (unitKeySet.has(unit.config.key))
+                throw new Error(`Multiple units with same key: ${unit.config.key}`);
+            unitKeySet.add(unit.config.key);
+            allUnits.push(unit);
+        }
+        let activeUnits = [];
+        let projectUnits = [];
+        // 1. Handle usePackage: "Work on these units only" (Option A)
+        //    - Matched units → active (compile/test/lint these)
+        //    - Matched + transitive → project (prepare dependencies, but don't compile them)
+        //    - If buildTree flag is set, transitive dependencies also become active
+        const usePackageKeys = runtimeParams.usePackage;
+        if (usePackageKeys?.length) {
+            const regexMatchers = usePackageKeys.map(filter => new RegExp(`.*?${filter}.*?`, 'i'));
+            const matched = allUnits.filter(unit => regexMatchers.some(matcher => matcher.test(unit.config.key))).map(unit => unit.config.key);
+            const transitive = this.unitsDependencyMapper.getTransitiveDependencies(matched);
+            activeUnits.push(...matched);
+            projectUnits.push(...matched, ...transitive);
+            if (!activeUnits.length)
+                throw new ImplementationMissingException('No unit found matching these filters: ' + usePackageKeys.join(', '));
+            // If buildTree flag is set, make transitive dependencies active too
+            if (runtimeParams.buildTree) {
+                activeUnits.push(...transitive);
+            }
+        }
+        else {
+            const allKeys = allUnits.map(unit => unit.config.key);
+            activeUnits = allKeys;
+            projectUnits = allKeys;
+        }
+        this._activeUnits = [...new Set(activeUnits)];
+        this._projectUnitKeys = [...new Set(projectUnits)];
+        this.logDebug(`Active units: ${this._activeUnits.join(', ')}`);
+        this.logDebug(`Project units: ${this._projectUnitKeys.join(', ')}`);
+        return {
+            activeUnits: this._activeUnits,
+            projectUnits: this._projectUnitKeys
+        };
+    }
+    getUnitByKey(key, className) {
+        const unit = this.unitKeyToUnitMap[key];
+        if (!unit)
+            throw new BadImplementationException(`Unit with key '${key}' not found.`);
+        if (className && !unit.isInstanceOf(className))
+            throw new BadImplementationException(`Unit with key '${key}' is not of type: ${className.name}`);
+        return unit;
+    }
+    /**
+     * Get multiple units by their keys, optionally filtered by class type
+     */
+    getUnitsByKeys(keys, className) {
+        const units = keys.map(key => this.unitKeyToUnitMap[key]).filter(Boolean);
+        if (className)
+            return units.filter(unit => unit.isInstanceOf(className));
+        return units;
+    }
+    /**
+     * Get the root NodeProject unit
+     */
+    getNodeProjectUnit() {
+        return this._projectUnits.find(unit => unit.isInstanceOf(Unit_NodeProject));
+    }
+    /**
+     * Build dependency tree for the given project unit keys
+     * Returns layers of units ordered from bottom (no dependencies) to top
+     */
+    async buildDependencyTree(projectUnitKeys) {
+        if (!this.unitsDependencyMapper) {
+            throw new Error('Dependency mapper must be initialized. Call initializeDependencyMapper() first.');
+        }
+        const unitKeyLayers = await this.unitsDependencyMapper.buildDependencyTree(projectUnitKeys);
+        return unitKeyLayers.map(keys => keys.map(key => this.getUnitByKey(key)).filter(Boolean));
+    }
+    /**
+     * Get transitive dependencies for given unit keys
+     */
+    getTransitiveDependencies(keys) {
+        if (!this.unitsDependencyMapper) {
+            throw new Error('Dependency mapper must be initialized. Call initializeDependencyMapper() first.');
+        }
+        return this.unitsDependencyMapper.getTransitiveDependencies(keys);
+    }
+    /**
+     * Get the dependency mapper (for runtime context)
+     */
+    getDependencyMapper() {
+        if (!this.unitsDependencyMapper) {
+            throw new Error('Dependency mapper must be initialized. Call initializeDependencyMapper() first.');
+        }
+        return this.unitsDependencyMapper;
+    }
+}

package/core/consts.d.ts

@@ -1,13 +0,0 @@
-import { MemKey } from '@nu-art/ts-common/mem-storage/index';
-import { RuntimeProjectConfig } from './types/index.js';
-export declare const CONST_VersionApp = "version-app.json";
-export declare const CONST_PackageJSONTemplate = "__package.json";
-export declare const CONST_PackageJSON = "package.json";
-export declare const CONST_NodeModules = "node_modules";
-export declare const CONST_BaiConfig = "bai-config.json";
-export declare const CONST_FirebaseRC = ".firebaserc";
-export declare const CONST_FirebaseJSON = "firebase.json";
-export declare const CONST_TS_CONFIG = "tsconfig.json";
-export declare const CONST_PNPM_WORKSPACE = "pnpm-workspace.yaml";
-export declare const CONST_PNPM_LOCK = "pnpm-lock.yaml";
-export declare const MemKey_Packages: MemKey<RuntimeProjectConfig>;

package/core/consts.js

@@ -1,12 +0,0 @@
-import { MemKey } from '@nu-art/ts-common/mem-storage/index';
-export const CONST_VersionApp = 'version-app.json';
-export const CONST_PackageJSONTemplate = '__package.json';
-export const CONST_PackageJSON = 'package.json';
-export const CONST_NodeModules = 'node_modules';
-export const CONST_BaiConfig = 'bai-config.json';
-export const CONST_FirebaseRC = '.firebaserc';
-export const CONST_FirebaseJSON = 'firebase.json';
-export const CONST_TS_CONFIG = 'tsconfig.json';
-export const CONST_PNPM_WORKSPACE = 'pnpm-workspace.yaml';
-export const CONST_PNPM_LOCK = 'pnpm-lock.yaml';
-export const MemKey_Packages = new MemKey('bai-packages', true);

package/core/exceptions/PhaseAggregatedException.d.ts

@@ -1,8 +0,0 @@
-import { CustomException, Logger } from '@nu-art/ts-common';
-import { ScheduledStep } from '../../v3/PhaseManager.js';
-import { UnitPhaseException } from './UnitPhaseException.js';
-export declare class PhaseAggregatedException extends CustomException {
-    errors: UnitPhaseException[];
-    constructor(errors: UnitPhaseException[], step: ScheduledStep);
-    print(logger: Logger): void;
-}

package/core/exceptions/UnitPhaseException.d.ts

@@ -1,5 +0,0 @@
-import { CustomException } from '@nu-art/ts-common';
-import { BaseUnit } from '../../v3/units/index.js';
-export declare class UnitPhaseException extends CustomException {
-    constructor(cause: Error, unit: BaseUnit, phase: string);
-}

package/core/exceptions/UnitPhaseException.js

@@ -1,6 +0,0 @@
-import { CustomException } from '@nu-art/ts-common';
-export class UnitPhaseException extends CustomException {
-    constructor(cause, unit, phase) {
-        super(UnitPhaseException, `Error in ${unit.config.key} (${phase})`, cause);
-    }
-}

package/old/PhaseRunnerDispatcher.d.ts

@@ -1,24 +0,0 @@
-import { FunctionKeys, ParamResolver } from '@nu-art/ts-common';
-import { BaseUnit } from '../v3/units/index.js';
-import { Phase } from '../v3/phase/index.js';
-export declare class PhaseRunnerDispatcher<T, K extends FunctionKeys<T> = FunctionKeys<T>, P extends ParamResolver<T, K> = ParamResolver<T, K>> {
-    private readonly method;
-    constructor(method: K);
-    private listeners;
-    addListener(listener: any): void;
-    removeListener(listener: any): void;
-    dispatch(...data: P): void;
-    dispatchAsync(...data: P): Promise<void>;
-}
-export interface PhaseRunner_OnPhaseChange {
-    __onPhaseChange: (data: Phase<string>) => void;
-}
-export declare const dispatcher_PhaseChange: PhaseRunnerDispatcher<PhaseRunner_OnPhaseChange, "__onPhaseChange", [data: Phase<string>]>;
-export interface PhaseRunner_OnUnitStatusChange {
-    __onUnitStatusChange: (data: BaseUnit) => void;
-}
-export declare const dispatcher_UnitStatusChange: PhaseRunnerDispatcher<PhaseRunner_OnUnitStatusChange, "__onUnitStatusChange", [data: BaseUnit<import("../v3/units/BaseUnit.js").BaseUnit_Config, import("../v3/units/BaseUnit.js").UnitRuntimeContext>]>;
-export interface PhaseRunner_OnUnitsChange {
-    __onUnitsChange: (data: BaseUnit[]) => void;
-}
-export declare const dispatcher_UnitChange: PhaseRunnerDispatcher<PhaseRunner_OnUnitsChange, "__onUnitsChange", [data: BaseUnit<import("../v3/units/BaseUnit.js").BaseUnit_Config, import("../v3/units/BaseUnit.js").UnitRuntimeContext>[]]>;

package/old/PhaseRunnerDispatcher.js

@@ -1,32 +0,0 @@
-import { removeItemFromArray } from '@nu-art/ts-common';
-export class PhaseRunnerDispatcher {
-    method;
-    constructor(method) {
-        this.method = method;
-    }
-    listeners = [];
-    //######################### Listeners Logic #########################
-    addListener(listener) {
-        if (this.listeners.includes(listener))
-            return;
-        this.listeners.push(listener);
-    }
-    removeListener(listener) {
-        removeItemFromArray(this.listeners, listener);
-    }
-    dispatch(...data) {
-        this.listeners.forEach(listener => {
-            // @ts-ignore
-            listener[this.method]?.(...data);
-        });
-    }
-    async dispatchAsync(...data) {
-        await Promise.all(this.listeners.map(async (listener) => {
-            // @ts-ignore
-            return listener[this.method]?.(...data);
-        }));
-    }
-}
-export const dispatcher_PhaseChange = new PhaseRunnerDispatcher('__onPhaseChange');
-export const dispatcher_UnitStatusChange = new PhaseRunnerDispatcher('__onUnitStatusChange');
-export const dispatcher_UnitChange = new PhaseRunnerDispatcher('__onUnitsChange');

package/old/runner-dispatchers.d.ts

@@ -1,10 +0,0 @@
-import { PhaseRunnerDispatcher } from './PhaseRunnerDispatcher.js';
-import { BaseUnit } from '../v3/units/index.js';
-export interface OnWatchReady {
-    __onWatchReady: () => void;
-}
-export declare const dispatcher_WatchReady: PhaseRunnerDispatcher<OnWatchReady, "__onWatchReady", []>;
-export interface OnUnitWatchCompiled {
-    __onUnitWatchCompiled: (units: BaseUnit[]) => void;
-}
-export declare const dispatcher_UnitWatchCompile: PhaseRunnerDispatcher<OnUnitWatchCompiled, "__onUnitWatchCompiled", [units: BaseUnit<import("../v3/units/BaseUnit.js").BaseUnit_Config, import("../v3/units/BaseUnit.js").UnitRuntimeContext>[]]>;

package/old/runner-dispatchers.js

@@ -1,3 +0,0 @@
-import { PhaseRunnerDispatcher } from './PhaseRunnerDispatcher.js';
-export const dispatcher_WatchReady = new PhaseRunnerDispatcher('__onWatchReady');
-export const dispatcher_UnitWatchCompile = new PhaseRunnerDispatcher('__onUnitWatchCompiled');

package/v3/PhaseManager.d.ts

@@ -1,26 +0,0 @@
-import { Logger } from '@nu-art/ts-common';
-import { RunningStatusHandler } from './RunningStatusHandler.js';
-import { Phase } from './phase/index.js';
-import { BaseUnit } from './units/index.js';
-export type ScheduledStep = {
-    phases: string[];
-    units: string[];
-};
-export type ExecutionStep = {
-    phases: Phase<any>[];
-    units: BaseUnit<any>[];
-};
-export declare class PhaseManager extends Logger {
-    private readonly phases;
-    private readonly units;
-    private runningUnits;
-    private killed;
-    private runningStatus;
-    private activeUnits;
-    private readonly keyToPhaseMap;
-    constructor(runningStatus: RunningStatusHandler, phases: Phase<any>[][], units: BaseUnit[][]);
-    calculateExecutionSteps(): Promise<ScheduledStep[]>;
-    execute(_steps: ScheduledStep[]): Promise<void>;
-    break(): Promise<void[]>;
-    private mapStep;
-}

package/v3/PhaseManager.js

@@ -1,158 +0,0 @@
-import { addItemToArray, asArray, exists, flatArray, Logger, removeItemFromArray, timeCounter } from '@nu-art/ts-common';
-import { PhaseAggregatedException } from '../core/exceptions/PhaseAggregatedException.js';
-import { UnitPhaseException } from '../core/exceptions/UnitPhaseException.js';
-export class PhaseManager extends Logger {
-    phases;
-    units;
-    runningUnits = [];
-    killed = false;
-    runningStatus;
-    activeUnits;
-    keyToPhaseMap;
-    constructor(runningStatus, phases, units) {
-        super();
-        this.phases = phases;
-        this.units = units;
-        this.runningStatus = runningStatus;
-        const unitKeySet = new Set();
-        const allUnits = [];
-        for (const unit of flatArray(units)) {
-            if (unitKeySet.has(unit.config.key))
-                throw new Error(`Multiple units with same key: ${unit.config.key}`);
-            unitKeySet.add(unit.config.key);
-            allUnits.push(unit);
-        }
-        const usePackageKeys = this.runningStatus.runtimeParams.usePackage;
-        if (!usePackageKeys?.length)
-            this.activeUnits = allUnits.map(unit => unit.config.key);
-        else {
-            const regexMatchers = usePackageKeys.map(filter => new RegExp(`.*?${filter}.*?`, 'i'));
-            this.activeUnits = allUnits.filter(unit => regexMatchers.some(matcher => matcher.test(unit.config.key))).map(unit => unit.config.key);
-        }
-        const packagesToInclude = this.runningStatus.runtimeParams.includePackage;
-        if (packagesToInclude?.length) {
-            const regexMatchers = asArray(packagesToInclude).map(filter => new RegExp(`.*?${filter}.*?`, 'i'));
-            this.activeUnits.push(...allUnits.filter(unit => regexMatchers.some(matcher => matcher.test(unit.config.key))).map(unit => unit.config.key));
-            this.activeUnits = [...new Set(this.activeUnits)];
-        }
-        this.keyToPhaseMap = flatArray(phases).reduce((acc, phase) => {
-            acc[phase.key] = phase;
-            return acc;
-        }, {});
-    }
-    //######################### Initialization #########################
-    async calculateExecutionSteps() {
-        const steps = [];
-        this.logDebug('Calculating execution steps for phases: ', this.phases.map(phases => phases.map(phase => phase.key)));
-        this.logDebug('Active Units: ', this.activeUnits);
-        for (let phaseGroup of this.phases) {
-            phaseGroup = phaseGroup.filter(phase => !exists(phase.filter) || phase.filter(this.runningStatus.runtimeParams));
-            for (const layer of this.units) {
-                const layerUnits = layer.filter(u => this.activeUnits.includes(u.config.key));
-                if (layerUnits.length === 0)
-                    continue;
-                const phaseMap = new Map();
-                for (const unit of layerUnits) {
-                    const supportedPhases = phaseGroup.filter(phase => phase.method in unit && typeof unit[phase.method] === 'function');
-                    if (supportedPhases.length === 0)
-                        continue;
-                    const key = phaseGroup
-                        .filter(phase => supportedPhases.find(p => p.key === phase.key))
-                        .map(p => p.key)
-                        .join('|');
-                    if (!phaseMap.has(key))
-                        phaseMap.set(key, []);
-                    phaseMap.get(key).push(unit);
-                }
-                for (const [phaseKeyCombo, groupedUnits] of phaseMap.entries()) {
-                    steps.push({
-                        phases: phaseKeyCombo.split('|'),
-                        units: groupedUnits.map(u => u.config.key),
-                    });
-                }
-            }
-        }
-        this.logVerbose('Calculated execution steps: ', steps);
-        return steps;
-    }
-    async execute(_steps) {
-        this.runningUnits = [];
-        for (let i = this.runningStatus.startIndex; i < _steps.length; i++) {
-            if (this.killed)
-                break;
-            const scheduledStep = _steps[i];
-            const step = this.mapStep(scheduledStep);
-            await this.runningStatus.onStepStarted(i);
-            this.logDebug(`Executing step #${i + 1}/${_steps.length}`);
-            this.logVerbose(scheduledStep);
-            const errors = [];
-            let failedStep;
-            await Promise.all(step.units.map(async (unit) => {
-                if (this.runningStatus.isCompleted(unit.config.key))
-                    return;
-                let failed = false;
-                for (const phase of step.phases) {
-                    if (this.killed)
-                        break;
-                    if (this.runningStatus.runtimeParams.dryRun) {
-                        this.logInfo(`[${phase.key}] - ${unit.config.key}`);
-                        continue;
-                    }
-                    addItemToArray(this.runningUnits, unit);
-                    const dtCounter = timeCounter();
-                    try {
-                        this.logInfo(`Phase(${phase.name}) - Running - ${unit.config.key}`);
-                        if (typeof unit[phase.method] === 'function')
-                            await unit[phase.method].call(unit);
-                        let operationDuration = '';
-                        if (dtCounter.dt() > 1500)
-                            operationDuration = ` (${dtCounter.format('mm:ss')})`;
-                        this.logInfo(`Phase(${phase.name}) - Completed${operationDuration} - ${unit.config.key}`);
-                    }
-                    catch (error) {
-                        this.logError(`Phase(${phase.name}) - Error - ${unit.config.key}`, error);
-                        errors.push(new UnitPhaseException(error, unit, phase.key));
-                        failedStep = scheduledStep;
-                        this.killed = true;
-                        failed = true;
-                        break;
-                    }
-                    finally {
-                        removeItemFromArray(this.runningUnits, unit);
-                    }
-                }
-                if (!failed)
-                    await this.runningStatus.onUnitCompleted(unit.config.key);
-            }));
-            if (failedStep && errors.length) {
-                throw new PhaseAggregatedException(errors, failedStep);
-            }
-            await this.runningStatus.onStepEnded();
-        }
-        this.logInfo('All steps completed.');
-    }
-    break() {
-        this.killed = true;
-        return Promise.all(this.runningUnits.map(unit => unit.kill()));
-    }
-    mapStep(scheduledStep) {
-        const mappedPhases = scheduledStep.phases.map(phaseKey => {
-            const phase = this.keyToPhaseMap[phaseKey];
-            if (!phase)
-                throw new Error(`Phase '${phaseKey}' not found in PhaseManager.phases`);
-            return phase;
-        });
-        const mappedUnits = scheduledStep.units.map(unitKey => {
-            for (const layer of this.units) {
-                const unit = layer.find(u => u.config.key === unitKey);
-                if (unit)
-                    return unit;
-            }
-            throw new Error(`Unit '${unitKey}' not found in PhaseManager.units`);
-        });
-        return {
-            phases: mappedPhases,
-            units: mappedUnits
-        };
-    }
-}

package/v3/RunningStatusHandler.d.ts

@@ -1,18 +0,0 @@
-import { Logger } from '@nu-art/ts-common';
-import { BaiParams } from '../core/params/params.js';
-export declare class RunningStatusHandler extends Logger {
-    private isolated;
-    private readonly outputFolder;
-    private completedUnits;
-    runtimeParams: BaiParams;
-    startIndex: number;
-    constructor(outputFolder: string, runtimeParams: BaiParams);
-    init(): Promise<void>;
-    isolate(): RunningStatusHandler;
-    isCompleted(unitKey: string): boolean;
-    onUnitCompleted(unitKey: string): Promise<void>;
-    onStepEnded(): Promise<void>;
-    onStepStarted(index: number): Promise<void>;
-    private saveStatus;
-    load(): Promise<any>;
-}