Small fixes

Author: benoitlahoz

packages/assemblerjs/src/features/assembler/lib/cycle-detector.ts

@@ -1,5 +1,4 @@
 import type { Identifier } from '@/shared/common';
-import { formatIdentifier } from './injectable-manager';
 
 export interface CycleDetectionResult {
   cycle: string[];
@@ -11,8 +10,8 @@ export interface CycleDetectionResult {
  */
 abstract class AbstractCycleDetector {
   abstract detect(
-    injectables: Map<Identifier, any>,
-    formatFn: (id: Identifier) => string
+    injectables: Map<Identifier<any>, any>,
+    formatFn: (id: Identifier<any>) => string
   ): CycleDetectionResult[];
 }
 
@@ -30,17 +29,17 @@ class NoOpCycleDetector extends AbstractCycleDetector {
  */
 class ActiveCycleDetector extends AbstractCycleDetector {
   detect(
-    injectables: Map<Identifier, any>,
-    formatFn: (id: Identifier) => string
+    injectables: Map<Identifier<any>, any>,
+    formatFn: (id: Identifier<any>) => string
   ): CycleDetectionResult[] {
     const cycles: CycleDetectionResult[] = [];
-    const visited = new Set<Identifier>();
+    const visited = new Set<Identifier<any>>();
 
     for (const [identifier] of injectables) {
       if (visited.has(identifier)) continue;
 
-      const path: Identifier[] = [];
-      const inPath = new Set<Identifier>();
+      const path: Identifier<any>[] = [];
+      const inPath = new Set<Identifier<any>>();
 
       if (this.hasCycleDFS(identifier, path, inPath, visited, injectables)) {
         // Cycle found - extract the cycle path
@@ -62,11 +61,11 @@ class ActiveCycleDetector extends AbstractCycleDetector {
    * DFS helper to detect cycles
    */
   private hasCycleDFS(
-    current: Identifier,
-    path: Identifier[],
-    inPath: Set<Identifier>,
-    visited: Set<Identifier>,
-    injectables: Map<Identifier, any>
+    current: Identifier<any>,
+    path: Identifier<any>[],
+    inPath: Set<Identifier<any>>,
+    visited: Set<Identifier<any>>,
+    injectables: Map<Identifier<any>, any>
   ): boolean {
     if (inPath.has(current)) {
       path.push(current);

packages/assemblerjs/src/features/assembler/lib/injectable-manager.ts

@@ -200,7 +200,7 @@ export class InjectableManager {
     )! as Injectable<T>;
 
     // Track resolution start
-    this.resolvingStack.add(injectable.identifier);
+    this.resolvingStack.add(injectable.identifier as Identifier<any>);
 
     try {
       if (injectable.isSingleton) {
@@ -210,7 +210,7 @@ export class InjectableManager {
       }
     } finally {
       // Always cleanup after resolution (success or error)
-      this.resolvingStack.delete(injectable.identifier);
+      this.resolvingStack.delete(injectable.identifier as Identifier<any>);
     }
   }
 
@@ -253,7 +253,7 @@ export class InjectableManager {
   /**
    * Get the injectables map for cycle detection and other analysis
    */
-  public getInjectables(): Map<Identifier, any> {
+  public getInjectables(): Map<Identifier<any>, any> {
     return this.injectables;
   }
 }

packages/assemblerjs/src/features/injectable/lib/dependencies.ts

@@ -1,4 +1,5 @@
 import type { Concrete } from '@assemblerjs/core';
+import type { Identifier } from '@/shared/common';
 import { getParamTypes } from '@/shared/common';
 import { getDecoratedParametersIndexes } from '@/shared/decorators';
 import { AbstractInjectable } from '@/features/injectable';
@@ -12,7 +13,10 @@ const dependenciesCache = new WeakMap<Function, any[]>();
  * Helper function to determine the decorator type for a given parameter index.
  * Now uses dynamic decorator registration instead of hardcoded names.
  */
-const getDecoratorType = (indexes: ReturnType<typeof getDecoratedParametersIndexes>, index: number): string | null => {
+const getDecoratorType = (indexes: ReturnType<typeof getDecoratedParametersIndexes> | never[], index: number): string | null => {
+  if (!indexes || typeof indexes !== 'object' || Array.isArray(indexes)) {
+    return null;
+  }
   for (const [decoratorName, decoratorIndexes] of Object.entries(indexes)) {
     if (decoratorIndexes.includes(index)) {
       return decoratorName;
@@ -35,8 +39,8 @@ export const resolveInjectableParameters = <T>(
   const parameters: any[] = [];
 
   // Parameters passed in constructor.
-  const paramTypes = getParamTypes(injectable.concrete);
-  const indexes = getDecoratedParametersIndexes(injectable.concrete);
+  const paramTypes = injectable.concrete ? getParamTypes(injectable.concrete) : [];
+  const indexes = injectable.concrete ? getDecoratedParametersIndexes(injectable.concrete) : [];
 
   // Build parameters to pass to instance.
   for (let i = 0; i < paramTypes.length; i++) {
@@ -45,7 +49,7 @@ export const resolveInjectableParameters = <T>(
     if (decoratorType) {
       // Use the appropriate resolver for decorated parameters
       const resolver = ParameterResolverFactory.getResolver(decoratorType);
-      parameters.push(resolver.resolve(i, injectable, injectable.concrete, configuration));
+      parameters.push(resolver.resolve(i, injectable, injectable.concrete as Concrete<T>, configuration));
     } else {
       const paramType = paramTypes[i];
 
@@ -74,7 +78,7 @@ export const resolveInjectableParameters = <T>(
               __paramCount: paramTypes.length,
               __expectedType: paramType
             },
-            injectable.identifier
+            injectable.identifier as Identifier<any>
           )
         );
       }