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

package/{v3 → workspace}/Workspace.d.ts

@@ -1,25 +1,38 @@
-import { Constructor, Logger } from '@nu-art/ts-common';
-import { BaiParams } from '../core/params/params.js';
-import { UnitsMapper } from './UnitsMapper/UnitsMapper.js';
-import { UnitsDependencyMapper } from './UnitsDependencyMapper/UnitsDependencyMapper.js';
-import { BaseUnit, ProjectUnit, Unit_NodeProject } from './units/index.js';
+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';
 /**
- * Manages all units in the workspace, including:
- * - Scanned Units: All units discovered from workspace scan
- * - Active Units: Units selected for execution (compile/test/lint)
- * - Project Units: Active units + their transitive dependencies
+ * 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 _scannedUnits;
     private _projectUnits;
     private _activeUnits;
     private _projectUnitKeys;
     private unitsDependencyMapper?;
     private unitKeyToUnitMap;
-    /**
-     * All units discovered from the workspace scan
-     */
-    get scannedUnits(): ReadonlyArray<BaseUnit<any>>;
     /**
      * All project units (subset of scanned units that are ProjectUnits)
      */
@@ -38,6 +51,7 @@ export declare class Workspace extends Logger {
     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;
     /**
@@ -56,10 +70,11 @@ export declare class Workspace extends Logger {
      * 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?: Constructor<T>): T[];
+    getUnitsByKeys<T extends BaseUnit>(keys: string[], className?: AnyConstructor<T>): T[];
     /**
      * Get the root NodeProject unit
      */

package/{v3 → workspace}/Workspace.js

@@ -1,25 +1,36 @@
-import { _keys, arrayToMap, flatArray, Logger } from '@nu-art/ts-common';
-import { UnitsDependencyMapper } from './UnitsDependencyMapper/UnitsDependencyMapper.js';
-import { ProjectUnit, Unit_NodeProject } from './units/index.js';
+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';
 /**
- * Manages all units in the workspace, including:
- * - Scanned Units: All units discovered from workspace scan
- * - Active Units: Units selected for execution (compile/test/lint)
- * - Project Units: Active units + their transitive dependencies
+ * 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 {
-    _scannedUnits = [];
     _projectUnits = [];
     _activeUnits = [];
     _projectUnitKeys = [];
     unitsDependencyMapper;
     unitKeyToUnitMap = {};
-    /**
-     * All units discovered from the workspace scan
-     */
-    get scannedUnits() {
-        return this._scannedUnits;
-    }
     /**
      * All project units (subset of scanned units that are ProjectUnits)
      */
@@ -43,26 +54,25 @@ export class Workspace extends Logger {
      */
     async scanUnits(path, unitsMapper) {
         this.logDebug(`Resolving units from: ${path}`);
-        this._scannedUnits = await unitsMapper.resolveUnits(path);
-        Object.freeze(this._scannedUnits);
-        this.unitKeyToUnitMap = arrayToMap(this._scannedUnits, unit => unit.config.key);
-        this._projectUnits = this._scannedUnits.filter(unit => unit.isInstanceOf(ProjectUnit));
+        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 existingKeys = new Set(this._projectUnits.map(u => u.config.key));
-        const newUnits = projectUnits.filter(unit => !existingKeys.has(unit.config.key));
-        if (newUnits.length > 0) {
-            // Unfreeze, add, then refreeze
-            const current = [...this._projectUnits, ...newUnits];
-            this._projectUnits = current;
-            Object.freeze(this._projectUnits);
+        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 newUnits) {
+            for (const unit of projectUnits) {
+                this.logDebug(`Adding project unit: ${unit.config.key}`);
                 this.unitKeyToUnitMap[unit.config.key] = unit;
             }
         }
@@ -83,11 +93,11 @@ export class Workspace extends Logger {
      */
     deriveActiveAndProjectUnits(runtimeParams) {
         if (!this.unitsDependencyMapper) {
-            throw new Error('Dependency mapper must be initialized before deriving units. Call initializeDependencyMapper() first.');
+            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._scannedUnits)) {
+        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);
@@ -106,6 +116,8 @@ export class Workspace extends Logger {
             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);
@@ -125,20 +137,21 @@ export class Workspace extends Logger {
             projectUnits: this._projectUnitKeys
         };
     }
-    /**
-     * Get a unit by its key
-     */
-    getUnitByKey(key) {
-        return this.unitKeyToUnitMap[key];
+    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) {
+        if (className)
             return units.filter(unit => unit.isInstanceOf(className));
-        }
         return units;
     }
     /**

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,27 +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 projectUnitKeys;
-    private readonly keyToPhaseMap;
-    constructor(runningStatus: RunningStatusHandler, phases: Phase<any>[][], units: BaseUnit[][], activeUnits: string[], projectUnitKeys: string[]);
-    calculateExecutionSteps(): Promise<ScheduledStep[]>;
-    execute(_steps: ScheduledStep[]): Promise<void>;
-    break(): Promise<void[]>;
-    private mapStep;
-}

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>;
-}

package/v3/RunningStatusHandler.js

@@ -1,67 +0,0 @@
-import fs, { promises as _fs } from 'fs';
-import { __stringify, Logger } from '@nu-art/ts-common';
-export class RunningStatusHandler extends Logger {
-    isolated = false;
-    outputFolder;
-    // The completed units in the phase.. when running -con, these can be skipped
-    completedUnits = [];
-    runtimeParams;
-    startIndex = 0;
-    constructor(outputFolder, runtimeParams) {
-        super();
-        this.outputFolder = outputFolder;
-        this.runtimeParams = runtimeParams;
-    }
-    async init() {
-        if (!fs.existsSync(this.outputFolder))
-            await _fs.mkdir(this.outputFolder, { recursive: true });
-        if (this.runtimeParams.continue) {
-            const currentParams = this.runtimeParams;
-            this.startIndex = await this.load();
-            this.runtimeParams = Object.assign(currentParams, this.runtimeParams);
-        }
-    }
-    isolate() {
-        this.isolated = true;
-        return this;
-    }
-    isCompleted(unitKey) {
-        return this.completedUnits.includes(unitKey);
-    }
-    async onUnitCompleted(unitKey) {
-        this.logDebug(`On unit completed: ${unitKey}`);
-        this.completedUnits.push(unitKey);
-        await this.saveStatus();
-    }
-    async onStepEnded() {
-        this.logDebug(`On step ended successfully #${this.startIndex}`);
-        this.completedUnits = [];
-    }
-    async onStepStarted(index) {
-        this.startIndex = index;
-        this.logDebug(`Setting execution index to #${this.startIndex}`);
-        if (this.isolated)
-            return;
-        await this.saveStatus();
-    }
-    async saveStatus() {
-        await _fs.writeFile(`${this.outputFolder}/running-status.json`, __stringify({
-            index: this.startIndex,
-            runtimeParams: this.runtimeParams,
-            completedUnits: this.completedUnits
-        }, true));
-    }
-    async load() {
-        try {
-            const data = JSON.parse(await _fs.readFile(`${this.outputFolder}/running-status.json`, { encoding: 'utf-8' }));
-            this.startIndex = data.index;
-            this.completedUnits = data.completedUnits ?? [];
-            this.runtimeParams = data.runtimeParams;
-            return data.index;
-        }
-        catch (e) {
-            this.logError('Failed reading running status, using initial status', e);
-            return;
-        }
-    }
-}

package/v3/UnitsMapper/UnitsMapper.d.ts

@@ -1,21 +0,0 @@
-import { BaseUnit, ProjectUnit } from '../units/index.js';
-import { Logger } from '@nu-art/ts-common';
-import { UnitMapper_Base } from './resolvers/UnitMapper_Base.js';
-import { BaiParams } from '../../core/params/params.js';
-/**
- * This class will receive a path and will map the workspace packages and libs
- *
- * A lib will have rules to infer it, mainly from the package.json but also from existing files in the context of the node lib
- */
-export declare class UnitsMapper extends Logger {
-    private rules;
-    /**
-     * @param path - will always be a directory
-     * @param projectRoot - The path to the project root
-     * @param units - The project units derived from the file system
-     */
-    resolveUnits(path: string, projectRoot?: string, units?: BaseUnit<any>[]): Promise<BaseUnit<any, import("../units/BaseUnit.js").UnitRuntimeContext>[]>;
-    addRules<T extends BaseUnit<any>>(...rules: UnitMapper_Base<T>[]): this;
-    setRuntimeParams(runtimeParams: BaiParams): this;
-    assertUniqueKeys(units: ProjectUnit[]): void;
-}

package/v3/UnitsMapper/resolvers/UnitMapper_Base.d.ts

@@ -1,23 +0,0 @@
-import { AbsolutePath, Logger, RelativePath, StringMap, TypeValidator } from '@nu-art/ts-common';
-import { BaseUnit } from '../../units/index.js';
-import { BAI_Config } from '../../../core/types/index.js';
-import { BaiParams } from '../../../core/params/params.js';
-export type BaseUnitConfig = {
-    fullPath: AbsolutePath;
-    relativePath: RelativePath;
-    label: string;
-    key: string;
-    dependencies: StringMap;
-};
-export type UnitConfigJSON_Base = {
-    type: string;
-};
-export declare abstract class UnitMapper_Base<T extends BaseUnit<any>, ConfigJSON extends UnitConfigJSON_Base = UnitConfigJSON_Base> extends Logger {
-    protected validator: TypeValidator<ConfigJSON>;
-    protected baiConfig: BAI_Config;
-    protected runtimeParams: BaiParams;
-    protected constructor(validator: TypeValidator<ConfigJSON>);
-    setRuntimeParams(runtimeParams: BaiParams): void;
-    setConfig(config: BAI_Config): void;
-    abstract resolveUnit(path: string, root: string): Promise<T | undefined>;
-}

package/v3/UnitsMapper/resolvers/UnitMapper_Base.js

@@ -1,16 +0,0 @@
-import { Logger } from '@nu-art/ts-common';
-export class UnitMapper_Base extends Logger {
-    validator;
-    baiConfig;
-    runtimeParams;
-    constructor(validator) {
-        super();
-        this.validator = validator;
-    }
-    setRuntimeParams(runtimeParams) {
-        this.runtimeParams = runtimeParams;
-    }
-    setConfig(config) {
-        this.baiConfig = config;
-    }
-}

package/v3/UnitsMapper/resolvers/UnitMapper_FirebaseFunction.js

@@ -1,66 +0,0 @@
-import { tsValidate_OptionalArray, tsValidateAnyString, tsValidateBoolean, tsValidateDynamicObject, tsValidateOptionalAnyNumber, tsValidateOptionalAnyString, tsValidateValue } from '@nu-art/ts-common';
-import { UnitMapper_Node } from './UnitMapper_Node.js';
-import { Unit_FirebaseFunctionsApp } from '../../units/firebase/Unit_FirebaseFunctionsApp.js';
-import { resolve } from 'path';
-import { BaiParam_SetEnv } from '../../../core/params/params.js';
-const valuesValidator = {
-    defaultConfig: tsValidateOptionalAnyString,
-    envConfig: tsValidateOptionalAnyString,
-    identityAccount: tsValidateOptionalAnyString,
-    projectId: tsValidateAnyString,
-    isLocal: tsValidateBoolean(false),
-};
-export class UnitMapper_FirebaseFunction_Class extends UnitMapper_Node {
-    static tsValidator_FirebaseFunction = {
-        type: tsValidateValue(['firebase-function']),
-        ignore: tsValidate_OptionalArray(tsValidateOptionalAnyString),
-        envs: tsValidateDynamicObject(valuesValidator, tsValidateAnyString),
-        debugPort: tsValidateOptionalAnyNumber,
-        basePort: tsValidateOptionalAnyNumber,
-        sslKey: tsValidateOptionalAnyString,
-        sslCert: tsValidateOptionalAnyString,
-        ...UnitMapper_Node.tsValidator_Node,
-    };
-    constructor() {
-        super(UnitMapper_FirebaseFunction_Class.tsValidator_FirebaseFunction);
-    }
-    async resolveNodeUnit(context) {
-        const outputDir = context.packageJson.publishConfig?.directory;
-        const env = this.runtimeParams[BaiParam_SetEnv.keyName];
-        let envUnitConfig = context.packageJson.unitConfig.envs[env];
-        if (!envUnitConfig) {
-            this.logWarning(`Missing EnvConfig in unit ${context.baseConfig.key}`);
-            envUnitConfig = {
-                identityAccount: '',
-                defaultConfig: '',
-                envConfig: '',
-                projectId: '',
-                isLocal: true
-            };
-            // throw new ImplementationMissingException(`Missing configuration for env: ${env}`);
-        }
-        const envConfig = {
-            identityAccount: envUnitConfig.identityAccount,
-            defaultConfig: envUnitConfig.defaultConfig,
-            envConfig: envUnitConfig.envConfig,
-            projectId: envUnitConfig.projectId,
-            isLocal: envUnitConfig.isLocal ?? env === 'local'
-        };
-        const { type, ...unitConfig } = context.packageJson.unitConfig;
-        return new Unit_FirebaseFunctionsApp({
-            ...context.baseConfig,
-            ...Unit_FirebaseFunctionsApp.DefaultConfig_FirebaseFunction,
-            ...unitConfig,
-            envConfig,
-            isTopLevelApp: true,
-            hasSelfHotReload: unitConfig.hasSelfHotReload ?? false,
-            packageJson: context.packageJson,
-            customESLintConfig: context.customESLintConfig,
-            customTSConfig: context.customTSConfig,
-            output: resolve(context.baseConfig.fullPath, outputDir ?? Unit_FirebaseFunctionsApp.DefaultConfig_FirebaseFunction.output),
-            sslCert: resolve(context.baseConfig.fullPath, unitConfig.sslCert ?? Unit_FirebaseFunctionsApp.DefaultConfig_FirebaseFunction.sslCert),
-            sslKey: resolve(context.baseConfig.fullPath, unitConfig.sslKey ?? Unit_FirebaseFunctionsApp.DefaultConfig_FirebaseFunction.sslKey),
-        });
-    }
-}
-export const UnitMapper_FirebaseFunction = new UnitMapper_FirebaseFunction_Class();

package/v3/core/FilesCache.d.ts

@@ -1,7 +0,0 @@
-export declare const FilesCache: {
-    clear: () => {};
-    load: {
-        json: <T>(pathToFile: string) => Promise<T>;
-        text: (pathToFile: string) => Promise<string>;
-    };
-};

package/v3/core/FilesCache.js

@@ -1,33 +0,0 @@
-import { ImplementationMissingException } from '@nu-art/ts-common';
-import { promises as fs } from 'fs';
-let cachedFiles = {};
-const readFile = async (path) => {
-    try {
-        const fileStat = await fs.stat(path);
-        if (fileStat.isFile())
-            return await fs.readFile(path, 'utf-8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            throw new ImplementationMissingException(`file does not exist: ${path}`);
-        throw error; // rethrow other errors
-    }
-    throw new ImplementationMissingException(`expected a file at: ${path}`);
-};
-export const FilesCache = {
-    clear: () => cachedFiles = {},
-    load: {
-        json: async (pathToFile) => {
-            const json = cachedFiles[pathToFile];
-            if (!json)
-                cachedFiles[pathToFile] = Object.freeze(JSON.parse(await readFile(pathToFile)));
-            return cachedFiles[pathToFile];
-        },
-        text: async (pathToFile) => {
-            const fileContent = cachedFiles[pathToFile];
-            if (!fileContent)
-                cachedFiles[pathToFile] = await readFile(pathToFile);
-            return cachedFiles[pathToFile];
-        }
-    }
-};

package/v3/phase/types.d.ts

@@ -1,10 +0,0 @@
-import { BaiParams } from '../../core/params/params.js';
-export type Phase<PhaseMethod extends string> = {
-    key: string;
-    name: string;
-    method: PhaseMethod;
-    filter?: (params: BaiParams) => boolean;
-    terminateAfterPhase?: boolean;
-    dependencyPhase?: Phase<string>[];
-    unitCategory?: "project" | "active";
-};