mesh-ioc 2.1.0 → 2.2.0

package/out/main/index.d.ts

@@ -2,3 +2,4 @@ export * from './decorators/dep';
 export * from './errors';
 export * from './mesh';
 export * from './types';
+export * from './reflect';

package/out/main/index.js

@@ -14,3 +14,4 @@ __exportStar(require("./decorators/dep"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./mesh"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./reflect"), exports);

package/out/main/reflect.d.ts

@@ -0,0 +1,6 @@
+import { Mesh } from './mesh.js';
+import { ServiceHandler } from './types.js';
+export declare const handlersMap: Map<string, ServiceHandler[]>;
+export declare function createHandlerDecorator(name: string): () => (target: any, methodName: string) => void;
+export declare function findHandlers(mesh: Mesh, name: string, recursive?: boolean): IterableIterator<ServiceHandler>;
+export declare function invokeHandlers(mesh: Mesh, name: string, recursive?: boolean): Promise<void>;

package/out/main/reflect.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeHandlers = exports.findHandlers = exports.createHandlerDecorator = exports.handlersMap = void 0;
+exports.handlersMap = new Map();
+function createHandlerDecorator(name) {
+    var _a;
+    const handlers = (_a = exports.handlersMap.get(name)) !== null && _a !== void 0 ? _a : [];
+    exports.handlersMap.set(name, handlers);
+    return () => {
+        return (target, methodName) => {
+            handlers.push({
+                target: target.constructor,
+                methodName,
+            });
+        };
+    };
+}
+exports.createHandlerDecorator = createHandlerDecorator;
+function* findHandlers(mesh, name, recursive = true) {
+    var _a;
+    const targets = (_a = exports.handlersMap.get(name)) !== null && _a !== void 0 ? _a : [];
+    for (const [key, binding] of mesh.bindings) {
+        if (binding.type === 'service') {
+            for (const t of targets) {
+                if (t.target === binding.class || t.target.isPrototypeOf(binding.class)) {
+                    yield {
+                        target: mesh.resolve(key),
+                        methodName: t.methodName,
+                    };
+                }
+            }
+        }
+    }
+    if (recursive && mesh.parent) {
+        yield* findHandlers(mesh.parent, name, recursive);
+    }
+}
+exports.findHandlers = findHandlers;
+function invokeHandlers(mesh, name, recursive = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const handlers = [...findHandlers(mesh, name, recursive)];
+        const promises = handlers.map(h => h.target[h.methodName]());
+        yield Promise.all(promises);
+    });
+}
+exports.invokeHandlers = invokeHandlers;

package/out/main/types.d.ts

@@ -29,8 +29,7 @@ export interface DepMetadata {
     designTypeName: string;
     key: string;
 }
-export interface ServiceMetadata {
-    class: ServiceConstructor<any>;
-    alias?: string;
-    metadata?: any;
+export interface ServiceHandler {
+    target: any;
+    methodName: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mesh-ioc",
-    "version": "2.1.0",
+    "version": "2.2.0",
     "description": "Mesh: Powerful and Lightweight IoC Library",
     "main": "out/main/index.js",
     "types": "out/main/index.d.ts",

package/out/main/scope.d.ts

@@ -1,11 +0,0 @@
-import { AbstractClass, Binding, ServiceConstructor, ServiceKey } from './types';
-export declare class Scope {
-    readonly name: string;
-    bindings: Map<string, Binding<any>>;
-    constructor(name: string, bindings?: Iterable<[string, Binding<any>]>);
-    [Symbol.iterator](): Generator<[string, Binding<any>], void, undefined>;
-    service<T>(impl: ServiceConstructor<T>): this;
-    service<T>(key: AbstractClass<T> | string, impl: ServiceConstructor<T>): this;
-    constant<T>(key: ServiceKey<T>, value: T): this;
-    alias<T>(key: AbstractClass<T> | string, referenceKey: AbstractClass<T> | string): this;
-}

package/out/main/scope.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Scope = void 0;
-const errors_1 = require("./errors");
-const util_1 = require("./util");
-class Scope {
-    constructor(name, bindings = []) {
-        this.name = name;
-        this.bindings = new Map();
-        for (const [k, v] of bindings) {
-            this.bindings.set(k, v);
-        }
-    }
-    *[Symbol.iterator]() {
-        yield* this.bindings.entries();
-    }
-    service(key, impl) {
-        const k = util_1.keyToString(key);
-        if (typeof impl === 'function') {
-            this.bindings.set(k, { type: 'service', class: impl });
-            return this;
-        }
-        else if (typeof key === 'function') {
-            this.bindings.set(k, { type: 'service', class: key });
-            return this;
-        }
-        throw new errors_1.MeshInvalidBinding(String(key));
-    }
-    constant(key, value) {
-        const k = util_1.keyToString(key);
-        this.bindings.set(k, { type: 'constant', value });
-        return this;
-    }
-    alias(key, referenceKey) {
-        const k = util_1.keyToString(key);
-        const refK = util_1.keyToString(referenceKey);
-        this.bindings.set(k, { type: 'alias', key: refK });
-        return this;
-    }
-}
-exports.Scope = Scope;