@noego/ioc 0.0.7 → 0.0.9

package/dist/framework/implementation/Container.cjs

@@ -0,0 +1,342 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Container_exports = {};
+__export(Container_exports, {
+  Container: () => Container,
+  createContainer: () => createContainer,
+  isPromise: () => isPromise
+});
+module.exports = __toCommonJS(Container_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_LoadAs = require("./LoadAs.cjs");
+var import_Parameter = require("./Parameter.cjs");
+var import_ContainerErrors = require("../errors/ContainerErrors.cjs");
+var import_DecoratorSupport = require("./DecoratorSupport.cjs");
+var ContainerRouting = /* @__PURE__ */ ((ContainerRouting2) => {
+  ContainerRouting2["FUNCTIONAL"] = "FUNCTIONAL";
+  ContainerRouting2["CLASS"] = "CLASS";
+  return ContainerRouting2;
+})(ContainerRouting || {});
+class Container {
+  constructor() {
+    // Routing and definition maps
+    this._routing = /* @__PURE__ */ new Map();
+    this._functionDefinition = /* @__PURE__ */ new Map();
+    this._classDefinition = /* @__PURE__ */ new Map();
+    // Storage maps
+    this._functionStorageSingleton = /* @__PURE__ */ new Map();
+    this._functionStorageScoped = /* @__PURE__ */ new Map();
+    this._classStorageSingleton = /* @__PURE__ */ new Map();
+    this._classStorageScoped = /* @__PURE__ */ new Map();
+  }
+  // Registration methods
+  registerClass(classDefinition, options) {
+    if (typeof classDefinition !== "function" || !classDefinition.prototype) {
+      console.warn(`[IOC] Attempted to register non-class: ${String(classDefinition)}`);
+      return;
+    }
+    this.clearDefinitions(classDefinition);
+    this._routing.set(classDefinition, "CLASS" /* CLASS */);
+    if (options && Object.keys(options).length > 0) {
+      this._classDefinition.set(classDefinition, options);
+    } else {
+    }
+  }
+  registerFunction(label, func, options = {}) {
+    this.clearDefinitions(label);
+    this._routing.set(label, "FUNCTIONAL" /* FUNCTIONAL */);
+    this._functionDefinition.set(label, { function: func, options });
+  }
+  // Instance resolution methods - Simplify to just call loadInstance
+  instance(classDefinition, params = []) {
+    if (typeof classDefinition !== "function" || !classDefinition.prototype) {
+      throw new import_ContainerErrors.NotAClassDefinitionError(`Cannot resolve instance for non-class: ${String(classDefinition)}`);
+    }
+    return this.loadInstance(classDefinition, params);
+  }
+  get(label, param = []) {
+    return this.loadInstance(label, param);
+  }
+  extend() {
+    const childContainer = createContainer();
+    childContainer._routing = new Map(this._routing);
+    childContainer._functionDefinition = new Map(this._functionDefinition);
+    childContainer._classDefinition = new Map(this._classDefinition);
+    childContainer._functionStorageSingleton = this._functionStorageSingleton;
+    childContainer._classStorageSingleton = this._classStorageSingleton;
+    return childContainer;
+  }
+  // Private helper methods
+  clearDefinitions(label) {
+    this._routing.delete(label);
+    this._functionDefinition.delete(label);
+    if (typeof label === "function") {
+      this._classDefinition.delete(label);
+    }
+  }
+  // Checks if the label is *currently* registered as a class
+  isRegisteredAsClass(label) {
+    return this._routing.get(label) === "CLASS" /* CLASS */;
+  }
+  // Checks if the label is *currently* registered as a function
+  isRegisteredAsFunction(label) {
+    return this._routing.get(label) === "FUNCTIONAL" /* FUNCTIONAL */;
+  }
+  hasInstance(label) {
+    const storageType = this.getStorageType(label);
+    if (!storageType) {
+      return false;
+    }
+    const isClass = this.isClassType(label);
+    if (isClass) {
+      return storageType === "singleton" ? this._classStorageSingleton.has(label) : this._classStorageScoped.has(label);
+    } else {
+      return storageType === "singleton" ? this._functionStorageSingleton.has(label) : this._functionStorageScoped.has(label);
+    }
+  }
+  // Helper to determine if something should be treated as a class (registered or decorated)
+  isClassType(label) {
+    if (this.isRegisteredAsClass(label)) {
+      return true;
+    }
+    if (typeof label === "function" && label.prototype && !this.isRegisteredAsFunction(label)) {
+      return (0, import_DecoratorSupport.getComponentOptions)(label) !== null;
+    }
+    return false;
+  }
+  getInstance(label) {
+    const storageType = this.getStorageType(label);
+    if (!storageType) {
+      console.error(`[IOC GetInstance] Attempted to get instance for non-stored type: ${String(label)}`);
+      throw new import_ContainerErrors.InstanceNotCreatedError();
+    }
+    const isClass = this.isClassType(label);
+    if (isClass) {
+      return storageType === "singleton" ? this._classStorageSingleton.get(label) : this._classStorageScoped.get(label);
+    } else {
+      return storageType === "singleton" ? this._functionStorageSingleton.get(label) : this._functionStorageScoped.get(label);
+    }
+  }
+  setInstance(label, instance, storageType) {
+    const isClass = this.isClassType(label);
+    if (isClass) {
+      if (storageType === "singleton") {
+        this._classStorageSingleton.set(label, instance);
+      } else if (storageType == "scoped") {
+        this._classStorageScoped.set(label, instance);
+      }
+    } else {
+      if (storageType === "singleton") {
+        this._functionStorageSingleton.set(label, instance);
+      } else if (storageType === "scoped") {
+        this._functionStorageScoped.set(label, instance);
+      }
+    }
+  }
+  getStorageType(label) {
+    let manualLoadAs;
+    let decoratorScope;
+    const isPotentialClass = typeof label === "function" && label.prototype;
+    if (this.isRegisteredAsClass(label)) {
+      manualLoadAs = this._classDefinition.get(label)?.loadAs;
+    } else if (this.isRegisteredAsFunction(label)) {
+      manualLoadAs = this._functionDefinition.get(label)?.options?.loadAs;
+    }
+    if (isPotentialClass && !this.isRegisteredAsFunction(label)) {
+      decoratorScope = (0, import_DecoratorSupport.getScope)(label);
+    }
+    const finalScope = manualLoadAs ?? decoratorScope ?? import_LoadAs.LoadAs.Transient;
+    if (finalScope === import_LoadAs.LoadAs.Singleton) {
+      return "singleton";
+    } else if (finalScope === import_LoadAs.LoadAs.Scoped) {
+      return "scoped";
+    } else {
+      return "transient";
+    }
+  }
+  // Central resolution logic
+  async loadInstance(label, params = [], resolutionChain = []) {
+    const currentLabelStr = typeof label === "function" && label.name ? label.name : String(label);
+    if (resolutionChain.includes(currentLabelStr)) {
+      console.error(`[IOC LoadInstance] Circular dependency detected: ${[...resolutionChain, currentLabelStr].join(" -> ")}`);
+      throw new import_ContainerErrors.CircularDependencyError([...resolutionChain, currentLabelStr]);
+    }
+    const nextResolutionChain = [...resolutionChain, currentLabelStr];
+    if (label instanceof import_Parameter.Parameter) {
+      try {
+        return Promise.resolve(this.resolveParameterValue(label, [...params]));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    if (this.isRegisteredAsClass(label)) {
+      return this.loadClassInstance(label, params, nextResolutionChain);
+    }
+    if (this.isRegisteredAsFunction(label)) {
+      return this.loadFunctionInstance(label, params, nextResolutionChain);
+    }
+    if (typeof label === "function" && label.prototype) {
+      const componentOptions = (0, import_DecoratorSupport.getComponentOptions)(label);
+      if (componentOptions !== null) {
+        if (!this._routing.has(label)) {
+          this._routing.set(label, "CLASS" /* CLASS */);
+        }
+        return this.loadClassInstance(label, params, nextResolutionChain);
+      }
+    }
+    console.error(`[IOC LoadInstance] Dependency not found and cannot be resolved: ${currentLabelStr}`);
+    throw new import_ContainerErrors.DependencyNotFoundError(currentLabelStr);
+  }
+  resolveParameterValue(param, params) {
+    const valueContainer = [...params].reverse().find((p) => p.belongsTo(param));
+    if (!valueContainer) {
+      throw new import_ContainerErrors.ParameterNotFoundError(param.toString());
+    }
+    return valueContainer.value;
+  }
+  loadClassInstance(classDefinition, params, resolutionChain) {
+    const storageType = this.getStorageType(classDefinition);
+    const className = classDefinition.name || "[Anonymous Class]";
+    if (storageType && this.hasInstance(classDefinition)) {
+      const instance = this.getInstance(classDefinition);
+      return instance;
+    }
+    const manualOptions = this._classDefinition.get(classDefinition);
+    let dependenciesToResolve;
+    if (manualOptions?.param && Array.isArray(manualOptions.param)) {
+      dependenciesToResolve = manualOptions.param;
+    } else {
+      dependenciesToResolve = (0, import_DecoratorSupport.getResolvedDependencies)(classDefinition);
+    }
+    const paramsCopy = [...params];
+    const resolutionPromises = dependenciesToResolve.map(
+      (dependencyIdentifier) => this.loadInstance(dependencyIdentifier, paramsCopy, resolutionChain)
+      // Recursive call handles auto-registration
+    );
+    let finalInstance = Promise.all(resolutionPromises).catch((error) => {
+      console.error(`[IOC LoadClass] Failed to resolve one or more dependencies for ${className}:`, error);
+      if (storageType && this.isRegisteredAsClass(classDefinition)) {
+        if (storageType === "singleton") this._classStorageSingleton.delete(classDefinition);
+        if (storageType === "scoped") this._classStorageScoped.delete(classDefinition);
+      }
+      throw error;
+    }).then(async (resolvedDependencies) => {
+      let instancePromise;
+      if (storageType && !this.hasInstance(classDefinition)) {
+        instancePromise = (async () => {
+          try {
+            const instance = new classDefinition(...resolvedDependencies);
+            this.setInstance(classDefinition, instance, storageType);
+            return instance;
+          } catch (err) {
+            console.error(`[IOC LoadClass] Error during instantiation of ${className}: ${err.message}`, err.stack);
+            if (storageType === "singleton") this._classStorageSingleton.delete(classDefinition);
+            if (storageType === "scoped") this._classStorageScoped.delete(classDefinition);
+            throw err;
+          }
+        })();
+        this.setInstance(classDefinition, instancePromise, storageType);
+      } else {
+        instancePromise = (async () => {
+          try {
+            const instance = new classDefinition(...resolvedDependencies);
+            return instance;
+          } catch (err) {
+            console.error(`[IOC LoadClass] Error during instantiation of transient ${className}: ${err.message}`, err.stack);
+            throw err;
+          }
+        })();
+      }
+      return await instancePromise;
+    });
+    if (storageType && storageType !== "transient") {
+      this.setInstance(classDefinition, finalInstance, storageType);
+    }
+    return finalInstance;
+  }
+  loadFunctionInstance(funcLabel, params, resolutionChain) {
+    const functionConfig = this._functionDefinition.get(funcLabel);
+    const storageType = this.getStorageType(funcLabel);
+    const labelStr = String(funcLabel);
+    if (storageType && this.hasInstance(funcLabel)) {
+      const instance = this.getInstance(funcLabel);
+      return instance;
+    }
+    const ioc_func = functionConfig.function;
+    const options = functionConfig.options;
+    const dependenciesToResolve = options?.param || [];
+    const paramsCopy = [...params];
+    const resolutionPromises = dependenciesToResolve.map(
+      (dependencyIdentifier) => this.loadInstance(dependencyIdentifier, paramsCopy, resolutionChain)
+    );
+    let finalInstance = Promise.all(resolutionPromises).catch((error) => {
+      console.error(`[IOC LoadFunc] Failed to resolve dependencies for function ${labelStr}:`, error);
+      if (storageType && this.isRegisteredAsFunction(funcLabel)) {
+        if (storageType === "singleton") this._functionStorageSingleton.delete(funcLabel);
+        if (storageType === "scoped") this._functionStorageScoped.delete(funcLabel);
+      }
+      throw error;
+    }).then(async (resolvedArgs) => {
+      let instancePromise;
+      if (storageType && !this.hasInstance(funcLabel)) {
+        instancePromise = (async () => {
+          try {
+            const result = await ioc_func.apply(null, resolvedArgs);
+            this.setInstance(funcLabel, result, storageType);
+            return result;
+          } catch (err) {
+            console.error(`[IOC LoadFunc] Error executing function ${labelStr}: ${err.message}`, err.stack);
+            if (storageType === "singleton") this._functionStorageSingleton.delete(funcLabel);
+            if (storageType === "scoped") this._functionStorageScoped.delete(funcLabel);
+            throw err;
+          }
+        })();
+        this.setInstance(funcLabel, instancePromise, storageType);
+      } else {
+        instancePromise = (async () => {
+          try {
+            const result = await ioc_func.apply(null, resolvedArgs);
+            return result;
+          } catch (err) {
+            console.error(`[IOC LoadFunc] Error executing transient function ${labelStr}: ${err.message}`, err.stack);
+            throw err;
+          }
+        })();
+      }
+      return await instancePromise;
+    });
+    if (storageType && storageType !== "transient") {
+      this.setInstance(funcLabel, finalInstance, storageType);
+    }
+    return finalInstance;
+  }
+}
+function isPromise(obj) {
+  return !!obj && typeof obj.then === "function";
+}
+function createContainer() {
+  return new Container();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Container,
+  createContainer,
+  isPromise
+});
+//# sourceMappingURL=Container.cjs.map

package/dist/framework/implementation/Container.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../framework/implementation/Container.ts"],"sourcesContent":["import 'reflect-metadata'; // Ensure polyfill is loaded conceptually\nimport type { ContainerOptions, IContainerClient, IContainerFunctionDefinition, IContainerSetup } from \"../interface/Container.cjs\";\nimport { LoadAs } from \"./LoadAs.cjs\";\nimport { Parameter } from \"./Parameter.cjs\";\nimport type { ParameterValue } from \"./Parameter.cjs\";\nimport { NotAClassDefinitionError, ParameterNotFoundError, DependencyNotFoundError, InstanceNotCreatedError, CircularDependencyError } from \"../errors/ContainerErrors.cjs\";\nimport {\n    getScope,\n    getComponentOptions, // Use helper\n    getResolvedDependencies // Use helper\n} from './DecoratorSupport'; // Assume helpers exist or create them\n\nenum ContainerRouting {\n    FUNCTIONAL = \"FUNCTIONAL\",\n    CLASS = \"CLASS\"\n    // No need for COMPONENT route, just check metadata if CLASS/FUNCTIONAL fails\n}\n\ntype StorageType = 'singleton' | 'scoped' | 'transient';\n\nexport class Container implements IContainerClient, IContainerSetup {\n    // Routing and definition maps\n    private _routing: Map<any, ContainerRouting> = new Map();\n    private _functionDefinition: Map<any, IContainerFunctionDefinition> = new Map();\n    private _classDefinition: Map<Function, Partial<ContainerOptions>> = new Map();\n\n    // Storage maps\n    private _functionStorageSingleton: Map<any, any> = new Map();\n    private _functionStorageScoped: Map<any, any> = new Map();\n    private _classStorageSingleton: Map<Function, any> = new Map();\n    private _classStorageScoped: Map<Function, any> = new Map();\n\n    // Registration methods\n    registerClass<T>(classDefinition: new (...args: any[]) => T, options?: Partial<ContainerOptions>): void {\n        // Basic validation\n        if (typeof classDefinition !== 'function' || !classDefinition.prototype) {\n             console.warn(`[IOC] Attempted to register non-class: ${String(classDefinition)}`);\n             // Optional: throw error instead?\n             // throw new NotAClassDefinitionError(`Attempted to register non-class: ${String(classDefinition)}`);\n             return; // Don't proceed if not a class constructor\n        }\n\n        // Always clear previous definitions for this exact class constructor\n        this.clearDefinitions(classDefinition);\n\n        // Always set the routing type so 'isClassDefinition' works\n        this._routing.set(classDefinition, ContainerRouting.CLASS);\n\n        // Store manual options *only if they are actually provided and have content*\n        if (options && Object.keys(options).length > 0) {\n            this._classDefinition.set(classDefinition, options);\n            // console.log(`[IOC RegClass] Manually registered ${classDefinition.name} with options:`, options);\n        } else {\n            // console.log(`[IOC RegClass] Manually registered ${classDefinition.name} with no specific options (will use decorators if present).`);\n             // If no options are provided, we don't store anything in _classDefinition,\n             // effectively clearing any previous manual config and letting decorators take over if present.\n        }\n    }\n\n    registerFunction<T extends (...arg: any[]) => any>(label: any, func: T, options: Partial<ContainerOptions> = {} as any): void {\n        this.clearDefinitions(label);\n        this._routing.set(label, ContainerRouting.FUNCTIONAL);\n        this._functionDefinition.set(label, { function: func, options });\n        // console.log(`[IOC RegFunc] Registered function with label ${String(label)} and options:`, options);\n    }\n\n    // Instance resolution methods - Simplify to just call loadInstance\n    instance<T, Args extends any[]>(classDefinition: new (...args: Args) => T, params: ParameterValue<any>[] = []): Promise<T> {\n        // Basic check upfront\n        if (typeof classDefinition !== 'function' || !classDefinition.prototype) {\n             throw new NotAClassDefinitionError(`Cannot resolve instance for non-class: ${String(classDefinition)}`);\n        }\n        return this.loadInstance(classDefinition, params) as Promise<T>;\n    }\n\n    get<T>(label: any, param: ParameterValue<any>[] = []): Promise<T> | T {\n        // Just delegate to loadInstance, which handles routing and auto-registration\n        return this.loadInstance(label, param);\n    }\n\n    extend(): IContainerClient & IContainerSetup {\n        const childContainer = createContainer() as Container;\n\n        // Copy routing and definition maps (share the registration knowledge)\n        childContainer._routing = new Map(this._routing);\n        childContainer._functionDefinition = new Map(this._functionDefinition);\n        childContainer._classDefinition = new Map(this._classDefinition);\n\n        // Share singleton storage (singletons are shared across all containers)\n        childContainer._functionStorageSingleton = this._functionStorageSingleton;\n        childContainer._classStorageSingleton = this._classStorageSingleton;\n\n        // Do NOT share scoped storage (new container = new scope)\n        // Child gets its own empty scoped storage\n\n        // console.log('[IOC Extend] Created child container.');\n        return childContainer;\n    }\n\n    // Private helper methods\n    private clearDefinitions(label: any): void {\n        this._routing.delete(label);\n        this._functionDefinition.delete(label);\n        // Only delete from classDefinition if the label is actually a function constructor\n        if (typeof label === 'function') {\n            this._classDefinition.delete(label);\n        }\n    }\n\n    // Checks if the label is *currently* registered as a class\n    private isRegisteredAsClass(label: any): boolean {\n        return this._routing.get(label) === ContainerRouting.CLASS;\n    }\n\n     // Checks if the label is *currently* registered as a function\n     private isRegisteredAsFunction(label: any): boolean {\n         return this._routing.get(label) === ContainerRouting.FUNCTIONAL;\n     }\n\n\n    private hasInstance(label: any): boolean {\n        const storageType = this.getStorageType(label); // This checks decorators if needed\n\n        if (!storageType) {\n            // Transient instances are never stored\n            return false;\n        }\n\n        // Determine if it's treated as a class (registered or decorated) *after* getting type\n        const isClass = this.isClassType(label); // Use a helper that checks routing OR decorator\n\n        if (isClass) {\n            return storageType === 'singleton'\n                ? this._classStorageSingleton.has(label)\n                : this._classStorageScoped.has(label);\n        } else { // Must be a function if not a class\n            return storageType === 'singleton'\n                ? this._functionStorageSingleton.has(label)\n                : this._functionStorageScoped.has(label);\n        }\n    }\n\n     // Helper to determine if something should be treated as a class (registered or decorated)\n     private isClassType(label: any): boolean {\n         if (this.isRegisteredAsClass(label)) {\n             return true;\n         }\n         // If not explicitly registered as a class, check if it's a function with @Component\n         if (typeof label === 'function' && label.prototype && !this.isRegisteredAsFunction(label)) {\n              return getComponentOptions(label) !== null;\n         }\n         return false;\n     }\n\n    private getInstance(label: any): any {\n        const storageType = this.getStorageType(label); // Checks decorators if needed\n\n         if (!storageType) {\n             // This should ideally not be reached if called after hasInstance check\n             console.error(`[IOC GetInstance] Attempted to get instance for non-stored type: ${String(label)}`);\n             throw new InstanceNotCreatedError();\n         }\n\n        const isClass = this.isClassType(label); // Check routing OR decorator\n\n        if (isClass) {\n            return storageType === 'singleton'\n                ? this._classStorageSingleton.get(label)\n                : this._classStorageScoped.get(label);\n        } else { // Must be a function\n            return storageType === 'singleton'\n                ? this._functionStorageSingleton.get(label)\n                : this._functionStorageScoped.get(label);\n        }\n    }\n\n    private setInstance(label: any, instance: any, storageType?: StorageType): void { // Made storageType non-optional\n        const isClass = this.isClassType(label); // Determine type based on routing OR decorator\n\n        if (isClass) {\n            if (storageType === 'singleton') {\n                this._classStorageSingleton.set(label, instance);\n            } else if (storageType == 'scoped'){ // storageType === 'scoped'\n                this._classStorageScoped.set(label, instance);\n            }\n        } else { // Must be a function\n            if (storageType === 'singleton') {\n                this._functionStorageSingleton.set(label, instance);\n            } else if(storageType === \"scoped\"){ // storageType === 'scoped'\n                this._functionStorageScoped.set(label, instance);\n            }\n        }\n    }\n\n    private getStorageType(label: any): StorageType {\n        let manualLoadAs: LoadAs | undefined;\n        let decoratorScope: LoadAs | undefined;\n        const isPotentialClass = typeof label === 'function' && label.prototype;\n\n        // Get manual registration options if available\n        if (this.isRegisteredAsClass(label)) { // Use helper\n            manualLoadAs = this._classDefinition.get(label)?.loadAs;\n        } else if (this.isRegisteredAsFunction(label)) { // Use helper\n            manualLoadAs = this._functionDefinition.get(label)?.options?.loadAs;\n        }\n\n        // Get decorator scope only if it's potentially a class *and not explicitly registered as a function*\n        if (isPotentialClass && !this.isRegisteredAsFunction(label)) {\n            decoratorScope = getScope(label); // Uses getComponentOptions internally\n        }\n\n        // Determine final scope: Manual > Decorator > Default (Transient)\n        const finalScope = manualLoadAs ?? decoratorScope ?? LoadAs.Transient;\n\n        if (finalScope === LoadAs.Singleton) {\n            return 'singleton';\n        } else if (finalScope === LoadAs.Scoped) {\n            return 'scoped';\n        }else{\n            return 'transient'; // Transient\n        }\n    }\n\n    // Central resolution logic\n    protected async loadInstance(\n        label: any,\n        params: ParameterValue<any>[] = [],\n        resolutionChain: string[] = [] // Track resolution path\n    ): Promise<any> {\n\n        // --- Circular Dependency Check ---\n        const currentLabelStr = (typeof label === 'function' && label.name) ? label.name : String(label);\n        if (resolutionChain.includes(currentLabelStr)) {\n            console.error(`[IOC LoadInstance] Circular dependency detected: ${[...resolutionChain, currentLabelStr].join(' -> ')}`);\n            throw new CircularDependencyError([...resolutionChain, currentLabelStr]);\n        }\n        const nextResolutionChain = [...resolutionChain, currentLabelStr];\n        // --- End Circular Dependency Check ---\n\n        // --- Handle Parameters ---\n        if (label instanceof Parameter) {\n            try {\n                // Pass a *copy* of params to avoid side effects in resolveParameterValue\n                return Promise.resolve(this.resolveParameterValue(label, [...params]));\n            } catch (e) {\n                // console.error(`[IOC LoadInstance] Error resolving parameter ${param.toString()}:`, e);\n                return Promise.reject(e);\n            }\n        }\n        // --- End Handle Parameters ---\n\n\n        // --- Check Explicit Registrations ---\n        if (this.isRegisteredAsClass(label)) {\n            // console.log(`[IOC LoadInstance] Resolving explicitly registered class: ${currentLabelStr}`);\n            return this.loadClassInstance(label, params, nextResolutionChain);\n        }\n        if (this.isRegisteredAsFunction(label)) {\n             // console.log(`[IOC LoadInstance] Resolving explicitly registered function: ${currentLabelStr}`);\n            return this.loadFunctionInstance(label, params, nextResolutionChain);\n        }\n        // --- End Check Explicit Registrations ---\n\n\n        // --- Attempt Auto-Registration/Resolution for Decorated Classes ---\n        if (typeof label === 'function' && label.prototype) {\n            const componentOptions = getComponentOptions(label); // Check for @Component\n            if (componentOptions !== null) {\n                 // console.log(`[IOC LoadInstance] Auto-resolving @Component class: ${currentLabelStr}`);\n                // Set routing *now* so subsequent internal checks work correctly\n                if (!this._routing.has(label)) { // Only set if not already set\n                     this._routing.set(label, ContainerRouting.CLASS);\n                     // console.log(`[IOC LoadInstance] Set routing for auto-resolved class: ${currentLabelStr}`);\n                }\n                // Proceed to load it as a class\n                return this.loadClassInstance(label, params, nextResolutionChain);\n            }\n        }\n        // --- End Auto-Registration ---\n\n\n        // --- Dependency Not Found ---\n        console.error(`[IOC LoadInstance] Dependency not found and cannot be resolved: ${currentLabelStr}`);\n        throw new DependencyNotFoundError(currentLabelStr);\n    }\n\n\n    private resolveParameterValue(param: Parameter, params: ParameterValue<any>[]): any { // No mutation\n        // Find the *last* provided value for the parameter\n        const valueContainer = [...params].reverse().find((p) => p.belongsTo(param));\n        if (!valueContainer) {\n             // console.error(`[IOC ResolveParam] Parameter not found: ${param.toString()}`);\n            throw new ParameterNotFoundError(param.toString());\n        }\n        // console.log(`[IOC ResolveParam] Resolved parameter ${param.toString()}`);\n        return valueContainer.value;\n    }\n\n    private loadClassInstance(\n        classDefinition: any, // Should be a class constructor here\n        params: ParameterValue<any>[],\n        resolutionChain: string[]\n    ): Promise<any> {\n        const storageType = this.getStorageType(classDefinition);\n        const className = classDefinition.name || '[Anonymous Class]';\n\n        // Check storage first (handle stored promises)\n        if (storageType && this.hasInstance(classDefinition)) {\n            const instance = this.getInstance(classDefinition);\n            // console.log(`[IOC LoadClass] Found existing ${storageType} instance for ${className}. IsPromise: ${isPromise(instance)}`);\n            return instance\n        }\n         // console.log(`[IOC LoadClass] Creating new ${storageType || 'transient'} instance for ${className}`);\n\n        // --- Determine Dependencies ---\n        const manualOptions = this._classDefinition.get(classDefinition) as ContainerOptions | undefined;\n        let dependenciesToResolve: any[];\n\n        if (manualOptions?.param && Array.isArray(manualOptions.param)) {\n            dependenciesToResolve = manualOptions.param;\n            // console.log(`[IOC LoadClass] Using manual dependencies for ${className}`);\n        } else {\n            // Use decorator-derived dependencies\n            dependenciesToResolve = getResolvedDependencies(classDefinition);\n             // console.log(`[IOC LoadClass] Using decorator/reflected dependencies for ${className}:`, dependenciesToResolve.map(d => typeof d === 'function' ? d.name : String(d)));\n        }\n        // --- End Determine Dependencies ---\n\n\n        // --- Resolve Dependencies ---\n        // Create a *copy* of params to pass down for dependency resolution\n        const paramsCopy = [...params];\n        const resolutionPromises = dependenciesToResolve.map(dependencyIdentifier =>\n            this.loadInstance(dependencyIdentifier, paramsCopy, resolutionChain) // Recursive call handles auto-registration\n        );\n\n        let finalInstance = Promise.all(resolutionPromises)\n        .catch((error)=>{\n            console.error(`[IOC LoadClass] Failed to resolve one or more dependencies for ${className}:`, error);\n            // Clean up potential partially stored promise if this was going to be singleton/scoped\n            if (storageType && this.isRegisteredAsClass(classDefinition)) { // Check if it was actually *being* stored\n                if (storageType === 'singleton') this._classStorageSingleton.delete(classDefinition);\n                if (storageType === 'scoped') this._classStorageScoped.delete(classDefinition);\n            }\n            throw error; // Re-throw dependency resolution error\n        }).then(async(resolvedDependencies)=>{\n            // --- Instantiate Class ---\n            // Store the promise *before* starting instantiation for concurrent requests\n            let instancePromise: Promise<any> | undefined;\n            if (storageType && !this.hasInstance(classDefinition)) { // Check again in case of race condition?\n                // Create the promise wrapper immediately\n                instancePromise = (async () => {\n                    try {\n                        // console.log(`[IOC LoadClass] Instantiating ${className} with ${resolvedDependencies.length} args.`);\n                        const instance = new classDefinition(...resolvedDependencies);\n                        // Overwrite the stored promise with the actual instance *after* it's created\n                        this.setInstance(classDefinition, instance, storageType); // Use the correct storageType\n                        // console.log(`[IOC LoadClass] Stored actual ${storageType} instance for ${className}`);\n                        return instance;\n                    } catch (err: any) {\n                        console.error(`[IOC LoadClass] Error during instantiation of ${className}: ${err.message}`, err.stack);\n                        // Clean up the stored promise on failure\n                        if (storageType === 'singleton') this._classStorageSingleton.delete(classDefinition);\n                        if (storageType === 'scoped') this._classStorageScoped.delete(classDefinition);\n                        throw err; // Re-throw instantiation error\n                    }\n                })();\n                 // console.log(`[IOC LoadClass] Storing promise for concurrent requests (${storageType}) for ${className}`);\n                this.setInstance(classDefinition, instancePromise, storageType);\n            } else {\n                 // If already has instance (from storage check) or is transient, just instantiate directly\n                 instancePromise = (async () => {\n                      try {\n                          // console.log(`[IOC LoadClass] Instantiating transient ${className} with ${resolvedDependencies.length} args.`);\n                           const instance = new classDefinition(...resolvedDependencies);\n                           // No storing for transient\n                           return instance;\n                      } catch (err: any) {\n                           console.error(`[IOC LoadClass] Error during instantiation of transient ${className}: ${err.message}`, err.stack);\n                           throw err; // Re-throw instantiation error\n                      }\n                 })();\n            }\n            // --- End Instantiate Class ---\n            // Await and return the final instance (either newly created or from the stored promise)\n            return await instancePromise;\n        });\n\n        if(storageType && storageType !== 'transient'){\n            this.setInstance(classDefinition, finalInstance, storageType); // Store the promise\n        }\n        return finalInstance\n    }\n\n    private loadFunctionInstance(\n        funcLabel: any,\n        params: ParameterValue<any>[],\n        resolutionChain: string[]\n    ): Promise<any> { // Always return Promise<any> since this is an async function\n        const functionConfig = this._functionDefinition.get(funcLabel)!; // Assumed to exist by caller\n        const storageType = this.getStorageType(funcLabel); // Only uses manual options for functions\n        const labelStr = String(funcLabel);\n\n        // Check storage first\n        if (storageType && this.hasInstance(funcLabel)) {\n            const instance = this.getInstance(funcLabel);\n            // console.log(`[IOC LoadFunc] Found existing ${storageType} instance for ${labelStr}. IsPromise: ${isPromise(instance)}`);\n            return instance;\n        }\n         // console.log(`[IOC LoadFunc] Creating new ${storageType || 'transient'} instance for ${labelStr}`);\n\n        const ioc_func = functionConfig.function;\n        const options = functionConfig.options;\n        const dependenciesToResolve: any[] = options?.param || [];\n\n        // --- Resolve Dependencies ---\n        const paramsCopy = [...params]; // Create a copy\n        const resolutionPromises = dependenciesToResolve.map(dependencyIdentifier =>\n            this.loadInstance(dependencyIdentifier, paramsCopy, resolutionChain)\n        );\n\n        let finalInstance = Promise.all(resolutionPromises).catch((error)=>{\n            console.error(`[IOC LoadFunc] Failed to resolve dependencies for function ${labelStr}:`, error);\n           // Clean up potential partial storage\n           if (storageType && this.isRegisteredAsFunction(funcLabel)) {\n                if (storageType === 'singleton') this._functionStorageSingleton.delete(funcLabel);\n                if (storageType === 'scoped') this._functionStorageScoped.delete(funcLabel);\n           }\n           throw error;\n        }).then(async(resolvedArgs)=>{\n            let instancePromise: Promise<any> | undefined;\n        if (storageType && !this.hasInstance(funcLabel)) {\n             instancePromise = (async () => {\n                 try {\n                     // console.log(`[IOC LoadFunc] Invoking ${labelStr} with ${resolvedArgs.length} args.`);\n                     const result = await ioc_func.apply(null, resolvedArgs); // Await in case function is async\n                     // Overwrite stored promise with actual result\n                     this.setInstance(funcLabel, result, storageType);\n                     // console.log(`[IOC LoadFunc] Stored actual ${storageType} instance for ${labelStr}`);\n                     return result;\n                 } catch (err: any) {\n                     console.error(`[IOC LoadFunc] Error executing function ${labelStr}: ${err.message}`, err.stack);\n                     // Clean up stored promise on failure\n                     if (storageType === 'singleton') this._functionStorageSingleton.delete(funcLabel);\n                     if (storageType === 'scoped') this._functionStorageScoped.delete(funcLabel);\n                     throw err;\n                 }\n             })();\n              // console.log(`[IOC LoadFunc] Storing promise for concurrent requests (${storageType}) for ${labelStr}`);\n             this.setInstance(funcLabel, instancePromise, storageType);\n        } else {\n             // Transient or already resolved from storage check\n             instancePromise = (async () => {\n                  try {\n                     // console.log(`[IOC LoadFunc] Invoking transient ${labelStr} with ${resolvedArgs.length} args.`);\n                      const result = await ioc_func.apply(null, resolvedArgs); // Await in case function is async\n                      // No storing for transient\n                      return result;\n                  } catch (err: any) {\n                      console.error(`[IOC LoadFunc] Error executing transient function ${labelStr}: ${err.message}`, err.stack);\n                      throw err;\n                  }\n             })();\n        }\n        // --- End Invoke Function ---\n\n        return await instancePromise; // Return the final (awaited) result\n        });\n\n        if(storageType && storageType !== 'transient'){\n            this.setInstance(funcLabel, finalInstance, storageType); // Store the promise\n        }\n\n        return finalInstance;\n    }\n}\n\n// Helper functions\nexport function isPromise(obj: any): obj is Promise<any> {\n    // Simplified check - more robust check might be needed depending on environment\n    return !!obj && typeof obj.then === 'function';\n}\n\nexport function createContainer(): IContainerClient & IContainerSetup {\n    return new Container();\n}\n"],"mappings":"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","names":["ContainerRouting"]}

package/dist/{cjs/framework/implementation/Container.d.ts → framework/implementation/Container.d.cts}

@@ -1,7 +1,8 @@
-import 'reflect-metadata';
-import { ContainerOptions, IContainerClient, IContainerSetup } from "../interface/Container";
-import { ParameterValue } from "./Parameter";
-export declare class Container implements IContainerClient, IContainerSetup {
+import { IContainerClient, IContainerSetup, ContainerOptions } from '../interface/Container.cjs';
+import { ParameterValue } from './Parameter.cjs';
+import './LoadAs.cjs';
+
+declare class Container implements IContainerClient, IContainerSetup {
     private _routing;
     private _functionDefinition;
     private _classDefinition;
@@ -27,5 +28,7 @@ export declare class Container implements IContainerClient, IContainerSetup {
     private loadClassInstance;
     private loadFunctionInstance;
 }
-export declare function isPromise(obj: any): obj is Promise<any>;
-export declare function createContainer(): IContainerClient & IContainerSetup;
+declare function isPromise(obj: any): obj is Promise<any>;
+declare function createContainer(): IContainerClient & IContainerSetup;
+
+export { Container, createContainer, isPromise };

package/dist/{esm/framework → framework}/implementation/Container.d.ts

@@ -1,7 +1,8 @@
-import 'reflect-metadata';
-import { ContainerOptions, IContainerClient, IContainerSetup } from "../interface/Container";
-import { ParameterValue } from "./Parameter";
-export declare class Container implements IContainerClient, IContainerSetup {
+import { IContainerClient, IContainerSetup, ContainerOptions } from '../interface/Container.js';
+import { ParameterValue } from './Parameter.js';
+import './LoadAs.js';
+
+declare class Container implements IContainerClient, IContainerSetup {
     private _routing;
     private _functionDefinition;
     private _classDefinition;
@@ -27,5 +28,7 @@ export declare class Container implements IContainerClient, IContainerSetup {
     private loadClassInstance;
     private loadFunctionInstance;
 }
-export declare function isPromise(obj: any): obj is Promise<any>;
-export declare function createContainer(): IContainerClient & IContainerSetup;
+declare function isPromise(obj: any): obj is Promise<any>;
+declare function createContainer(): IContainerClient & IContainerSetup;
+
+export { Container, createContainer, isPromise };