@navios/di 0.5.1 → 0.6.0

package/src/utils/get-injectors.mts

@@ -1,6 +1,6 @@
 import type { z, ZodObject, ZodType } from 'zod/v4'
 
-import type { FactoryContext } from '../factory-context.mjs'
+import type { FactoryContext } from '../internal/context/factory-context.mjs'
 import type {
   BoundInjectionToken,
   ClassType,
@@ -9,7 +9,7 @@ import type {
   FactoryInjectionToken,
   InjectionToken,
   InjectionTokenSchemaType,
-} from '../injection-token.mjs'
+} from '../token/injection-token.mjs'
 import type {
   Factorable,
   FactorableWithArgs,
@@ -22,6 +22,7 @@ import type {
 } from './types.mjs'
 
 import { InjectableTokenMeta } from '../symbols/index.mjs'
+import { withoutResolutionContext } from '../internal/context/resolution-context.mjs'
 
 export interface Injectors {
   // #1 Simple class
@@ -167,7 +168,11 @@ export function getInjectors() {
   let promiseCollector: null | ((promise: Promise<any>) => void) = null
   let injectState: InjectState | null = null
 
-  function getRequest(token: InjectionToken<any>, args?: unknown) {
+  function getRequest(
+    token: InjectionToken<any>,
+    args?: unknown,
+    skipCycleTracking = false,
+  ) {
     if (!injectState) {
       throw new Error(
         '[Injector] Trying to make a request outside of a injectable context',
@@ -185,16 +190,26 @@ export function getInjectors() {
     }
     let result: any = null
     let error: Error | null = null
-    const promise = getFactoryContext()
-      .inject(token as any, args as any)
-      .then((r) => {
-        result = r
-        return r
-      })
-      .catch((e) => {
-        // We don't throw here because we have a mechanism to handle errors
-        error = e
-      })
+
+    // For async inject, we run outside the resolution context to skip cycle tracking.
+    // This is because asyncInject returns a promise that doesn't block the constructor,
+    // so it cannot cause a deadlock even with circular dependencies.
+    const doInject = () =>
+      getFactoryContext()
+        .inject(token as any, args as any)
+        .then((r) => {
+          result = r
+          return r
+        })
+        .catch((e) => {
+          // We don't throw here because we have a mechanism to handle errors
+          error = e
+        })
+
+    const promise = skipCycleTracking
+      ? withoutResolutionContext(doInject)
+      : doInject()
+
     const request: InjectRequest = {
       token,
       promise,
@@ -226,7 +241,9 @@ export function getInjectors() {
     }
     // @ts-expect-error In case we have a class
     const realToken = token[InjectableTokenMeta] ?? token
-    const request = getRequest(realToken, args)
+    // Pass skipCycleTracking=true because asyncInject returns a promise that doesn't
+    // block the constructor, so it cannot cause a deadlock even with circular dependencies.
+    const request = getRequest(realToken, args, true)
     return request.promise.then((result) => {
       if (request.error) {
         // We throw here because we want to fail the asyncInject call if the dependency fails to initialize
@@ -282,7 +299,7 @@ export function getInjectors() {
       )
     }
 
-    const instance = getFactoryContext().locator.getSyncInstance(
+    const instance = getFactoryContext().container.tryGetSync(
       realToken,
       args,
     )

package/src/utils/types.mts

@@ -3,7 +3,7 @@ import type {
   ClassType,
   FactoryInjectionToken,
   InjectionToken,
-} from '../injection-token.mjs'
+} from '../token/injection-token.mjs'
 
 // Utility types for string manipulation and union handling
 export type Join<TElements, TSeparator extends string> =

package/tsdown.config.mts

@@ -0,0 +1,67 @@
+import { withFilter } from 'rolldown/filter'
+import { defineConfig } from 'tsdown'
+import swc from 'unplugin-swc'
+
+export default defineConfig([
+  // Node.js build (default)
+  {
+    entry: ['src/index.mts', 'src/testing/index.mts'],
+    outDir: 'lib',
+    format: ['esm', 'cjs'],
+    clean: true,
+    treeshake: true,
+    sourcemap: true,
+    platform: 'node',
+    dts: true,
+    target: 'es2022',
+    plugins: [
+      withFilter(
+        swc.rolldown({
+          jsc: {
+            target: 'es2022',
+            parser: {
+              syntax: 'typescript',
+              decorators: true,
+            },
+            transform: {
+              decoratorVersion: '2022-03',
+            },
+          },
+        }),
+        // Only run this transform if the file contains a decorator.
+        { transform: { code: '@' } },
+      ),
+    ],
+  },
+  // Browser build - uses dedicated entry that forces SyncLocalStorage
+  {
+    entry: {
+      'browser/index': 'src/browser.mts',
+    },
+    outDir: 'lib',
+    format: ['esm'],
+    treeshake: true,
+    sourcemap: true,
+    platform: 'browser',
+    dts: true,
+    target: 'es2022',
+    plugins: [
+      withFilter(
+        swc.rolldown({
+          jsc: {
+            target: 'es2022',
+            parser: {
+              syntax: 'typescript',
+              decorators: true,
+            },
+            transform: {
+              decoratorVersion: '2022-03',
+            },
+          },
+        }),
+        // Only run this transform if the file contains a decorator.
+        { transform: { code: '@' } },
+      ),
+    ],
+  },
+])