@art-ws/di-node 2.0.1

package/dist/es/decorators.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import type { DIModuleOptions, DITypeOptions } from "./types";
+export declare function DIModule(options?: Partial<DIModuleOptions>): ClassDecorator;
+export declare function Autowire(options: DITypeOptions): ClassDecorator;
+export declare function Singleton(options?: Partial<DITypeOptions>): ClassDecorator;
+export declare function Service(options?: Partial<DITypeOptions>): ClassDecorator;
+export declare function Transient(options?: Partial<DITypeOptions>): ClassDecorator;

package/dist/es/decorators.js

@@ -0,0 +1,34 @@
+import "reflect-metadata";
+import { DIRegistry, METADATA_DI_MODULE_OPTIONS, METADATA_DI_TYPE_OPTIONS, } from "./registry";
+import { DIScope as Scope } from "./types";
+export function DIModule(options) {
+    const o = options ?? {};
+    o.scope = o.scope || Scope.SINGLETON;
+    return ((token) => {
+        Reflect.defineMetadata(METADATA_DI_MODULE_OPTIONS, o, token);
+        DIRegistry.current.registerModule(token);
+        return token;
+    });
+}
+export function Autowire(options) {
+    const o = (options ?? {});
+    return ((cls) => {
+        Reflect.defineMetadata(METADATA_DI_TYPE_OPTIONS, o, cls);
+        DIRegistry.current.registerProviders(o.scope, [cls]);
+    });
+}
+export function Singleton(options) {
+    const o = options ?? {};
+    o.scope = Scope.SINGLETON;
+    return Autowire(o);
+}
+export function Service(options) {
+    const o = options || {};
+    o.scope = o.scope ?? Scope.REQUEST;
+    return Autowire(options);
+}
+export function Transient(options) {
+    const o = options || {};
+    o.scope = o.scope ?? Scope.TRANSIENT;
+    return Autowire(options);
+}

package/dist/es/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./utils";
+export * from "./decorators";
+export * from "./injector-ref";
+export * from "./node-platform";
+export * from "./re-export";
+export * from "./registry";
+export * from "./types";

package/dist/es/index.js

@@ -0,0 +1,8 @@
+// created from 'create-ts-index'
+export * from "./utils";
+export * from "./decorators";
+export * from "./injector-ref";
+export * from "./node-platform";
+export * from "./re-export";
+export * from "./registry";
+export * from "./types";

package/dist/es/injector-ref.d.ts

@@ -0,0 +1,28 @@
+import { Injector } from "injection-js";
+import type { Provider } from "injection-js";
+import { ReflectiveInjector_ } from "injection-js/reflective_injector";
+import type { CreateChildOptions, InjectableType, InjectorRef, ScopeStrategy, TInjectableToken } from "./types";
+export declare function getScopeForInjectorRef(parent: InjectorRef | null, scopeStrategyFn: ScopeStrategy): string | null;
+export declare class InjectorRefImpl implements InjectorRef {
+    private parentInjector;
+    scopeStrategy: ScopeStrategy;
+    private readonly disposable;
+    private resolvedProvidersStore;
+    private reflectiveInjector;
+    private readonly injectorScope;
+    private readonly isTransient;
+    constructor(parentInjector: InjectorRefImpl | null, moduleToken: InjectableType | null, scopeStrategy: ScopeStrategy, staticProviders: Provider[], dynamicProviders: Provider[], disposable: boolean);
+    getByName<T>(tokenName: string): TInjectableToken<T> | undefined;
+    tryGet<T>(token: TInjectableToken<T>): T | undefined;
+    get<T>(token: TInjectableToken<T>): T;
+    get reflectiveInjector_(): ReflectiveInjector_;
+    getInstances(): any[];
+    dispose(cb: (ref?: unknown) => void): void;
+    injector(): Injector;
+    createChild(providers?: Provider[], opts?: Partial<CreateChildOptions>): InjectorRef;
+    parent(): InjectorRef | null;
+    scope(): string;
+    private _initEagerCalled;
+    initEager(cb?: (ref?: InjectableType) => Promise<void> | void, cached?: boolean): Promise<void>;
+    bootstrapModules(): Promise<void>;
+}

package/dist/es/injector-ref.js

@@ -0,0 +1,145 @@
+import { Injector, ReflectiveInjector } from "injection-js";
+import { ReflectiveInjector_ } from "injection-js/reflective_injector";
+import { DIRegistry } from "./registry";
+import { resolveAndBootstrapModule } from "./types";
+export function getScopeForInjectorRef(parent, scopeStrategyFn) {
+    return scopeStrategyFn(parent ? parent.scope() : null);
+}
+const nil = null;
+export class InjectorRefImpl {
+    parentInjector;
+    scopeStrategy;
+    disposable;
+    resolvedProvidersStore = nil;
+    reflectiveInjector;
+    injectorScope;
+    isTransient;
+    constructor(parentInjector, moduleToken, scopeStrategy, staticProviders, dynamicProviders, disposable) {
+        this.parentInjector = parentInjector;
+        this.scopeStrategy = scopeStrategy;
+        this.disposable = disposable;
+        if (!(typeof scopeStrategy === "function")) {
+            throw new Error("scopeStrategy not function");
+        }
+        this.injectorScope = getScopeForInjectorRef(parentInjector, scopeStrategy);
+        if (!this.injectorScope) {
+            throw new Error("Child injector for TRANSIENT scope not supported");
+        }
+        this.isTransient = !scopeStrategy(this.injectorScope);
+        if (staticProviders?.length) {
+            DIRegistry.current.registerProviders(this.injectorScope, staticProviders);
+        }
+        if (moduleToken) {
+            DIRegistry.current.registerModule(moduleToken, this.injectorScope);
+        }
+        let dynamicProvidersResolved = [];
+        if (dynamicProviders?.length) {
+            dynamicProvidersResolved =
+                ReflectiveInjector.resolve(dynamicProviders) || [];
+        }
+        const staticProvidersResolved = DIRegistry.current.getResolvedProvidersFor(this.injectorScope, moduleToken);
+        this.resolvedProvidersStore = [
+            ...staticProvidersResolved,
+            ...dynamicProvidersResolved,
+        ];
+        const resolvedProviders = this.isTransient
+            ? []
+            : this.resolvedProvidersStore || [];
+        this.reflectiveInjector = ReflectiveInjector.fromResolvedProviders(resolvedProviders, parentInjector?.injector());
+    }
+    getByName(tokenName) {
+        return DIRegistry.current.resolveTokenByName(tokenName);
+    }
+    tryGet(token) {
+        try {
+            return this.get(token);
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    get(token) {
+        let result;
+        try {
+            if (this.isTransient) {
+                const tmp = this.reflectiveInjector.createChildFromResolved(this.resolvedProvidersStore || []);
+                result = tmp.get(token);
+            }
+            else {
+                result = this.reflectiveInjector.get(token);
+            }
+        }
+        catch (e) {
+            const err = e;
+            if (err.message?.startsWith("No provider")) {
+                const ex = new Error(`${err.message} (scope: ${this.injectorScope})`);
+                ex.stack = err.stack;
+                throw ex;
+            }
+            else {
+                throw e;
+            }
+        }
+        return result;
+    }
+    get reflectiveInjector_() {
+        return this.reflectiveInjector;
+    }
+    getInstances() {
+        return this.reflectiveInjector_?.objs ?? [];
+    }
+    dispose(cb) {
+        if (!this.reflectiveInjector)
+            return;
+        if (!this.disposable) {
+            throw new Error("disposable = false");
+        }
+        const isObject = (x) => {
+            const t = typeof x;
+            return t === "object" || t === "function";
+        };
+        this.getInstances()
+            .filter(isObject)
+            .forEach((x) => {
+            cb(x);
+        });
+        this.reflectiveInjector = nil;
+        this.resolvedProvidersStore = [];
+        this.parentInjector = nil;
+    }
+    injector() {
+        return this.reflectiveInjector;
+    }
+    createChild(providers, opts) {
+        const options = opts || { disposable: false };
+        return new InjectorRefImpl(this, null, this.scopeStrategy, [], providers ?? [], options.disposable ?? false);
+    }
+    parent() {
+        return this.parentInjector || null;
+    }
+    scope() {
+        return this.injectorScope ?? "";
+    }
+    _initEagerCalled = false;
+    async initEager(cb, cached) {
+        if (this._initEagerCalled)
+            throw new Error(`'initEager' already called for InjectorRef instance`);
+        this._initEagerCalled = true;
+        const tokens = DIRegistry.current.getEagerTokens(this.scope(), cached);
+        for (const token of tokens) {
+            const ref = this.get(token);
+            if (typeof cb === "function") {
+                const result = cb(ref);
+                if (typeof result?.then === "function") {
+                    await result;
+                }
+            }
+        }
+    }
+    async bootstrapModules() {
+        const tokens = DIRegistry.current.getDIModules(this.scope());
+        for (const token of tokens) {
+            await resolveAndBootstrapModule(this, token);
+        }
+    }
+}

package/dist/es/node-platform.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleLoader } from "./types";
+export declare function platform(): ModuleLoader;

package/dist/es/node-platform.js

@@ -0,0 +1,50 @@
+import { InjectorRefImpl } from "./injector-ref";
+import { APP_INITIALIZER, getDefaultScopeStrategy, ROOT_INJECTOR, } from "./types";
+class NodeModuleLoader {
+    diProviders;
+    providers(providers) {
+        this.diProviders = providers;
+        return this;
+    }
+    async initAppInitializer(injector) {
+        let promises;
+        let p;
+        try {
+            p = injector.get(APP_INITIALIZER);
+        }
+        catch (e) {
+            const err = e;
+            if (!err.message.includes("No provider for InjectionToken APP_INITIALIZER")) {
+                throw e;
+            }
+        }
+        if (p) {
+            if (Array.isArray(p))
+                promises = p;
+            else
+                promises = [p];
+            await Promise.all(promises);
+        }
+    }
+    async bootstrapModule(token) {
+        let injector = null;
+        const providers = [
+            ...(this.diProviders ?? []),
+            {
+                provide: ROOT_INJECTOR,
+                useFactory: () => injector,
+                deps: [],
+            },
+        ];
+        injector = new InjectorRefImpl(null, token, getDefaultScopeStrategy, providers, [], false);
+        const instance = injector.get(token);
+        await this.initAppInitializer(injector);
+        return {
+            injector,
+            instance,
+        };
+    }
+}
+export function platform() {
+    return new NodeModuleLoader();
+}

package/dist/es/re-export.d.ts

@@ -0,0 +1 @@
+export * from "injection-js";

package/dist/es/re-export.js

@@ -0,0 +1 @@
+export * from "injection-js";

package/dist/es/registry.d.ts

@@ -0,0 +1,37 @@
+import type { Provider, ResolvedReflectiveProvider } from "injection-js";
+import "reflect-metadata";
+import type { DIModuleOptions, DITypeOptions, InjectableToken, InjectableType } from "./types";
+export declare const METADATA_DI_ID: unique symbol;
+export declare const METADATA_DI_MODULE_OPTIONS: unique symbol;
+export declare const METADATA_DI_TYPE_OPTIONS: unique symbol;
+type ProvidersStore = Map<string, Provider>;
+type ScopesStore = Map<string, ProvidersStore>;
+export declare function tokenToString(token: InjectableType): string | undefined;
+export declare function isDITokenRegistered(token: InjectableType): boolean;
+export declare function getDIModuleOptions(token: InjectableType): DIModuleOptions;
+export declare function getDITypeOptions(token: InjectableType): DITypeOptions;
+export declare class DIRegistry {
+    static current: DIRegistry;
+    parent: DIRegistry | null;
+    private nextId;
+    scopesStore: ScopesStore;
+    resolvedProvidersStore: Map<string, ResolvedReflectiveProvider[]>;
+    modulesStore: InjectableToken[];
+    resolvedEagerTokens: Map<string, InjectableType[]>;
+    tokensStore: Map<string, unknown>;
+    private getNexId;
+    private getProvidersStore;
+    registerProviders(scope: string, providers: Provider[]): void;
+    private registerProvider;
+    private injectRegisterTokenID;
+    private _registerModule;
+    registerModule(moduleToken: InjectableType, scope?: string): void;
+    getProvidersFor(scope: string, token: InjectableType | null): Provider[];
+    clear(): void;
+    getResolvedProvidersFor(scope: string, token: InjectableType | null): ResolvedReflectiveProvider[];
+    getDIModules(scope: string): InjectableType[];
+    resolveEagerTokens(scope: string): InjectableType[];
+    getEagerTokens(scope: string, cached?: boolean): InjectableType[];
+    resolveTokenByName(name: string): InjectableToken | undefined;
+}
+export {};

package/dist/es/registry.js

@@ -0,0 +1,171 @@
+import { ReflectiveInjector } from "injection-js";
+import "reflect-metadata";
+export const METADATA_DI_ID = Symbol("art-ws:di:id");
+export const METADATA_DI_MODULE_OPTIONS = Symbol("art-ws:di:module:options");
+export const METADATA_DI_TYPE_OPTIONS = Symbol("art-ws:di:type:options");
+function className(cls) {
+    const str = String(cls);
+    const [_type, _name] = str.split(" ");
+    if (_type != "class" || !_name)
+        return undefined;
+    return _name.trim();
+}
+export function tokenToString(token) {
+    const s = token.toString();
+    if (s === "[object Object]")
+        return undefined;
+    return className(token);
+}
+export function isDITokenRegistered(token) {
+    return Boolean(Reflect.getMetadata(METADATA_DI_ID, token));
+}
+export function getDIModuleOptions(token) {
+    const o = Reflect.getMetadata(METADATA_DI_MODULE_OPTIONS, token);
+    if (typeof o !== "object") {
+        throw new Error(`Module ${token} require @DIModule() decorator`);
+    }
+    return o;
+}
+export function getDITypeOptions(token) {
+    const o = Reflect.getMetadata(METADATA_DI_TYPE_OPTIONS, token);
+    if (typeof o !== "object") {
+        throw new Error(`Type ${`${token}`} require  @Autowired() decorator`);
+    }
+    return o;
+}
+export class DIRegistry {
+    static current;
+    parent = null;
+    nextId = 1;
+    scopesStore = new Map();
+    resolvedProvidersStore = new Map();
+    modulesStore = [];
+    resolvedEagerTokens = new Map();
+    tokensStore = new Map();
+    getNexId() {
+        return this.nextId++;
+    }
+    getProvidersStore(scope) {
+        const { scopesStore } = this;
+        const providersStore = scopesStore.get(scope) ??
+            (() => {
+                const value = new Map();
+                scopesStore.set(scope, value);
+                return value;
+            })();
+        return providersStore;
+    }
+    registerProviders(scope, providers) {
+        const providersStore = this.getProvidersStore(scope);
+        providers.forEach((provider) => {
+            this.registerProvider(providersStore, provider);
+        });
+    }
+    registerProvider(store, provider) {
+        const o = Reflect.getMetadata(METADATA_DI_TYPE_OPTIONS, provider);
+        if (o && isDITokenRegistered(provider)) {
+            return;
+        }
+        const id = this.injectRegisterTokenID(provider);
+        store.set(`${id}`, provider);
+        const tokenName = tokenToString(provider);
+        if (tokenName) {
+            this.tokensStore.set(tokenName, provider);
+        }
+    }
+    injectRegisterTokenID(token) {
+        if (!token) {
+            throw new Error("token not defined");
+        }
+        const id = this.getNexId();
+        const metadataValue = `${id}`;
+        Reflect.defineMetadata(METADATA_DI_ID, metadataValue, token);
+        return metadataValue;
+    }
+    _registerModule(path, moduleToken, scope) {
+        if (isDITokenRegistered(moduleToken)) {
+            return;
+        }
+        const idMaybe = Reflect.getMetadata(METADATA_DI_ID, moduleToken);
+        if (idMaybe && path.includes(idMaybe)) {
+            throw new Error(`Circular dependency for type ${`${moduleToken}`}`);
+        }
+        this.modulesStore.push(moduleToken);
+        path.push(this.injectRegisterTokenID(moduleToken));
+        const o = getDIModuleOptions(moduleToken);
+        (o.imports ?? []).forEach((importedModuleToken) => {
+            this._registerModule(path, importedModuleToken, scope);
+        });
+        const s = scope ?? o.scope ?? "";
+        if (!s) {
+            throw new Error(`Scope not provided for ${moduleToken}`);
+        }
+        const providers = [...(o.providers ?? [])];
+        this.registerProviders(s, [
+            moduleToken,
+            ...providers,
+            ...(o.bootstrap ?? []),
+        ]);
+    }
+    registerModule(moduleToken, scope) {
+        this._registerModule([], moduleToken, scope);
+    }
+    getProvidersFor(scope, token) {
+        if (!scope) {
+            throw new Error(`Scope not defined.`);
+        }
+        if (token && !isDITokenRegistered(token)) {
+            throw new Error(`Token ${token} not registered.`);
+        }
+        const providersStore = this.getProvidersStore(scope);
+        const providers = [...providersStore.values()];
+        return providers;
+    }
+    clear() {
+        this.resolvedProvidersStore.clear();
+        this.resolvedEagerTokens.clear();
+    }
+    getResolvedProvidersFor(scope, token) {
+        if (!scope)
+            throw new Error("Scope not defined");
+        const { resolvedProvidersStore } = this;
+        if (resolvedProvidersStore.has(scope)) {
+            return resolvedProvidersStore.get(scope) ?? [];
+        }
+        const effectiveProviders = this.getProvidersFor(scope, token);
+        const result = ReflectiveInjector.resolve(effectiveProviders) ?? [];
+        resolvedProvidersStore.set(scope, result);
+        return result;
+    }
+    getDIModules(scope) {
+        return [...this.modulesStore]
+            .map((token) => ({ token, options: getDIModuleOptions(token) }))
+            .filter((x) => x.options?.scope === scope)
+            .map((x) => x.token);
+    }
+    resolveEagerTokens(scope) {
+        const providersStore = this.getProvidersStore(scope);
+        return [...providersStore.values()]
+            .map((token) => ({
+            token,
+            options: Reflect.getMetadata(METADATA_DI_TYPE_OPTIONS, token),
+        }))
+            .filter((x) => x.options?.eager)
+            .map((x) => x.token);
+    }
+    getEagerTokens(scope, cached) {
+        if (!cached)
+            return this.resolveEagerTokens(scope);
+        const { resolvedEagerTokens } = this;
+        return (resolvedEagerTokens.get(scope) ??
+            (() => {
+                const value = this.resolveEagerTokens(scope);
+                resolvedEagerTokens.set(scope, value);
+                return value;
+            })());
+    }
+    resolveTokenByName(name) {
+        return this.tokensStore.get(name);
+    }
+}
+DIRegistry.current = new DIRegistry();

package/dist/es/types.d.ts

@@ -0,0 +1,53 @@
+import { InjectionToken, Injector } from "injection-js";
+import type { Provider, Type } from "injection-js";
+export type TInjectableType<T> = Type<T> | Object;
+export type InjectableType = TInjectableType<any>;
+export type TInjectableToken<T> = TInjectableType<T> | InjectionToken<T>;
+export type InjectableToken = TInjectableToken<any>;
+export declare const APP_INITIALIZER: InjectionToken<Promise<void>[]>;
+export declare const ROOT_INJECTOR: InjectionToken<InjectorRef>;
+export declare enum DIScope {
+    SINGLETON = "SINGLETON",
+    REQUEST = "REQUEST",
+    TRANSIENT = "TRANSIENT"
+}
+export interface DIModuleOptions {
+    scope: DIScope;
+    imports?: InjectableType[];
+    providers?: Provider[];
+    bootstrap?: InjectableType[];
+}
+export interface DITypeOptions {
+    scope: DIScope;
+    eager?: boolean;
+}
+export type ScopeStrategy = (parent: DIScope | null | string) => DIScope | null | string;
+export declare function getDefaultScopeStrategy(parent: DIScope | null | string): DIScope | null | string;
+export interface CreateChildOptions {
+    disposable: boolean;
+}
+export interface InjectorRef {
+    get: <T>(token: TInjectableToken<T>) => T;
+    parent: () => InjectorRef | null;
+    scope: () => string;
+    injector: () => Injector;
+    createChild: (providers?: Provider[], opts?: CreateChildOptions) => InjectorRef;
+    dispose?: (callback: (x?: unknown) => void) => void;
+    initEager: (cb?: (ref?: InjectableType) => void, cached?: boolean) => Promise<void>;
+    bootstrapModules: () => Promise<void> | void;
+    getByName: <T>(tokenName: string) => TInjectableToken<T> | undefined;
+}
+export interface ModuleRef<T = any> {
+    injector: InjectorRef;
+    instance: T;
+}
+export interface ModuleLoader {
+    providers: (providers?: Provider[]) => ModuleLoader;
+    bootstrapModule: (rootModule: InjectableType) => Promise<ModuleRef>;
+}
+export interface DoBootstrap {
+    doBootstrap: (injector?: InjectorRef) => Promise<void> | void;
+}
+export declare function tryInvokeDoBootstrap(ref: DoBootstrap, injector: InjectorRef): Promise<void>;
+export declare function resolveAndInvokeDoBootstrap(injector: InjectorRef, token: InjectableToken): Promise<void>;
+export declare function resolveAndBootstrapModule(injector: InjectorRef, token: InjectableToken): Promise<void>;

package/dist/es/types.js

@@ -0,0 +1,45 @@
+import { InjectionToken, Injector } from "injection-js";
+import { getDIModuleOptions } from "./registry";
+// https://angular.io/api/core/APP_INITIALIZER
+// https://github.com/angular/angular/blob/master/packages/core/src/application_init.ts
+export const APP_INITIALIZER = new InjectionToken("APP_INITIALIZER");
+export const ROOT_INJECTOR = new InjectionToken("ROOT_INJECTOR");
+export var DIScope;
+(function (DIScope) {
+    DIScope["SINGLETON"] = "SINGLETON";
+    DIScope["REQUEST"] = "REQUEST";
+    DIScope["TRANSIENT"] = "TRANSIENT";
+})(DIScope || (DIScope = {}));
+export function getDefaultScopeStrategy(parent) {
+    if (!parent) {
+        return DIScope.SINGLETON;
+    }
+    else if (parent === DIScope.SINGLETON) {
+        return DIScope.REQUEST;
+    }
+    else if (parent === DIScope.REQUEST) {
+        return DIScope.TRANSIENT;
+    }
+    return "";
+}
+export async function tryInvokeDoBootstrap(ref, injector) {
+    if (typeof ref?.doBootstrap === "function") {
+        const result = ref.doBootstrap(injector);
+        if (typeof result?.then === "function") {
+            await result;
+        }
+    }
+}
+export async function resolveAndInvokeDoBootstrap(injector, token) {
+    const ref = injector.get(token);
+    await tryInvokeDoBootstrap(ref, injector);
+}
+export async function resolveAndBootstrapModule(injector, token) {
+    const ref = injector.get(token);
+    await tryInvokeDoBootstrap(ref, injector);
+    const o = getDIModuleOptions(token);
+    for (const moduleToken of o.bootstrap ?? []) {
+        const moduleRef = injector.get(moduleToken);
+        await tryInvokeDoBootstrap(moduleRef, injector);
+    }
+}

package/dist/es/utils/get-multi.d.ts

@@ -0,0 +1,2 @@
+import type { InjectorRef } from "../types";
+export declare function getMultiInstances<T>(token: any, injector: InjectorRef): T[];

package/dist/es/utils/get-multi.js

@@ -0,0 +1,7 @@
+import { getInstanceSafe } from "./get-safe";
+export function getMultiInstances(token, injector) {
+    const result = getInstanceSafe(token, injector);
+    if (!result)
+        return [];
+    return Array.isArray(result) ? result : [result];
+}

package/dist/es/utils/get-safe.d.ts

@@ -0,0 +1,2 @@
+import type { InjectorRef } from "../types";
+export declare function getInstanceSafe<T>(token: any, injector: InjectorRef): T | null;

package/dist/es/utils/get-safe.js

@@ -0,0 +1,11 @@
+export function getInstanceSafe(token, injector) {
+    try {
+        return injector.get(token);
+    }
+    catch (e) {
+        const err = e;
+        if (err?.message?.startsWith("No provider for"))
+            return null;
+        throw err;
+    }
+}

package/dist/es/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./get-multi";
+export * from "./get-safe";

package/dist/es/utils/index.js

@@ -0,0 +1,3 @@
+// created from 'create-ts-index'
+export * from "./get-multi";
+export * from "./get-safe";

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@art-ws/di-node",
+  "version": "2.0.1",
+  "description": "Dependency Injection core",
+  "keywords": [
+    "lib"
+  ],
+  "license": "UNLICENSED",
+  "main": "dist/es/index.js",
+  "types": "dist/es/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "injection-js": "^2.5.0",
+    "reflect-metadata": "^0.2.2",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "eslint": "^9.34.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4",
+    "@art-ws/config-ts": "2.0.6",
+    "@art-ws/config-eslint": "2.0.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "check": "pnpm clean && pnpm build && pnpm lint && pnpm test",
+    "clean": "rm -rf dist",
+    "clean:nm": "rm -rf node_modules",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "watch": "tsc --watch"
+  }
+}