@visactor/vrender-core 0.17.0-alpha.1 → 0.17.0-alpha.3

package/cjs/common/inversify/container.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.Container = void 0;
+
+const generator_1 = require("../generator"), binding_1 = require("./binding"), literal_types_1 = require("./literal_types"), metadata_keys_1 = require("./metadata_keys"), metadata_reader_1 = require("./metadata_reader"), binding_to_syntax_1 = require("./syntax/binding_to_syntax");
+
+class Container {
+    constructor(containerOptions) {
+        const options = containerOptions || {};
+        options.defaultScope = options.defaultScope || literal_types_1.BindingScopeEnum.Transient, 
+        this.options = options, this.id = generator_1.Generator.GenAutoIncrementId(), this._bindingDictionary = new Map, 
+        this._metadataReader = new metadata_reader_1.MetadataReader;
+    }
+    load(module) {
+        const containerModuleHelpers = this._getContainerModuleHelpersFactory()(module.id);
+        module.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction);
+    }
+    get(serviceIdentifier) {
+        const getArgs = this._getNotAllArgs(serviceIdentifier, !1);
+        return this._get(getArgs);
+    }
+    getAll(serviceIdentifier) {
+        const getArgs = this._getAllArgs(serviceIdentifier);
+        return this._get(getArgs);
+    }
+    getTagged(serviceIdentifier, key, value) {
+        const getArgs = this._getNotAllArgs(serviceIdentifier, !1, key, value);
+        return this._get(getArgs);
+    }
+    getNamed(serviceIdentifier, named) {
+        return this.getTagged(serviceIdentifier, metadata_keys_1.NAMED_TAG, named);
+    }
+    isBound(serviceIdentifier) {
+        return this._bindingDictionary.has(serviceIdentifier);
+    }
+    bind(serviceIdentifier) {
+        const scope = this.options.defaultScope, binding = new binding_1.Binding(serviceIdentifier, scope), list = this._bindingDictionary.get(serviceIdentifier) || [];
+        return list.push(binding), this._bindingDictionary.set(serviceIdentifier, list), 
+        new binding_to_syntax_1.BindingToSyntax(binding);
+    }
+    unbind(serviceIdentifier) {
+        this._bindingDictionary.delete(serviceIdentifier);
+    }
+    rebind(serviceIdentifier) {
+        return this.unbind(serviceIdentifier), this.bind(serviceIdentifier);
+    }
+    _getContainerModuleHelpersFactory() {
+        const setModuleId = (bindingToSyntax, moduleId) => {
+            bindingToSyntax._binding.moduleId = moduleId;
+        }, getBindFunction = moduleId => serviceIdentifier => {
+            const bindingToSyntax = this.bind(serviceIdentifier);
+            return setModuleId(bindingToSyntax, moduleId), bindingToSyntax;
+        }, getUnbindFunction = () => serviceIdentifier => this.unbind(serviceIdentifier), getIsboundFunction = () => serviceIdentifier => this.isBound(serviceIdentifier), getRebindFunction = moduleId => serviceIdentifier => {
+            const bindingToSyntax = this.rebind(serviceIdentifier);
+            return setModuleId(bindingToSyntax, moduleId), bindingToSyntax;
+        };
+        return mId => ({
+            bindFunction: getBindFunction(mId),
+            isboundFunction: getIsboundFunction(),
+            rebindFunction: getRebindFunction(mId),
+            unbindFunction: getUnbindFunction(),
+            unbindAsyncFunction: serviceIdentifier => null
+        });
+    }
+    _getNotAllArgs(serviceIdentifier, isMultiInject, key, value) {
+        return {
+            avoidConstraints: !1,
+            isMultiInject: isMultiInject,
+            serviceIdentifier: serviceIdentifier,
+            key: key,
+            value: value
+        };
+    }
+    _getAllArgs(serviceIdentifier) {
+        return {
+            avoidConstraints: !0,
+            isMultiInject: !0,
+            serviceIdentifier: serviceIdentifier
+        };
+    }
+    _get(getArgs) {
+        const result = [];
+        return this._bindingDictionary.get(getArgs.serviceIdentifier).forEach((binding => {
+            result.push(this._resolveFromBinding(binding));
+        })), getArgs.isMultiInject || 1 !== result.length ? result : result[0];
+    }
+    _getChildRequest(binding) {
+        const constr = binding.implementationType, {userGeneratedMetadata: userGeneratedMetadata} = this._metadataReader.getConstructorMetadata(constr), keys = Object.keys(userGeneratedMetadata), arr = [];
+        for (let i = 0; i < keys.length; i++) {
+            const constructorArgsMetadata = userGeneratedMetadata[i], targetMetadataMap = {};
+            constructorArgsMetadata.forEach((md => {
+                targetMetadataMap[md.key] = md.value;
+            }));
+            const metadata = {
+                inject: targetMetadataMap[metadata_keys_1.INJECT_TAG],
+                multiInject: targetMetadataMap[metadata_keys_1.MULTI_INJECT_TAG]
+            }, injectIdentifier = metadata.inject || metadata.multiInject, target = {
+                serviceIdentifier: injectIdentifier,
+                constructorArgsMetadata: constructorArgsMetadata
+            }, request = {
+                injectIdentifier: injectIdentifier,
+                metadata: constructorArgsMetadata,
+                bindings: this._bindingDictionary.get(injectIdentifier).filter((b => b.constraint(target)))
+            };
+            arr.push(request);
+        }
+        return arr;
+    }
+    _resolveFromBinding(binding) {
+        const result = this._getResolvedFromBinding(binding);
+        return this._saveToScope(binding, result), result;
+    }
+    _getResolvedFromBinding(binding) {
+        let result;
+        switch (binding.type) {
+          case literal_types_1.BindingTypeEnum.ConstantValue:
+          case literal_types_1.BindingTypeEnum.Function:
+            result = binding.cache;
+            break;
+
+          case literal_types_1.BindingTypeEnum.Instance:
+            result = this._resolveInstance(binding, binding.implementationType);
+            break;
+
+          default:
+            result = binding.dynamicValue({
+                container: this
+            });
+        }
+        return result;
+    }
+    _resolveInstance(binding, constr) {
+        if (binding.activated) return binding.cache;
+        const childRequests = this._getChildRequest(binding);
+        return this._createInstance(constr, childRequests);
+    }
+    _createInstance(constr, childRequests) {
+        if (childRequests.length) {
+            return new constr(...this._resolveRequests(childRequests));
+        }
+        return new constr;
+    }
+    _resolveRequests(childRequests) {
+        return childRequests.map((request => request.bindings.length > 1 ? request.bindings.map((binding => this._resolveFromBinding(binding))) : this._resolveFromBinding(request.bindings[0])));
+    }
+    _saveToScope(binding, result) {
+        binding.scope === literal_types_1.BindingScopeEnum.Singleton && (binding.cache = result, 
+        binding.activated = !0);
+    }
+}
+
+exports.Container = Container;
+//# sourceMappingURL=container.js.map

package/cjs/common/inversify/container.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/inversify/container.ts"],"names":[],"mappings":"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","file":"container.js","sourcesContent":["import { Generator } from '../generator';\nimport { Binding } from './binding';\nimport type { interfaces } from './interfaces';\nimport { BindingScopeEnum, BindingTypeEnum } from './literal_types';\nimport { Metadata } from './meta-data';\nimport { INJECT_TAG, MULTI_INJECT_TAG, NAMED_TAG } from './metadata_keys';\nimport { MetadataReader } from './metadata_reader';\nimport { BindingToSyntax } from './syntax/binding_to_syntax';\n\ninterface IChildRequest {\n  injectIdentifier: any;\n  metadata: interfaces.Metadata<unknown>[];\n  bindings: Binding<unknown>[];\n}\n\ninterface GetArgs<T> {\n  avoidConstraints: boolean;\n  isMultiInject: boolean;\n  serviceIdentifier: interfaces.ServiceIdentifier<T>;\n  key: string | symbol;\n  value: any;\n}\n\nexport class Container {\n  id: number;\n  readonly options: interfaces.ContainerOptions;\n  private _bindingDictionary: Map<any, Binding<unknown>[]>;\n  private _metadataReader: interfaces.MetadataReader;\n\n  constructor(containerOptions?: interfaces.ContainerOptions) {\n    const options = containerOptions || {};\n    options.defaultScope = options.defaultScope || BindingScopeEnum.Transient;\n    // console.log(this);\n    this.options = options;\n    this.id = Generator.GenAutoIncrementId();\n    this._bindingDictionary = new Map();\n    this._metadataReader = new MetadataReader();\n  }\n\n  load(module: interfaces.ContainerModule) {\n    const getHelpers = this._getContainerModuleHelpersFactory();\n\n    const containerModuleHelpers = getHelpers(module.id);\n\n    module.registry(\n      containerModuleHelpers.bindFunction as interfaces.Bind,\n      containerModuleHelpers.unbindFunction,\n      containerModuleHelpers.isboundFunction,\n      containerModuleHelpers.rebindFunction as interfaces.Rebind\n    );\n  }\n\n  get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T {\n    const getArgs = this._getNotAllArgs(serviceIdentifier, false);\n\n    return this._get<T>(getArgs) as T;\n  }\n\n  getAll<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T[] {\n    const getArgs = this._getAllArgs(serviceIdentifier);\n\n    return this._get<T>(getArgs) as T[];\n  }\n\n  getTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T {\n    const getArgs = this._getNotAllArgs(serviceIdentifier, false, key, value);\n\n    return this._get<T>(getArgs) as T;\n  }\n\n  getNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T {\n    return this.getTagged<T>(serviceIdentifier, NAMED_TAG, named);\n  }\n\n  isBound(serviceIdentifier: interfaces.ServiceIdentifier<unknown>): boolean {\n    return this._bindingDictionary.has(serviceIdentifier);\n  }\n\n  // Registers a type binding\n  bind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T> {\n    const scope = this.options.defaultScope;\n    const binding = new Binding<T>(serviceIdentifier, scope);\n    const list = this._bindingDictionary.get(serviceIdentifier) || [];\n    list.push(binding);\n    this._bindingDictionary.set(serviceIdentifier, list);\n    return new BindingToSyntax<T>(binding);\n  }\n\n  unbind(serviceIdentifier: interfaces.ServiceIdentifier): void {\n    this._bindingDictionary.delete(serviceIdentifier);\n  }\n\n  rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T> {\n    this.unbind(serviceIdentifier);\n    return this.bind(serviceIdentifier);\n  }\n\n  private _getContainerModuleHelpersFactory() {\n    const setModuleId = (\n      bindingToSyntax: interfaces.BindingToSyntax<unknown>,\n      moduleId: interfaces.ContainerModuleBase['id']\n    ) => {\n      // TODO: Implement an internal type `_BindingToSyntax<T>` wherein this member\n      // can be public. Let `BindingToSyntax<T>` be the presentational type that\n      // depends on it, and does not expose this member as public.\n      (\n        bindingToSyntax as unknown as { _binding: { moduleId: interfaces.ContainerModuleBase['id'] } }\n      )._binding.moduleId = moduleId;\n    };\n\n    const getBindFunction =\n      <T>(moduleId: interfaces.ContainerModuleBase['id']) =>\n      (serviceIdentifier: interfaces.ServiceIdentifier) => {\n        const bindingToSyntax = this.bind(serviceIdentifier);\n        setModuleId(bindingToSyntax, moduleId);\n        return bindingToSyntax as BindingToSyntax<T>;\n      };\n\n    const getUnbindFunction = () => (serviceIdentifier: interfaces.ServiceIdentifier) => {\n      return this.unbind(serviceIdentifier);\n    };\n\n    const getUnbindAsyncFunction = () => (serviceIdentifier: interfaces.ServiceIdentifier) => {\n      return null as any;\n      // return this.unbindAsync(serviceIdentifier);\n    };\n\n    const getIsboundFunction = () => (serviceIdentifier: interfaces.ServiceIdentifier) => {\n      return this.isBound(serviceIdentifier);\n    };\n\n    const getRebindFunction =\n      <T = unknown>(moduleId: interfaces.ContainerModuleBase['id']) =>\n      (serviceIdentifier: interfaces.ServiceIdentifier) => {\n        const bindingToSyntax = this.rebind(serviceIdentifier);\n        setModuleId(bindingToSyntax, moduleId);\n        return bindingToSyntax as BindingToSyntax<T>;\n      };\n    return (mId: interfaces.ContainerModuleBase['id']) => ({\n      bindFunction: getBindFunction(mId),\n      isboundFunction: getIsboundFunction(),\n      rebindFunction: getRebindFunction(mId),\n      unbindFunction: getUnbindFunction(),\n      unbindAsyncFunction: getUnbindAsyncFunction()\n    });\n  }\n\n  private _getNotAllArgs<T>(\n    serviceIdentifier: interfaces.ServiceIdentifier<T>,\n    isMultiInject: boolean,\n    key?: string | number | symbol | undefined,\n    value?: unknown\n  ): any {\n    return {\n      avoidConstraints: false,\n      isMultiInject,\n      serviceIdentifier,\n      key,\n      value\n    };\n  }\n\n  private _getAllArgs<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): any {\n    return {\n      avoidConstraints: true,\n      isMultiInject: true,\n      serviceIdentifier\n    };\n  }\n\n  private _get<T>(getArgs: GetArgs<T>): T | T[] {\n    const result: T[] = [];\n    const bindings = this._bindingDictionary.get(getArgs.serviceIdentifier) as Binding<T>[];\n    bindings.forEach(binding => {\n      result.push(this._resolveFromBinding<T>(binding));\n    });\n\n    return !getArgs.isMultiInject && result.length === 1 ? result[0] : result;\n  }\n\n  private _getChildRequest(binding: Binding<unknown>) {\n    const constr = binding.implementationType;\n    const { userGeneratedMetadata } = this._metadataReader.getConstructorMetadata(constr as any);\n    const keys = Object.keys(userGeneratedMetadata);\n    const arr = [];\n    for (let i = 0; i < keys.length; i++) {\n      const constructorArgsMetadata = userGeneratedMetadata[i];\n      const targetMetadataMap = {};\n      constructorArgsMetadata.forEach(md => {\n        targetMetadataMap[md.key] = md.value;\n      });\n      const metadata = {\n        inject: targetMetadataMap[INJECT_TAG],\n        multiInject: targetMetadataMap[MULTI_INJECT_TAG]\n      };\n      const injectIdentifier = metadata.inject || metadata.multiInject;\n      const target = {\n        serviceIdentifier: injectIdentifier,\n        constructorArgsMetadata\n      };\n      const bindings = this._bindingDictionary.get(injectIdentifier).filter(b => {\n        return b.constraint(target as any);\n      });\n      const request = {\n        injectIdentifier,\n        metadata: constructorArgsMetadata,\n        bindings\n      };\n\n      arr.push(request);\n    }\n\n    return arr;\n  }\n\n  private _resolveFromBinding<T>(binding: Binding<T>): T {\n    const result = this._getResolvedFromBinding<T>(binding);\n\n    this._saveToScope(binding, result);\n\n    return result;\n  }\n\n  private _getResolvedFromBinding<T>(binding: Binding<T>) {\n    let result: T;\n    switch (binding.type) {\n      case BindingTypeEnum.ConstantValue:\n      case BindingTypeEnum.Function:\n        result = binding.cache as T;\n        break;\n      case BindingTypeEnum.Instance:\n        result = this._resolveInstance<T>(binding, binding.implementationType as interfaces.Newable<T>);\n        break;\n      default:\n        result = binding.dynamicValue({ container: this } as any);\n    }\n\n    return result;\n  }\n\n  private _resolveInstance<T>(binding: Binding<T>, constr: interfaces.Newable<T>): T {\n    if (binding.activated) {\n      return binding.cache;\n    }\n\n    const childRequests = this._getChildRequest(binding);\n    return this._createInstance(constr, childRequests);\n  }\n\n  private _createInstance<T>(constr: interfaces.Newable<T>, childRequests: IChildRequest[]) {\n    if (childRequests.length) {\n      const resolved = this._resolveRequests(childRequests);\n      const obj = new constr(...resolved);\n      return obj;\n    }\n    const obj = new constr();\n    return obj;\n  }\n\n  private _resolveRequests(childRequests: IChildRequest[]): any[] {\n    return childRequests.map(request => {\n      return request.bindings.length > 1\n        ? request.bindings.map(binding => this._resolveFromBinding(binding))\n        : this._resolveFromBinding(request.bindings[0]);\n    });\n  }\n\n  private _saveToScope(binding: Binding<unknown>, result: any) {\n    if (binding.scope === BindingScopeEnum.Singleton) {\n      binding.cache = result;\n      binding.activated = true;\n    }\n  }\n}\n"]}

package/cjs/common/inversify/cotainer-module.d.ts

@@ -0,0 +1,6 @@
+import type { interfaces } from '../inversify-lite';
+export declare class ContainerModule {
+    id: number;
+    registry: interfaces.ContainerModuleCallBack;
+    constructor(registry: interfaces.ContainerModuleCallBack);
+}

package/cjs/common/inversify/cotainer-module.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.ContainerModule = void 0;
+
+const generator_1 = require("../generator");
+
+class ContainerModule {
+    constructor(registry) {
+        this.id = generator_1.Generator.GenAutoIncrementId(), this.registry = registry;
+    }
+}
+
+exports.ContainerModule = ContainerModule;
+//# sourceMappingURL=cotainer-module.js.map

package/cjs/common/inversify/cotainer-module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/inversify/cotainer-module.ts"],"names":[],"mappings":";;;AAAA,4CAAyC;AAGzC,MAAa,eAAe;IAI1B,YAAY,QAA4C;QACtD,IAAI,CAAC,EAAE,GAAG,qBAAS,CAAC,kBAAkB,EAAE,CAAC;QACzC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;CACF;AARD,0CAQC","file":"cotainer-module.js","sourcesContent":["import { Generator } from '../generator';\nimport type { interfaces } from '../inversify-lite';\n\nexport class ContainerModule {\n  id: number;\n  registry: interfaces.ContainerModuleCallBack;\n\n  constructor(registry: interfaces.ContainerModuleCallBack) {\n    this.id = Generator.GenAutoIncrementId();\n    this.registry = registry;\n  }\n}\n"]}

package/cjs/common/inversify/index.d.ts

@@ -0,0 +1,7 @@
+export { ContainerModule } from './cotainer-module';
+export { inject } from './annotation/inject';
+export { multiInject } from './annotation/multi_inject';
+export { injectable } from './annotation/injectable';
+export { named } from './annotation/named';
+export { Container } from './container';
+export * from './interfaces';

package/cjs/common/inversify/index.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k);
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    desc && !("get" in desc ? !m.__esModule : desc.writable || desc.configurable) || (desc = {
+        enumerable: !0,
+        get: function() {
+            return m[k];
+        }
+    }), Object.defineProperty(o, k2, desc);
+} : function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k), o[k2] = m[k];
+}), __exportStar = this && this.__exportStar || function(m, exports) {
+    for (var p in m) "default" === p || Object.prototype.hasOwnProperty.call(exports, p) || __createBinding(exports, m, p);
+};
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.Container = exports.named = exports.injectable = exports.multiInject = exports.inject = exports.ContainerModule = void 0;
+
+var cotainer_module_1 = require("./cotainer-module");
+
+Object.defineProperty(exports, "ContainerModule", {
+    enumerable: !0,
+    get: function() {
+        return cotainer_module_1.ContainerModule;
+    }
+});
+
+var inject_1 = require("./annotation/inject");
+
+Object.defineProperty(exports, "inject", {
+    enumerable: !0,
+    get: function() {
+        return inject_1.inject;
+    }
+});
+
+var multi_inject_1 = require("./annotation/multi_inject");
+
+Object.defineProperty(exports, "multiInject", {
+    enumerable: !0,
+    get: function() {
+        return multi_inject_1.multiInject;
+    }
+});
+
+var injectable_1 = require("./annotation/injectable");
+
+Object.defineProperty(exports, "injectable", {
+    enumerable: !0,
+    get: function() {
+        return injectable_1.injectable;
+    }
+});
+
+var named_1 = require("./annotation/named");
+
+Object.defineProperty(exports, "named", {
+    enumerable: !0,
+    get: function() {
+        return named_1.named;
+    }
+});
+
+var container_1 = require("./container");
+
+Object.defineProperty(exports, "Container", {
+    enumerable: !0,
+    get: function() {
+        return container_1.Container;
+    }
+}), __exportStar(require("./interfaces"), exports);
+//# sourceMappingURL=index.js.map

package/cjs/common/inversify/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/inversify/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AA0BA,qDAAoD;AAA3C,kHAAA,eAAe,OAAA;AACxB,8CAA6C;AAApC,gGAAA,MAAM,OAAA;AACf,0DAAwD;AAA/C,2GAAA,WAAW,OAAA;AACpB,sDAAqD;AAA5C,wGAAA,UAAU,OAAA;AACnB,4CAA2C;AAAlC,8FAAA,KAAK,OAAA;AACd,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAElB,+CAA6B","file":"index.js","sourcesContent":["/**\n * 该文件夹下所有文件来源于inversify\n * https://github.com/inversify/InversifyJS\n * The MIT License (MIT)\n\nCopyright (c) 2015-2017 Remo H. Jansen\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n */\n\nexport { ContainerModule } from './cotainer-module';\nexport { inject } from './annotation/inject';\nexport { multiInject } from './annotation/multi_inject';\nexport { injectable } from './annotation/injectable';\nexport { named } from './annotation/named';\nexport { Container } from './container';\n// export { postConstruct } from './annotation/post_construct';\nexport * from './interfaces';\n"]}

package/cjs/common/inversify/interfaces.d.ts

@@ -0,0 +1,218 @@
+import { FactoryType } from '../utils/factory_type';
+export declare namespace interfaces {
+    type DynamicValue<T> = (context: interfaces.Context) => T;
+    type ContainerResolution<T> = T | Promise<T> | (T | Promise<T>)[];
+    type BindingScope = 'Singleton' | 'Transient' | 'Request';
+    type BindingType = 'ConstantValue' | 'Constructor' | 'DynamicValue' | 'Factory' | 'Function' | 'Instance' | 'Invalid' | 'Provider';
+    type TargetType = 'ConstructorArgument' | 'ClassProperty' | 'Variable';
+    interface BindingScopeEnum {
+        Singleton: interfaces.BindingScope;
+        Transient: interfaces.BindingScope;
+    }
+    interface BindingTypeEnum {
+        ConstantValue: interfaces.BindingType;
+        Constructor: interfaces.BindingType;
+        DynamicValue: interfaces.BindingType;
+        Factory: interfaces.BindingType;
+        Function: interfaces.BindingType;
+        Instance: interfaces.BindingType;
+        Invalid: interfaces.BindingType;
+        Provider: interfaces.BindingType;
+    }
+    interface TargetTypeEnum {
+        ConstructorArgument: interfaces.TargetType;
+        ClassProperty: interfaces.TargetType;
+        Variable: interfaces.TargetType;
+    }
+    type Newable<T> = new (...args: any[]) => T;
+    type Instance<T> = T & Record<string, () => void>;
+    interface Abstract<T> {
+        prototype: T;
+    }
+    type ServiceIdentifier<T = unknown> = string | symbol | Newable<T> | Abstract<T>;
+    interface Clonable<T> {
+        clone(): T;
+    }
+    type BindingActivation<T = unknown> = (context: interfaces.Context, injectable: T) => T | Promise<T>;
+    type BindingDeactivation<T = unknown> = (injectable: T) => void | Promise<void>;
+    interface Binding<TActivated = unknown> extends Clonable<Binding<TActivated>> {
+        id: number;
+        moduleId: ContainerModuleBase['id'];
+        activated: boolean;
+        serviceIdentifier: ServiceIdentifier<TActivated>;
+        constraint: ConstraintFunction;
+        dynamicValue: DynamicValue<TActivated> | null;
+        scope: BindingScope;
+        type: BindingType;
+        implementationType: Newable<TActivated> | TActivated | null;
+        factory: FactoryCreator<unknown> | null;
+        provider: ProviderCreator<unknown> | null;
+        cache: null | TActivated | Promise<TActivated>;
+    }
+    type SimpleFactory<T, U extends unknown[] = unknown[]> = (...args: U) => T;
+    type MultiFactory<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = (...args: U) => SimpleFactory<T, V>;
+    type Factory<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = SimpleFactory<T, U> | MultiFactory<T, U, V>;
+    type FactoryCreator<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = (context: Context) => Factory<T, U, V>;
+    type AutoNamedFactory<T> = SimpleFactory<T, [string]>;
+    type AutoFactory<T> = SimpleFactory<T, []>;
+    type FactoryTypeFunction<T = unknown> = (context: interfaces.Context) => T | Promise<T>;
+    interface FactoryDetails {
+        factoryType: FactoryType;
+        factory: FactoryTypeFunction | null;
+    }
+    type Provider<T> = (...args: any[]) => ((...args: any[]) => Promise<T>) | Promise<T>;
+    type ProviderCreator<T> = (context: Context) => Provider<T>;
+    interface NextArgs<T = unknown> {
+        avoidConstraints: boolean;
+        contextInterceptor: (contexts: Context) => Context;
+        isMultiInject: boolean;
+        targetType: TargetType;
+        serviceIdentifier: interfaces.ServiceIdentifier<T>;
+        key?: string | number | symbol | undefined;
+        value?: unknown;
+    }
+    type Next = (args: NextArgs) => unknown | unknown[];
+    type Middleware = (next: Next) => Next;
+    type ContextInterceptor = (context: interfaces.Context) => interfaces.Context;
+    interface Context {
+        id: number;
+        container: Container;
+        plan: Plan;
+        currentRequest: Request;
+        addPlan(plan: Plan): void;
+        setCurrentRequest(request: Request): void;
+    }
+    type MetadataOrMetadataArray = Metadata | Metadata[];
+    interface Metadata<TValue = unknown> {
+        key: string | number | symbol;
+        value: TValue;
+    }
+    interface Plan {
+        parentContext: Context;
+        rootRequest: Request;
+    }
+    interface QueryableString {
+        contains(searchString: string): boolean;
+        equals(compareString: string): boolean;
+        value(): string;
+    }
+    type ResolveRequestHandler = (request: interfaces.Request) => unknown;
+    type RequestScope = Map<unknown, unknown>;
+    interface Request {
+        id: number;
+        serviceIdentifier: ServiceIdentifier;
+        parentContext: Context;
+        parentRequest: Request | null;
+        childRequests: Request[];
+        target: Target;
+        bindings: Binding<unknown>[];
+        requestScope: RequestScope | null;
+        addChildRequest(serviceIdentifier: ServiceIdentifier, bindings: Binding<unknown> | Binding<unknown>[], target: Target): Request;
+    }
+    interface Target {
+        id: number;
+        serviceIdentifier: ServiceIdentifier;
+        type: TargetType;
+        name: QueryableString;
+        identifier: string | symbol;
+        metadata: Metadata[];
+        getNamedTag(): interfaces.Metadata<string> | null;
+        getCustomTags(): interfaces.Metadata[] | null;
+        hasTag(key: string | number | symbol): boolean;
+        isArray(): boolean;
+        matchesArray(name: interfaces.ServiceIdentifier): boolean;
+        isNamed(): boolean;
+        isTagged(): boolean;
+        isOptional(): boolean;
+        matchesNamedTag(name: string): boolean;
+        matchesTag(key: string | number | symbol): (value: unknown) => boolean;
+    }
+    interface ContainerOptions {
+        autoBindInjectable?: boolean;
+        defaultScope?: BindingScope | undefined;
+        skipBaseClassChecks?: boolean;
+    }
+    interface Container {
+        id: number;
+        parent: Container | null;
+        options: ContainerOptions;
+        bind<T>(serviceIdentifier: ServiceIdentifier<T>): BindingToSyntax<T>;
+        rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
+        unbind(serviceIdentifier: ServiceIdentifier): void;
+        unbindAll(): void;
+        isBound(serviceIdentifier: ServiceIdentifier): boolean;
+        isCurrentBound<T>(serviceIdentifier: ServiceIdentifier<T>): boolean;
+        isBoundNamed(serviceIdentifier: ServiceIdentifier, named: string | number | symbol): boolean;
+        isBoundTagged(serviceIdentifier: ServiceIdentifier, key: string | number | symbol, value: unknown): boolean;
+        get<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+        getNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T;
+        getTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T;
+        getAll<T>(serviceIdentifier: ServiceIdentifier<T>): T[];
+        getAllTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T[];
+        getAllNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T[];
+        getAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<T>;
+        resolve<T>(constructorFunction: interfaces.Newable<T>): T;
+        load(...modules: ContainerModule[]): void;
+        unload(...modules: ContainerModuleBase[]): void;
+        applyCustomMetadataReader(metadataReader: MetadataReader): void;
+    }
+    type Bind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
+    type Rebind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
+    type Unbind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => void;
+    type UnbindAsync = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => Promise<void>;
+    type IsBound = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => boolean;
+    interface ContainerModuleBase {
+        id: number;
+    }
+    interface ContainerModule extends ContainerModuleBase {
+        registry: ContainerModuleCallBack;
+    }
+    interface ModuleActivationHandlers {
+        onActivations: Lookup<BindingActivation<unknown>>;
+        onDeactivations: Lookup<BindingDeactivation<unknown>>;
+    }
+    type ContainerModuleCallBack = (bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind) => void;
+    interface Lookup<T> extends Clonable<Lookup<T>> {
+        add(serviceIdentifier: ServiceIdentifier, value: T): void;
+        getMap(): Map<interfaces.ServiceIdentifier, T[]>;
+        get(serviceIdentifier: ServiceIdentifier): T[];
+        remove(serviceIdentifier: interfaces.ServiceIdentifier): void;
+        removeByCondition(condition: (item: T) => boolean): T[];
+        removeIntersection(lookup: interfaces.Lookup<T>): void;
+        hasKey(serviceIdentifier: ServiceIdentifier): boolean;
+        clone(): Lookup<T>;
+        traverse(func: (key: interfaces.ServiceIdentifier, value: T[]) => void): void;
+    }
+    interface BindingOnSyntax<T> {
+    }
+    interface BindingInSyntax<T> {
+        inSingletonScope(): BindingInSyntax<T>;
+        inTransientScope(): BindingInSyntax<T>;
+        whenTargetNamed(name: string | number | symbol): BindingOnSyntax<T>;
+    }
+    interface BindingInWhenOnSyntax<T> extends BindingInSyntax<T>, BindingInSyntax<T> {
+    }
+    interface BindingToSyntax<T> {
+        to(constructor: Newable<T>): BindingInWhenOnSyntax<T>;
+        toSelf(): BindingInWhenOnSyntax<T>;
+        toConstantValue(value: T): BindingInWhenOnSyntax<T>;
+        toDynamicValue(func: DynamicValue<T>): BindingInWhenOnSyntax<T>;
+        toFactory<T2, T3 extends unknown[] = unknown[], T4 extends unknown[] = unknown[]>(factory: FactoryCreator<T2, T3, T4>): BindingInWhenOnSyntax<T>;
+        toService(service: ServiceIdentifier<T>): void;
+    }
+    interface ConstraintFunction {
+        metaData?: Metadata;
+        (request: Request | null): boolean;
+    }
+    interface MetadataReader {
+        getConstructorMetadata(constructorFunc: NewableFunction): ConstructorMetadata;
+        getPropertiesMetadata(constructorFunc: NewableFunction): MetadataMap;
+    }
+    interface MetadataMap {
+        [propertyNameOrArgumentIndex: string | symbol]: Metadata[];
+    }
+    interface ConstructorMetadata {
+        compilerGeneratedMetadata: NewableFunction[] | undefined;
+        userGeneratedMetadata: MetadataMap;
+    }
+}

package/cjs/common/inversify/interfaces.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+//# sourceMappingURL=interfaces.js.map

package/cjs/common/inversify/interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/inversify/interfaces.ts"],"names":[],"mappings":"","file":"interfaces.js","sourcesContent":["// @ts-nocheck\n/* eslint-disable */\nimport { FactoryType } from '../utils/factory_type';\n\nexport namespace interfaces {\n  export type DynamicValue<T> = (context: interfaces.Context) => T;\n  export type ContainerResolution<T> = T | Promise<T> | (T | Promise<T>)[];\n\n  export type BindingScope = 'Singleton' | 'Transient' | 'Request';\n\n  export type BindingType =\n    | 'ConstantValue'\n    | 'Constructor'\n    | 'DynamicValue'\n    | 'Factory'\n    | 'Function'\n    | 'Instance'\n    | 'Invalid'\n    | 'Provider';\n\n  export type TargetType = 'ConstructorArgument' | 'ClassProperty' | 'Variable';\n\n  export interface BindingScopeEnum {\n    Singleton: interfaces.BindingScope;\n    Transient: interfaces.BindingScope;\n  }\n\n  export interface BindingTypeEnum {\n    ConstantValue: interfaces.BindingType;\n    Constructor: interfaces.BindingType;\n    DynamicValue: interfaces.BindingType;\n    Factory: interfaces.BindingType;\n    Function: interfaces.BindingType;\n    Instance: interfaces.BindingType;\n    Invalid: interfaces.BindingType;\n    Provider: interfaces.BindingType;\n  }\n\n  export interface TargetTypeEnum {\n    ConstructorArgument: interfaces.TargetType;\n    ClassProperty: interfaces.TargetType;\n    Variable: interfaces.TargetType;\n  }\n\n  export type Newable<T> = new (...args: any[]) => T;\n\n  export type Instance<T> = T & Record<string, () => void>;\n\n  export interface Abstract<T> {\n    prototype: T;\n  }\n\n  export type ServiceIdentifier<T = unknown> = string | symbol | Newable<T> | Abstract<T>;\n\n  export interface Clonable<T> {\n    clone(): T;\n  }\n\n  export type BindingActivation<T = unknown> = (context: interfaces.Context, injectable: T) => T | Promise<T>;\n\n  export type BindingDeactivation<T = unknown> = (injectable: T) => void | Promise<void>;\n\n  export interface Binding<TActivated = unknown> extends Clonable<Binding<TActivated>> {\n    id: number;\n    moduleId: ContainerModuleBase['id'];\n    activated: boolean;\n    serviceIdentifier: ServiceIdentifier<TActivated>;\n    constraint: ConstraintFunction;\n    dynamicValue: DynamicValue<TActivated> | null;\n    scope: BindingScope;\n    type: BindingType;\n    implementationType: Newable<TActivated> | TActivated | null;\n    factory: FactoryCreator<unknown> | null;\n    provider: ProviderCreator<unknown> | null;\n    // onActivation: BindingActivation<TActivated> | null;\n    // onDeactivation: BindingDeactivation<TActivated> | null;\n    cache: null | TActivated | Promise<TActivated>;\n  }\n\n  export type SimpleFactory<T, U extends unknown[] = unknown[]> = (...args: U) => T;\n\n  export type MultiFactory<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = (\n    ...args: U\n  ) => SimpleFactory<T, V>;\n\n  export type Factory<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> =\n    | SimpleFactory<T, U>\n    | MultiFactory<T, U, V>;\n\n  export type FactoryCreator<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = (\n    context: Context\n  ) => Factory<T, U, V>;\n\n  export type AutoNamedFactory<T> = SimpleFactory<T, [string]>;\n\n  export type AutoFactory<T> = SimpleFactory<T, []>;\n\n  export type FactoryTypeFunction<T = unknown> = (context: interfaces.Context) => T | Promise<T>;\n\n  export interface FactoryDetails {\n    factoryType: FactoryType;\n    factory: FactoryTypeFunction | null;\n  }\n\n  export type Provider<T> = (...args: any[]) => ((...args: any[]) => Promise<T>) | Promise<T>;\n\n  export type ProviderCreator<T> = (context: Context) => Provider<T>;\n\n  export interface NextArgs<T = unknown> {\n    avoidConstraints: boolean;\n    contextInterceptor: (contexts: Context) => Context;\n    isMultiInject: boolean;\n    targetType: TargetType;\n    serviceIdentifier: interfaces.ServiceIdentifier<T>;\n    key?: string | number | symbol | undefined;\n    value?: unknown;\n  }\n\n  export type Next = (args: NextArgs) => unknown | unknown[];\n\n  export type Middleware = (next: Next) => Next;\n\n  export type ContextInterceptor = (context: interfaces.Context) => interfaces.Context;\n\n  export interface Context {\n    id: number;\n    container: Container;\n    plan: Plan;\n    currentRequest: Request;\n    addPlan(plan: Plan): void;\n    setCurrentRequest(request: Request): void;\n  }\n\n  export type MetadataOrMetadataArray = Metadata | Metadata[];\n\n  export interface Metadata<TValue = unknown> {\n    key: string | number | symbol;\n    value: TValue;\n  }\n\n  export interface Plan {\n    parentContext: Context;\n    rootRequest: Request;\n  }\n\n  export interface QueryableString {\n    // startsWith(searchString: string): boolean;\n    // endsWith(searchString: string): boolean;\n    contains(searchString: string): boolean;\n    equals(compareString: string): boolean;\n    value(): string;\n  }\n\n  export type ResolveRequestHandler = (request: interfaces.Request) => unknown;\n\n  export type RequestScope = Map<unknown, unknown>;\n\n  export interface Request {\n    id: number;\n    serviceIdentifier: ServiceIdentifier;\n    parentContext: Context;\n    parentRequest: Request | null;\n    childRequests: Request[];\n    target: Target;\n    bindings: Binding<unknown>[];\n    requestScope: RequestScope | null;\n    addChildRequest(\n      serviceIdentifier: ServiceIdentifier,\n      bindings: Binding<unknown> | Binding<unknown>[],\n      target: Target\n    ): Request;\n  }\n\n  export interface Target {\n    id: number;\n    serviceIdentifier: ServiceIdentifier;\n    type: TargetType;\n    name: QueryableString;\n    identifier: string | symbol;\n    metadata: Metadata[];\n    getNamedTag(): interfaces.Metadata<string> | null;\n    getCustomTags(): interfaces.Metadata[] | null;\n    hasTag(key: string | number | symbol): boolean;\n    isArray(): boolean;\n    matchesArray(name: interfaces.ServiceIdentifier): boolean;\n    isNamed(): boolean;\n    isTagged(): boolean;\n    isOptional(): boolean;\n    matchesNamedTag(name: string): boolean;\n    matchesTag(key: string | number | symbol): (value: unknown) => boolean;\n  }\n\n  export interface ContainerOptions {\n    autoBindInjectable?: boolean;\n    defaultScope?: BindingScope | undefined;\n    skipBaseClassChecks?: boolean;\n  }\n\n  export interface Container {\n    id: number;\n    parent: Container | null;\n    options: ContainerOptions;\n    bind<T>(serviceIdentifier: ServiceIdentifier<T>): BindingToSyntax<T>;\n    rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;\n    // rebindAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<interfaces.BindingToSyntax<T>>;\n    unbind(serviceIdentifier: ServiceIdentifier): void;\n    // unbindAsync(serviceIdentifier: interfaces.ServiceIdentifier): Promise<void>;\n    unbindAll(): void;\n    // unbindAllAsync(): Promise<void>;\n    isBound(serviceIdentifier: ServiceIdentifier): boolean;\n    isCurrentBound<T>(serviceIdentifier: ServiceIdentifier<T>): boolean;\n    isBoundNamed(serviceIdentifier: ServiceIdentifier, named: string | number | symbol): boolean;\n    isBoundTagged(serviceIdentifier: ServiceIdentifier, key: string | number | symbol, value: unknown): boolean;\n    get<T>(serviceIdentifier: ServiceIdentifier<T>): T;\n    getNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T;\n    getTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T;\n    getAll<T>(serviceIdentifier: ServiceIdentifier<T>): T[];\n    getAllTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T[];\n    getAllNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T[];\n    getAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<T>;\n    // getNamedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Promise<T>;\n    // getTaggedAsync<T>(\n    //   serviceIdentifier: ServiceIdentifier<T>,\n    //   key: string | number | symbol,\n    //   value: unknown\n    // ): Promise<T>;\n    // getAllAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<T[]>;\n    // getAllTaggedAsync<T>(\n    //   serviceIdentifier: ServiceIdentifier<T>,\n    //   key: string | number | symbol,\n    //   value: unknown\n    // ): Promise<T[]>;\n    // getAllNamedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Promise<T[]>;\n    // onActivation<T>(serviceIdentifier: ServiceIdentifier<T>, onActivation: BindingActivation<T>): void;\n    // onDeactivation<T>(serviceIdentifier: ServiceIdentifier<T>, onDeactivation: BindingDeactivation<T>): void;\n    resolve<T>(constructorFunction: interfaces.Newable<T>): T;\n    load(...modules: ContainerModule[]): void;\n    // loadAsync(...modules: AsyncContainerModule[]): Promise<void>;\n    unload(...modules: ContainerModuleBase[]): void;\n    // unloadAsync(...modules: ContainerModuleBase[]): Promise<void>;\n    applyCustomMetadataReader(metadataReader: MetadataReader): void;\n    // applyMiddleware(...middleware: Middleware[]): void;\n    // snapshot(): void;\n    // restore(): void;\n    // createChild(): Container;\n  }\n\n  export type Bind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;\n\n  export type Rebind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;\n\n  export type Unbind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => void;\n\n  export type UnbindAsync = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => Promise<void>;\n\n  export type IsBound = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => boolean;\n\n  export interface ContainerModuleBase {\n    id: number;\n  }\n\n  export interface ContainerModule extends ContainerModuleBase {\n    registry: ContainerModuleCallBack;\n  }\n\n  export interface ModuleActivationHandlers {\n    onActivations: Lookup<BindingActivation<unknown>>;\n    onDeactivations: Lookup<BindingDeactivation<unknown>>;\n  }\n\n  // export interface ModuleActivationStore extends Clonable<ModuleActivationStore> {\n  //   addDeactivation(\n  //     moduleId: ContainerModuleBase['id'],\n  //     serviceIdentifier: ServiceIdentifier<unknown>,\n  //     onDeactivation: interfaces.BindingDeactivation<unknown>\n  //   ): void;\n  //   addActivation(\n  //     moduleId: ContainerModuleBase['id'],\n  //     serviceIdentifier: ServiceIdentifier<unknown>,\n  //     onActivation: interfaces.BindingActivation<unknown>\n  //   ): void;\n  //   remove(moduleId: ContainerModuleBase['id']): ModuleActivationHandlers;\n  // }\n\n  export type ContainerModuleCallBack = (\n    bind: interfaces.Bind,\n    unbind: interfaces.Unbind,\n    isBound: interfaces.IsBound,\n    rebind: interfaces.Rebind\n    // unbindAsync: interfaces.UnbindAsync,\n    // onActivation: interfaces.Container['onActivation'],\n    // onDeactivation: interfaces.Container['onDeactivation']\n  ) => void;\n\n  // export interface ContainerSnapshot {\n  //   bindings: Lookup<Binding<unknown>>;\n  //   activations: Lookup<BindingActivation<unknown>>;\n  //   deactivations: Lookup<BindingDeactivation<unknown>>;\n  //   middleware: Next | null;\n  //   moduleActivationStore: interfaces.ModuleActivationStore;\n  // }\n\n  export interface Lookup<T> extends Clonable<Lookup<T>> {\n    add(serviceIdentifier: ServiceIdentifier, value: T): void;\n    getMap(): Map<interfaces.ServiceIdentifier, T[]>;\n    get(serviceIdentifier: ServiceIdentifier): T[];\n    remove(serviceIdentifier: interfaces.ServiceIdentifier): void;\n    removeByCondition(condition: (item: T) => boolean): T[];\n    removeIntersection(lookup: interfaces.Lookup<T>): void;\n    hasKey(serviceIdentifier: ServiceIdentifier): boolean;\n    clone(): Lookup<T>;\n    traverse(func: (key: interfaces.ServiceIdentifier, value: T[]) => void): void;\n  }\n\n  export interface BindingOnSyntax<T> {\n    // onActivation(fn: (context: Context, injectable: T) => T | Promise<T>): BindingWhenSyntax<T>;\n    // onDeactivation(fn: (injectable: T) => void | Promise<void>): BindingWhenSyntax<T>;\n  }\n\n  // export interface BindingWhenOnSyntax<T> extends BindingWhenSyntax<T>, BindingOnSyntax<T> {}\n\n  export interface BindingInSyntax<T> {\n    inSingletonScope(): BindingInSyntax<T>;\n    inTransientScope(): BindingInSyntax<T>;\n    whenTargetNamed(name: string | number | symbol): BindingOnSyntax<T>;\n    // inRequestScope(): BindingInSyntax<T>;\n  }\n\n  export interface BindingInWhenOnSyntax<T> extends BindingInSyntax<T>, BindingInSyntax<T> {}\n\n  export interface BindingToSyntax<T> {\n    to(constructor: Newable<T>): BindingInWhenOnSyntax<T>;\n    toSelf(): BindingInWhenOnSyntax<T>;\n    toConstantValue(value: T): BindingInWhenOnSyntax<T>;\n    toDynamicValue(func: DynamicValue<T>): BindingInWhenOnSyntax<T>;\n    toFactory<T2, T3 extends unknown[] = unknown[], T4 extends unknown[] = unknown[]>(\n      factory: FactoryCreator<T2, T3, T4>\n    ): BindingInWhenOnSyntax<T>;\n    toService(service: ServiceIdentifier<T>): void;\n  }\n\n  export interface ConstraintFunction {\n    metaData?: Metadata;\n    (request: Request | null): boolean;\n  }\n\n  export interface MetadataReader {\n    getConstructorMetadata(constructorFunc: NewableFunction): ConstructorMetadata;\n    getPropertiesMetadata(constructorFunc: NewableFunction): MetadataMap;\n  }\n\n  export interface MetadataMap {\n    [propertyNameOrArgumentIndex: string | symbol]: Metadata[];\n  }\n\n  export interface ConstructorMetadata {\n    compilerGeneratedMetadata: NewableFunction[] | undefined;\n    userGeneratedMetadata: MetadataMap;\n  }\n}\n"]}

package/cjs/common/inversify/literal_types.d.ts

@@ -0,0 +1,5 @@
+import type { interfaces } from './interfaces';
+declare const BindingScopeEnum: interfaces.BindingScopeEnum;
+declare const BindingTypeEnum: interfaces.BindingTypeEnum;
+declare const TargetTypeEnum: interfaces.TargetTypeEnum;
+export { BindingScopeEnum, BindingTypeEnum, TargetTypeEnum };

package/cjs/common/inversify/literal_types.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.TargetTypeEnum = exports.BindingTypeEnum = exports.BindingScopeEnum = void 0;
+
+const BindingScopeEnum = {
+    Singleton: "Singleton",
+    Transient: "Transient"
+};
+
+exports.BindingScopeEnum = BindingScopeEnum;
+
+const BindingTypeEnum = {
+    ConstantValue: "ConstantValue",
+    Constructor: "Constructor",
+    DynamicValue: "DynamicValue",
+    Factory: "Factory",
+    Function: "Function",
+    Instance: "Instance",
+    Invalid: "Invalid",
+    Provider: "Provider"
+};
+
+exports.BindingTypeEnum = BindingTypeEnum;
+
+const TargetTypeEnum = {
+    ClassProperty: "ClassProperty",
+    ConstructorArgument: "ConstructorArgument",
+    Variable: "Variable"
+};
+
+exports.TargetTypeEnum = TargetTypeEnum;
+//# sourceMappingURL=literal_types.js.map

package/cjs/common/inversify/literal_types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/inversify/literal_types.ts"],"names":[],"mappings":";;;AAEA,MAAM,gBAAgB,GAAgC;IACpD,SAAS,EAAE,WAAW;IACtB,SAAS,EAAE,WAAW;CACvB,CAAC;AAmBO,4CAAgB;AAjBzB,MAAM,eAAe,GAA+B;IAClD,aAAa,EAAE,eAAe;IAC9B,WAAW,EAAE,aAAa;IAC1B,YAAY,EAAE,cAAc;IAC5B,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;CACrB,CAAC;AAQyB,0CAAe;AAN1C,MAAM,cAAc,GAA8B;IAChD,aAAa,EAAE,eAAe;IAC9B,mBAAmB,EAAE,qBAAqB;IAC1C,QAAQ,EAAE,UAAU;CACrB,CAAC;AAE0C,wCAAc","file":"literal_types.js","sourcesContent":["import type { interfaces } from './interfaces';\n\nconst BindingScopeEnum: interfaces.BindingScopeEnum = {\n  Singleton: 'Singleton',\n  Transient: 'Transient'\n};\n\nconst BindingTypeEnum: interfaces.BindingTypeEnum = {\n  ConstantValue: 'ConstantValue',\n  Constructor: 'Constructor',\n  DynamicValue: 'DynamicValue',\n  Factory: 'Factory',\n  Function: 'Function',\n  Instance: 'Instance',\n  Invalid: 'Invalid',\n  Provider: 'Provider'\n};\n\nconst TargetTypeEnum: interfaces.TargetTypeEnum = {\n  ClassProperty: 'ClassProperty',\n  ConstructorArgument: 'ConstructorArgument',\n  Variable: 'Variable'\n};\n\nexport { BindingScopeEnum, BindingTypeEnum, TargetTypeEnum };\n"]}

package/cjs/common/inversify/meta-data.d.ts

@@ -0,0 +1,6 @@
+export declare class Metadata {
+    key: string | number | symbol;
+    value: unknown;
+    constructor(key: string | number | symbol, value: unknown);
+    toString(): string;
+}

package/cjs/common/inversify/meta-data.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.Metadata = void 0;
+
+const metadata_keys_1 = require("./metadata_keys");
+
+class Metadata {
+    constructor(key, value) {
+        this.key = key, this.value = value;
+    }
+    toString() {
+        return this.key === metadata_keys_1.NAMED_TAG ? `named: ${String(this.value).toString()} ` : `tagged: { key:${this.key.toString()}, value: ${String(this.value)} }`;
+    }
+}
+
+exports.Metadata = Metadata;
+//# sourceMappingURL=meta-data.js.map