proxydi 0.0.3

package/.github/workflows/coverage_badge.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+    push:
+        branches:
+            - main
+    pull_request:
+        branches:
+            - main
+
+jobs:
+    test:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
+
+            - name: Setup Node.js
+              uses: actions/setup-node@v3
+              with:
+                  node-version: '22'
+
+            - name: Install dependencies
+              run: npm install
+
+            - name: Run tests with coverage
+              run: npm run coverage
+
+            - name: Upload coverage to Coveralls
+              uses: coverallsapp/github-action@v2
+              with:
+                  github-token: ${{ secrets.GITHUB_TOKEN }}
+                  path-to-lcov: ./coverage/lcov.info

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 proxy-di
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# ProxyDI
+
+[![Coverage Status](https://coveralls.io/repos/github/proxy-di/proxydi/badge.svg?branch=main)](https://coveralls.io/github/proxy-di/proxydi?branch=main)
+
+A typed DI container that resolves circular dependencies via Proxy.
+
+Core notes:
+
+- Uses Stage 3 decorators (supported in TypeScript 5.x and babel-plugin-proposal-decorators)
+- Automatically resolves circular dependencies
+- Matches services by unique identifiers, class or property names
+- Currently in active development
+
+# Quick start
+
+```shell
+npm i proxydi
+```
+
+If you are using TypeScript be sure that your tsconfig.json set exactly `false` value for `experimentalDecorators`. This could be not obvious, but this setup turns on support of Stage 3 decorators.
+
+```jsonc
+{
+    "compilerOptions": {
+        // ...
+        "experimentalDecorators": false,
+    },
+    //...
+}
+```
+
+1. @inject your dependencies
+
+```typescript
+import { inject } from 'proxydi';
+
+interface Personality {
+    greet(): string;
+}
+
+class Agent {
+    @inject() personality: Personality;
+}
+```
+
+2. Create, fill ProxyDI container
+
+```typescript
+import { ProxyDI } from 'proxydi';
+
+class Jarvis implements Personality {
+    greet: () => 'Hello, sir!';
+}
+
+const container = new ProxyDI();
+container.registerClass('personality', Jarvis);
+```
+
+3. Use dependencies
+
+```typescript
+const agent = container.resolve(Agent);
+console.log(agent.personality.greet());
+```
+
+```shell
+> Hello, sir!
+```
+
+To be continued...

package/dist/ProxyDI.d.ts

@@ -0,0 +1,32 @@
+import { ProxyDISettings, ServiceClass, ServiceId } from './types';
+export declare const PROXYDI: unique symbol;
+export declare const PROXYDI_ID: unique symbol;
+export declare class ProxyDI {
+    private static idCounter;
+    readonly id: number;
+    readonly parent?: ProxyDI;
+    private children;
+    private instances;
+    private classes;
+    private proxies;
+    private proxyFactory;
+    protected allowRewriteClasses: boolean;
+    protected allowRewriteInstances: boolean;
+    constructor(settings?: ProxyDISettings);
+    registerInstance<T>(serviceId: ServiceId, instance: T extends {
+        new (...args: any[]): any;
+    } ? never : T): void;
+    registerClass<T>(serviceId: ServiceId, serviceClass: ServiceClass<T>): void;
+    private findInstance;
+    isKnown(serviceId: ServiceId): boolean;
+    resolve<T>(serviceId: ServiceId): T;
+    private findDefiner;
+    injectDependencies(instance: any): void;
+    private getProxy;
+    createChildContainer(settings?: ProxyDISettings): ProxyDI;
+    removeInstance(serviceId: ServiceId): void;
+    removeClass(serviceId: ServiceId): void;
+    destroy(): void;
+    addChild(child: ProxyDI): void;
+    private removeChild;
+}

package/dist/ProxyFactory.d.ts

@@ -0,0 +1,8 @@
+import { ProxyDI } from './ProxyDI';
+import { ServiceId } from './types';
+export declare class ProxyFactory {
+    private container;
+    constructor(container: ProxyDI);
+    makeProxy<T>(serviceId: ServiceId): T;
+}
+export declare function isProxy(value: any): boolean;

package/dist/index.cjs

@@ -0,0 +1,230 @@
+'use strict';
+
+const INJECTS = Symbol('injects');
+const inject = (serviceId) => {
+    return function (_value, context) {
+        if ((context === null || context === undefined ? undefined : context.kind) === 'field') {
+            const name = serviceId ? serviceId : context.name;
+            const inject = {
+                property: context.name,
+                serviceId: name,
+                set: context.access.set,
+            };
+            context.addInitializer(function () {
+                if (!this[INJECTS]) {
+                    this[INJECTS] = [];
+                }
+                this[INJECTS].push(inject);
+            });
+        }
+    };
+};
+
+const injectableClasses = {};
+
+const IS_PROXY = Symbol('isProxy');
+class ProxyFactory {
+    constructor(container) {
+        this.container = container;
+    }
+    makeProxy(serviceId) {
+        const self = this;
+        const proxy = new Proxy({ [IS_PROXY]: true }, {
+            get: function (target, prop, receiver) {
+                if (target[prop]) {
+                    return target[prop];
+                }
+                if (self.container.isKnown(serviceId)) {
+                    const instance = self.container.resolve(serviceId);
+                    return Reflect.get(instance, prop, receiver);
+                }
+                else {
+                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                }
+            },
+            set: function (target, prop, value) {
+                if (self.container.isKnown(serviceId)) {
+                    const instance = self.container.resolve(serviceId);
+                    return Reflect.set(instance, prop, value);
+                }
+                else {
+                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                }
+            },
+            has: function (target, prop) {
+                if (self.container.isKnown(serviceId)) {
+                    const instance = self.container.resolve(serviceId);
+                    return Reflect.has(instance, prop);
+                }
+                else {
+                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                }
+            },
+        });
+        return proxy;
+    }
+}
+
+const PROXYDI = Symbol('ProxyDI');
+const PROXYDI_ID = Symbol('ProxyDI_ID');
+class ProxyDI {
+    constructor(settings) {
+        this.children = {};
+        this.instances = {};
+        this.classes = {};
+        this.proxies = {};
+        this.allowRewriteClasses = false;
+        this.allowRewriteInstances = false;
+        this.proxyFactory = new ProxyFactory(this);
+        this.id = ProxyDI.idCounter++;
+        if (settings === null || settings === undefined ? undefined : settings.parent) {
+            this.parent = settings.parent;
+            this.parent.addChild(this);
+        }
+        if ((settings === null || settings === undefined ? undefined : settings.allowRewriteClasses) !== undefined) {
+            this.allowRewriteClasses = settings.allowRewriteClasses;
+        }
+        if ((settings === null || settings === undefined ? undefined : settings.allowRewriteInstances) !== undefined) {
+            this.allowRewriteInstances = settings.allowRewriteInstances;
+        }
+    }
+    registerInstance(serviceId, instance) {
+        if (this.instances[serviceId]) {
+            if (!this.allowRewriteInstances) {
+                throw new Error(`ProxyDI already has registered instance for ${serviceId}`);
+            }
+        }
+        this.injectDependencies(instance);
+        if (typeof instance === 'object') {
+            instance[PROXYDI_ID] = serviceId;
+        }
+        this.instances[serviceId] = instance;
+    }
+    registerClass(serviceId, serviceClass) {
+        if (this.classes[serviceId]) {
+            if (!this.allowRewriteClasses) {
+                throw new Error(`ProxyDI already has registered class for ${serviceId}`);
+            }
+        }
+        this.classes[serviceId] = serviceClass;
+    }
+    findInstance(serviceId) {
+        const instance = this.instances[serviceId];
+        if (!instance && this.parent) {
+            return this.parent.findInstance(serviceId);
+        }
+        return instance;
+    }
+    isKnown(serviceId) {
+        return !!(this.findInstance(serviceId) || this.findDefiner(serviceId));
+    }
+    resolve(serviceId) {
+        if (!this.isKnown(serviceId)) {
+            throw new Error(`Can't resolve unknown ProxyDI-service: ${serviceId}`);
+        }
+        const instance = this.findInstance(serviceId);
+        if (instance) {
+            return instance;
+        }
+        const definer = this.findDefiner(serviceId);
+        if (definer) {
+            let instance = new definer();
+            this.injectDependencies(instance);
+            instance[PROXYDI_ID] = serviceId;
+            this.instances[serviceId] = instance;
+            return instance;
+        }
+        else {
+            return this.getProxy(serviceId);
+        }
+    }
+    findDefiner(serviceId) {
+        let definer = this.classes[serviceId];
+        if (!definer && this.parent) {
+            return this.parent.findDefiner(serviceId);
+        }
+        if (!definer) {
+            return injectableClasses[serviceId];
+        }
+        return definer;
+    }
+    injectDependencies(instance) {
+        const serviceInjects = instance[INJECTS] || [];
+        serviceInjects.forEach((inject) => {
+            let value = this.findInstance(inject.serviceId);
+            if (!value) {
+                value = this.getProxy(inject.serviceId);
+            }
+            inject.set(instance, value);
+        });
+        if (typeof instance === 'object') {
+            instance[PROXYDI] = this;
+        }
+    }
+    getProxy(serviceId) {
+        let proxy = this.proxies[serviceId];
+        if (!proxy) {
+            proxy = this.proxyFactory.makeProxy(serviceId);
+            this.proxies[serviceId] = proxy;
+        }
+        return proxy;
+    }
+    createChildContainer(settings) {
+        const childSettings = Object.assign(Object.assign({}, settings), { parent: this });
+        return new ProxyDI(childSettings);
+    }
+    removeInstance(serviceId) {
+        const id = serviceId[PROXYDI_ID]
+            ? serviceId[PROXYDI_ID]
+            : serviceId;
+        const instance = this.instances[id];
+        if (instance) {
+            const serviceInjects = instance[INJECTS] || [];
+            serviceInjects.forEach((inject) => {
+                inject.set(instance, undefined);
+            });
+            delete instance[PROXYDI];
+            delete instance[PROXYDI_ID];
+            delete this.instances[serviceId];
+        }
+    }
+    removeClass(serviceId) {
+        delete this.classes[serviceId];
+    }
+    destroy() {
+        const allServices = Object.keys(this.instances);
+        for (const serviceId of allServices) {
+            const instance = this.instances[serviceId];
+            this.removeInstance(instance);
+        }
+        this.instances = {};
+        this.proxies = {};
+        this.classes = {};
+        for (const id of Object.keys(this.children)) {
+            const child = this.children[+id];
+            child.destroy();
+        }
+        this.children = {};
+        this.proxyFactory = undefined;
+        if (this.parent) {
+            this.parent.removeChild(this.id);
+            this.parent = undefined;
+        }
+    }
+    addChild(child) {
+        if (this.children[child.id]) {
+            throw new Error(`ProxyDI already has child with id ${child.id}`);
+        }
+        this.children[child.id] = child;
+    }
+    removeChild(id) {
+        const child = this.children[id];
+        if (child) {
+            delete this.children[id];
+        }
+    }
+}
+ProxyDI.idCounter = 0;
+
+exports.ProxyDI = ProxyDI;
+exports.inject = inject;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ProxyDI } from './ProxyDI';
+export { inject } from './inject';
+export { Inject, ServiceId, ServiceClass, ProxyDISettings } from './types';

package/dist/index.js

@@ -0,0 +1,227 @@
+const INJECTS = Symbol('injects');
+const inject = (serviceId) => {
+    return function (_value, context) {
+        if ((context === null || context === undefined ? undefined : context.kind) === 'field') {
+            const name = serviceId ? serviceId : context.name;
+            const inject = {
+                property: context.name,
+                serviceId: name,
+                set: context.access.set,
+            };
+            context.addInitializer(function () {
+                if (!this[INJECTS]) {
+                    this[INJECTS] = [];
+                }
+                this[INJECTS].push(inject);
+            });
+        }
+    };
+};
+
+const injectableClasses = {};
+
+const IS_PROXY = Symbol('isProxy');
+class ProxyFactory {
+    constructor(container) {
+        this.container = container;
+    }
+    makeProxy(serviceId) {
+        const self = this;
+        const proxy = new Proxy({ [IS_PROXY]: true }, {
+            get: function (target, prop, receiver) {
+                if (target[prop]) {
+                    return target[prop];
+                }
+                if (self.container.isKnown(serviceId)) {
+                    const instance = self.container.resolve(serviceId);
+                    return Reflect.get(instance, prop, receiver);
+                }
+                else {
+                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                }
+            },
+            set: function (target, prop, value) {
+                if (self.container.isKnown(serviceId)) {
+                    const instance = self.container.resolve(serviceId);
+                    return Reflect.set(instance, prop, value);
+                }
+                else {
+                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                }
+            },
+            has: function (target, prop) {
+                if (self.container.isKnown(serviceId)) {
+                    const instance = self.container.resolve(serviceId);
+                    return Reflect.has(instance, prop);
+                }
+                else {
+                    throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                }
+            },
+        });
+        return proxy;
+    }
+}
+
+const PROXYDI = Symbol('ProxyDI');
+const PROXYDI_ID = Symbol('ProxyDI_ID');
+class ProxyDI {
+    constructor(settings) {
+        this.children = {};
+        this.instances = {};
+        this.classes = {};
+        this.proxies = {};
+        this.allowRewriteClasses = false;
+        this.allowRewriteInstances = false;
+        this.proxyFactory = new ProxyFactory(this);
+        this.id = ProxyDI.idCounter++;
+        if (settings === null || settings === undefined ? undefined : settings.parent) {
+            this.parent = settings.parent;
+            this.parent.addChild(this);
+        }
+        if ((settings === null || settings === undefined ? undefined : settings.allowRewriteClasses) !== undefined) {
+            this.allowRewriteClasses = settings.allowRewriteClasses;
+        }
+        if ((settings === null || settings === undefined ? undefined : settings.allowRewriteInstances) !== undefined) {
+            this.allowRewriteInstances = settings.allowRewriteInstances;
+        }
+    }
+    registerInstance(serviceId, instance) {
+        if (this.instances[serviceId]) {
+            if (!this.allowRewriteInstances) {
+                throw new Error(`ProxyDI already has registered instance for ${serviceId}`);
+            }
+        }
+        this.injectDependencies(instance);
+        if (typeof instance === 'object') {
+            instance[PROXYDI_ID] = serviceId;
+        }
+        this.instances[serviceId] = instance;
+    }
+    registerClass(serviceId, serviceClass) {
+        if (this.classes[serviceId]) {
+            if (!this.allowRewriteClasses) {
+                throw new Error(`ProxyDI already has registered class for ${serviceId}`);
+            }
+        }
+        this.classes[serviceId] = serviceClass;
+    }
+    findInstance(serviceId) {
+        const instance = this.instances[serviceId];
+        if (!instance && this.parent) {
+            return this.parent.findInstance(serviceId);
+        }
+        return instance;
+    }
+    isKnown(serviceId) {
+        return !!(this.findInstance(serviceId) || this.findDefiner(serviceId));
+    }
+    resolve(serviceId) {
+        if (!this.isKnown(serviceId)) {
+            throw new Error(`Can't resolve unknown ProxyDI-service: ${serviceId}`);
+        }
+        const instance = this.findInstance(serviceId);
+        if (instance) {
+            return instance;
+        }
+        const definer = this.findDefiner(serviceId);
+        if (definer) {
+            let instance = new definer();
+            this.injectDependencies(instance);
+            instance[PROXYDI_ID] = serviceId;
+            this.instances[serviceId] = instance;
+            return instance;
+        }
+        else {
+            return this.getProxy(serviceId);
+        }
+    }
+    findDefiner(serviceId) {
+        let definer = this.classes[serviceId];
+        if (!definer && this.parent) {
+            return this.parent.findDefiner(serviceId);
+        }
+        if (!definer) {
+            return injectableClasses[serviceId];
+        }
+        return definer;
+    }
+    injectDependencies(instance) {
+        const serviceInjects = instance[INJECTS] || [];
+        serviceInjects.forEach((inject) => {
+            let value = this.findInstance(inject.serviceId);
+            if (!value) {
+                value = this.getProxy(inject.serviceId);
+            }
+            inject.set(instance, value);
+        });
+        if (typeof instance === 'object') {
+            instance[PROXYDI] = this;
+        }
+    }
+    getProxy(serviceId) {
+        let proxy = this.proxies[serviceId];
+        if (!proxy) {
+            proxy = this.proxyFactory.makeProxy(serviceId);
+            this.proxies[serviceId] = proxy;
+        }
+        return proxy;
+    }
+    createChildContainer(settings) {
+        const childSettings = Object.assign(Object.assign({}, settings), { parent: this });
+        return new ProxyDI(childSettings);
+    }
+    removeInstance(serviceId) {
+        const id = serviceId[PROXYDI_ID]
+            ? serviceId[PROXYDI_ID]
+            : serviceId;
+        const instance = this.instances[id];
+        if (instance) {
+            const serviceInjects = instance[INJECTS] || [];
+            serviceInjects.forEach((inject) => {
+                inject.set(instance, undefined);
+            });
+            delete instance[PROXYDI];
+            delete instance[PROXYDI_ID];
+            delete this.instances[serviceId];
+        }
+    }
+    removeClass(serviceId) {
+        delete this.classes[serviceId];
+    }
+    destroy() {
+        const allServices = Object.keys(this.instances);
+        for (const serviceId of allServices) {
+            const instance = this.instances[serviceId];
+            this.removeInstance(instance);
+        }
+        this.instances = {};
+        this.proxies = {};
+        this.classes = {};
+        for (const id of Object.keys(this.children)) {
+            const child = this.children[+id];
+            child.destroy();
+        }
+        this.children = {};
+        this.proxyFactory = undefined;
+        if (this.parent) {
+            this.parent.removeChild(this.id);
+            this.parent = undefined;
+        }
+    }
+    addChild(child) {
+        if (this.children[child.id]) {
+            throw new Error(`ProxyDI already has child with id ${child.id}`);
+        }
+        this.children[child.id] = child;
+    }
+    removeChild(id) {
+        const child = this.children[id];
+        if (child) {
+            delete this.children[id];
+        }
+    }
+}
+ProxyDI.idCounter = 0;
+
+export { ProxyDI, inject };

package/dist/index.umd.js

@@ -0,0 +1,236 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.YourLibraryName = {}));
+})(this, (function (exports) { 'use strict';
+
+    const INJECTS = Symbol('injects');
+    const inject = (serviceId) => {
+        return function (_value, context) {
+            if ((context === null || context === undefined ? undefined : context.kind) === 'field') {
+                const name = serviceId ? serviceId : context.name;
+                const inject = {
+                    property: context.name,
+                    serviceId: name,
+                    set: context.access.set,
+                };
+                context.addInitializer(function () {
+                    if (!this[INJECTS]) {
+                        this[INJECTS] = [];
+                    }
+                    this[INJECTS].push(inject);
+                });
+            }
+        };
+    };
+
+    const injectableClasses = {};
+
+    const IS_PROXY = Symbol('isProxy');
+    class ProxyFactory {
+        constructor(container) {
+            this.container = container;
+        }
+        makeProxy(serviceId) {
+            const self = this;
+            const proxy = new Proxy({ [IS_PROXY]: true }, {
+                get: function (target, prop, receiver) {
+                    if (target[prop]) {
+                        return target[prop];
+                    }
+                    if (self.container.isKnown(serviceId)) {
+                        const instance = self.container.resolve(serviceId);
+                        return Reflect.get(instance, prop, receiver);
+                    }
+                    else {
+                        throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                    }
+                },
+                set: function (target, prop, value) {
+                    if (self.container.isKnown(serviceId)) {
+                        const instance = self.container.resolve(serviceId);
+                        return Reflect.set(instance, prop, value);
+                    }
+                    else {
+                        throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                    }
+                },
+                has: function (target, prop) {
+                    if (self.container.isKnown(serviceId)) {
+                        const instance = self.container.resolve(serviceId);
+                        return Reflect.has(instance, prop);
+                    }
+                    else {
+                        throw new Error(`Unknown ProxyDI-service: ${serviceId}`);
+                    }
+                },
+            });
+            return proxy;
+        }
+    }
+
+    const PROXYDI = Symbol('ProxyDI');
+    const PROXYDI_ID = Symbol('ProxyDI_ID');
+    class ProxyDI {
+        constructor(settings) {
+            this.children = {};
+            this.instances = {};
+            this.classes = {};
+            this.proxies = {};
+            this.allowRewriteClasses = false;
+            this.allowRewriteInstances = false;
+            this.proxyFactory = new ProxyFactory(this);
+            this.id = ProxyDI.idCounter++;
+            if (settings === null || settings === undefined ? undefined : settings.parent) {
+                this.parent = settings.parent;
+                this.parent.addChild(this);
+            }
+            if ((settings === null || settings === undefined ? undefined : settings.allowRewriteClasses) !== undefined) {
+                this.allowRewriteClasses = settings.allowRewriteClasses;
+            }
+            if ((settings === null || settings === undefined ? undefined : settings.allowRewriteInstances) !== undefined) {
+                this.allowRewriteInstances = settings.allowRewriteInstances;
+            }
+        }
+        registerInstance(serviceId, instance) {
+            if (this.instances[serviceId]) {
+                if (!this.allowRewriteInstances) {
+                    throw new Error(`ProxyDI already has registered instance for ${serviceId}`);
+                }
+            }
+            this.injectDependencies(instance);
+            if (typeof instance === 'object') {
+                instance[PROXYDI_ID] = serviceId;
+            }
+            this.instances[serviceId] = instance;
+        }
+        registerClass(serviceId, serviceClass) {
+            if (this.classes[serviceId]) {
+                if (!this.allowRewriteClasses) {
+                    throw new Error(`ProxyDI already has registered class for ${serviceId}`);
+                }
+            }
+            this.classes[serviceId] = serviceClass;
+        }
+        findInstance(serviceId) {
+            const instance = this.instances[serviceId];
+            if (!instance && this.parent) {
+                return this.parent.findInstance(serviceId);
+            }
+            return instance;
+        }
+        isKnown(serviceId) {
+            return !!(this.findInstance(serviceId) || this.findDefiner(serviceId));
+        }
+        resolve(serviceId) {
+            if (!this.isKnown(serviceId)) {
+                throw new Error(`Can't resolve unknown ProxyDI-service: ${serviceId}`);
+            }
+            const instance = this.findInstance(serviceId);
+            if (instance) {
+                return instance;
+            }
+            const definer = this.findDefiner(serviceId);
+            if (definer) {
+                let instance = new definer();
+                this.injectDependencies(instance);
+                instance[PROXYDI_ID] = serviceId;
+                this.instances[serviceId] = instance;
+                return instance;
+            }
+            else {
+                return this.getProxy(serviceId);
+            }
+        }
+        findDefiner(serviceId) {
+            let definer = this.classes[serviceId];
+            if (!definer && this.parent) {
+                return this.parent.findDefiner(serviceId);
+            }
+            if (!definer) {
+                return injectableClasses[serviceId];
+            }
+            return definer;
+        }
+        injectDependencies(instance) {
+            const serviceInjects = instance[INJECTS] || [];
+            serviceInjects.forEach((inject) => {
+                let value = this.findInstance(inject.serviceId);
+                if (!value) {
+                    value = this.getProxy(inject.serviceId);
+                }
+                inject.set(instance, value);
+            });
+            if (typeof instance === 'object') {
+                instance[PROXYDI] = this;
+            }
+        }
+        getProxy(serviceId) {
+            let proxy = this.proxies[serviceId];
+            if (!proxy) {
+                proxy = this.proxyFactory.makeProxy(serviceId);
+                this.proxies[serviceId] = proxy;
+            }
+            return proxy;
+        }
+        createChildContainer(settings) {
+            const childSettings = Object.assign(Object.assign({}, settings), { parent: this });
+            return new ProxyDI(childSettings);
+        }
+        removeInstance(serviceId) {
+            const id = serviceId[PROXYDI_ID]
+                ? serviceId[PROXYDI_ID]
+                : serviceId;
+            const instance = this.instances[id];
+            if (instance) {
+                const serviceInjects = instance[INJECTS] || [];
+                serviceInjects.forEach((inject) => {
+                    inject.set(instance, undefined);
+                });
+                delete instance[PROXYDI];
+                delete instance[PROXYDI_ID];
+                delete this.instances[serviceId];
+            }
+        }
+        removeClass(serviceId) {
+            delete this.classes[serviceId];
+        }
+        destroy() {
+            const allServices = Object.keys(this.instances);
+            for (const serviceId of allServices) {
+                const instance = this.instances[serviceId];
+                this.removeInstance(instance);
+            }
+            this.instances = {};
+            this.proxies = {};
+            this.classes = {};
+            for (const id of Object.keys(this.children)) {
+                const child = this.children[+id];
+                child.destroy();
+            }
+            this.children = {};
+            this.proxyFactory = undefined;
+            if (this.parent) {
+                this.parent.removeChild(this.id);
+                this.parent = undefined;
+            }
+        }
+        addChild(child) {
+            if (this.children[child.id]) {
+                throw new Error(`ProxyDI already has child with id ${child.id}`);
+            }
+            this.children[child.id] = child;
+        }
+        removeChild(id) {
+            const child = this.children[id];
+            if (child) {
+                delete this.children[id];
+            }
+        }
+    }
+    ProxyDI.idCounter = 0;
+
+    exports.ProxyDI = ProxyDI;
+    exports.inject = inject;
+
+}));

package/dist/inject.d.ts

@@ -0,0 +1,3 @@
+import { ServiceId } from './types';
+export declare const INJECTS: unique symbol;
+export declare const inject: (serviceId?: ServiceId) => (_value: unknown, context: ClassFieldDecoratorContext) => void;

package/dist/injectable.d.ts

@@ -0,0 +1,3 @@
+import { ServiceClass, ServiceId } from './types';
+export declare const injectableClasses: Record<ServiceId, ServiceClass<any>>;
+export declare const injectable: (serviceId?: ServiceId) => (value: ServiceClass<any>, context: ClassDecoratorContext) => void;

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+import { ProxyDI } from './ProxyDI';
+export type ServiceId = any;
+export type ServiceConstructor<T extends unknown> = new () => T;
+export type Setter = (object: unknown, value: unknown) => void;
+export type Inject = {
+    property: string | symbol;
+    serviceId: ServiceId;
+    set: Setter;
+};
+export type ServiceClass<T> = new (...args: any[]) => T;
+export type ProxyDISettings = {
+    parent?: ProxyDI;
+    allowRewriteClasses?: boolean;
+    allowRewriteInstances?: boolean;
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+    "name": "proxydi",
+    "version": "0.0.3",
+    "description": "A typed DI container that resolves circular dependencies via Proxy",
+    "type": "module",
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "scripts": {
+        "build": "rollup -c",
+        "dev": "rollup -c -w",
+        "test": "vitest",
+        "lint": "eslint src --ext .ts",
+        "format": "prettier --write \"src/**/*.ts\"",
+        "prepare": "npm run build",
+        "coverage": "vitest run --coverage"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/proxy-di/proxydi.git"
+    },
+    "keywords": [
+        "DI",
+        "DI-container",
+        "dependency-injection",
+        "dependency-injection-container",
+        "injector",
+        "ioc",
+        "inversion-of-control",
+        "proxy",
+        "typescript"
+    ],
+    "author": "Yolziii",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/proxy-di/proxydi/issues"
+    },
+    "homepage": "https://github.com/proxy-di/proxydi#readme",
+    "devDependencies": {
+        "@rollup/plugin-typescript": "^12.1.2",
+        "@typescript-eslint/eslint-plugin": "^8.22.0",
+        "@typescript-eslint/parser": "^8.22.0",
+        "@vitest/coverage-v8": "^3.0.4",
+        "eslint": "^9.19.0",
+        "prettier": "^3.4.2",
+        "rollup": "^4.32.1",
+        "typescript": "^5.7.3",
+        "vitest": "^3.0.4"
+    }
+}