@adimm/x-injection 0.3.1

package/dist/index.cjs

@@ -0,0 +1,531 @@
+"use strict";
+
+var e, i = Object.defineProperty, t = Object.getOwnPropertyDescriptor, n = Object.getOwnPropertyNames, r = Object.prototype.hasOwnProperty, o = (e, t) => i(e, "name", {
+    value: t,
+    configurable: !0
+}), s = {};
+
+((e, t) => {
+    for (var n in t) i(e, n, {
+        get: t[n],
+        enumerable: !0
+    });
+})(s, {
+    ANONYMOUSE_MODULE_DEFAULT_ID: () => c,
+    AppModule: () => z,
+    GLOBAL_APP_MODULE_ID: () => d,
+    GlobalAppModule: () => $,
+    GlobalContainer: () => V,
+    Inject: () => b,
+    InjectFromBase: () => B,
+    Injectable: () => I,
+    InjectionScope: () => u,
+    MultiInject: () => T,
+    Named: () => D,
+    Optional: () => M,
+    PostConstruct: () => C,
+    PreDestroy: () => A,
+    ProviderModule: () => W,
+    ProviderModuleHelpers: () => p,
+    ProviderTokenHelpers: () => f,
+    Tagged: () => O,
+    Unmanaged: () => q,
+    XInjectionDynamicExportsOutOfRange: () => G,
+    XInjectionError: () => F,
+    XInjectionProviderModuleDisposedError: () => U,
+    XInjectionProviderModuleError: () => N,
+    injectionScopeToBindingScope: () => h
+}), module.exports = (e = s, ((e, o, s, d) => {
+    if (o && "object" == typeof o || "function" == typeof o) for (let c of n(o)) r.call(e, c) || c === s || i(e, c, {
+        get: () => o[c],
+        enumerable: !(d = t(o, c)) || d.enumerable
+    });
+    return e;
+})(i({}, "__esModule", {
+    value: !0
+}), e));
+
+var d = "GlobalAppModule", c = "AnonymousModule", a = require("inversify"), u = function(e) {
+    return e[e.Singleton = 0] = "Singleton", e[e.Transient = 1] = "Transient", e[e.Request = 2] = "Request", 
+    e;
+}({});
+
+function h(e) {
+    switch (e) {
+      case u.Singleton:
+        return "Singleton";
+
+      case u.Transient:
+        return "Transient";
+
+      case u.Request:
+        return "Request";
+    }
+}
+
+function l(e) {
+    switch (e) {
+      case "Singleton":
+        return u.Singleton;
+
+      case "Transient":
+        return u.Transient;
+
+      case "Request":
+        return u.Request;
+    }
+}
+
+o(h, "injectionScopeToBindingScope"), o(l, "bindingScopeToInjectionScope");
+
+var f, p, v = require("@inversifyjs/core");
+
+function g(e) {
+    return "function" == typeof e && /^class\s/.test(Function.prototype.toString.call(e));
+}
+
+function S(e) {
+    return "[object Object]" === Object.prototype.toString.call(e);
+}
+
+function y(e) {
+    if (!1 === S(e)) return !1;
+    const i = e.constructor;
+    if (void 0 === i) return !0;
+    const t = i.prototype;
+    return !1 !== S(t) && !1 !== t.hasOwnProperty("isPrototypeOf");
+}
+
+function I(e) {
+    return void 0 === e ? (0, a.injectable)() : (0, a.injectable)(h(e));
+}
+
+o(g, "isClass"), o(S, "isObject"), o(y, "isPlainObject"), function(e) {
+    function i(e) {
+        return f(e) && "useClass" in e;
+    }
+    function t(e) {
+        return f(e) && "useValue" in e;
+    }
+    function n(e) {
+        return f(e) && "useFactory" in e;
+    }
+    function r(e) {
+        return "string" == typeof e || "symbol" == typeof e || g(e) || "function" == typeof e;
+    }
+    function s(e) {
+        return r(e) ? e : e.provide;
+    }
+    function d(e) {
+        return e.map((e => s(e)));
+    }
+    function c(e, i) {
+        return u(e) ?? h(e) ?? i;
+    }
+    function a(e) {
+        if (f(e)) return e;
+    }
+    function u(e) {
+        const i = a(e);
+        if (i) return i.scope;
+    }
+    function h(e) {
+        const i = s(e);
+        if (!g(i)) return;
+        const t = (0, v.getClassMetadata)(i)?.scope;
+        return t ? l(t) : void 0;
+    }
+    function f(e) {
+        return y(e) && "object" == typeof e && "provide" in e;
+    }
+    o(i, "isClassToken"), e.isClassToken = i, o(t, "isValueToken"), e.isValueToken = t, 
+    o(n, "isFactoryToken"), e.isFactoryToken = n, o(r, "isProviderIdentifier"), e.isProviderIdentifier = r, 
+    o(s, "toServiceIdentifier"), e.toServiceIdentifier = s, o(d, "toServiceIdentifiers"), 
+    e.toServiceIdentifiers = d, o(c, "getInjectionScopeByPriority"), e.getInjectionScopeByPriority = c, 
+    o(a, "tryGetProviderOptions"), e.tryGetProviderOptions = a, o(u, "tryGetScopeFromProvider"), 
+    e.tryGetScopeFromProvider = u, o(h, "tryGetDecoratorScopeFromClass"), e.tryGetDecoratorScopeFromClass = h, 
+    o(f, "hasProvideProperty");
+}(f || (f = {})), function(e) {
+    function i(e) {
+        return e;
+    }
+    function t(e) {
+        return !Array.isArray(e) && "function" == typeof e;
+    }
+    o(i, "buildInternalConstructorParams"), e.buildInternalConstructorParams = i, o(t, "isDynamicExport"), 
+    e.isDynamicExport = t;
+}(p || (p = {})), o(I, "Injectable");
+
+var m = require("inversify");
+
+function b(e) {
+    return (0, m.inject)(f.toServiceIdentifier(e));
+}
+
+o(b, "Inject");
+
+var E = require("inversify");
+
+function T(e) {
+    return (0, E.multiInject)(f.toServiceIdentifier(e));
+}
+
+o(T, "MultiInject");
+
+var _ = require("inversify");
+
+function B(e) {
+    return (0, _.injectFromBase)(e);
+}
+
+o(B, "InjectFromBase");
+
+var w = require("inversify");
+
+function D(e) {
+    return (0, w.named)(e);
+}
+
+o(D, "Named");
+
+var j = require("inversify");
+
+function M() {
+    return (0, j.optional)();
+}
+
+o(M, "Optional");
+
+var P = require("inversify");
+
+function C() {
+    return (0, P.postConstruct)();
+}
+
+o(C, "PostConstruct");
+
+var k = require("inversify");
+
+function A() {
+    return (0, k.preDestroy)();
+}
+
+o(A, "PreDestroy");
+
+var x = require("inversify");
+
+function O(e, i) {
+    return (0, x.tagged)(e, i);
+}
+
+o(O, "Tagged");
+
+var R = require("inversify");
+
+function q() {
+    return (0, R.unmanaged)();
+}
+
+o(q, "Unmanaged");
+
+var F = class e extends Error {
+    static {
+        o(this, "XInjectionError");
+    }
+    name=e.name;
+}, N = class e extends Error {
+    static {
+        o(this, "XInjectionProviderModuleError");
+    }
+    name=e.name;
+    constructor(e, i) {
+        super(`{ProviderModule.${e.toString()}} => ${i}`);
+    }
+}, U = class e extends N {
+    static {
+        o(this, "XInjectionProviderModuleDisposedError");
+    }
+    name=e.name;
+    constructor(e) {
+        super(e, "Has been disposed! You can re-initialize it by using the `_lazyInit` method.");
+    }
+}, G = class e extends N {
+    static {
+        o(this, "XInjectionDynamicExportsOutOfRange");
+    }
+    name=e.name;
+    constructor(e) {
+        super(e, `The 'ProviderModule.${e.toString()}' is trying to dynamically export providers/modules out of the declared range of the static exports!`);
+    }
+}, V = new (require("inversify").Container)({
+    defaultScope: "Singleton"
+}), L = require("inversify"), X = class {
+    static {
+        o(this, "ProviderModuleUtils");
+    }
+    get container() {
+        return this.module.toNaked().container;
+    }
+    module;
+    moduleNaked;
+    constructor(e) {
+        this.module = e, this.moduleNaked = e.toNaked();
+    }
+    bindToContainer(e, i) {
+        return f.isProviderIdentifier(e) ? this.bindSelfTokenToContainer(e, i) : f.isClassToken(e) ? this.bindClassTokenToContainer(e, i) : f.isValueToken(e) ? this.bindValueTokenToContainer(e) : !!f.isFactoryToken(e) && this.bindFactoryTokenToContainer(e, i);
+    }
+    bindManyToContainer(e, i) {
+        e.forEach((e => this.bindToContainer(e, i)));
+    }
+    bindSelfTokenToContainer(e, i) {
+        return this.setBindingScope(e, this.container.bind(f.toServiceIdentifier(e)).toSelf(), i), 
+        this.moduleNaked.__isCurrentBound(e);
+    }
+    bindClassTokenToContainer(e, i) {
+        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(f.toServiceIdentifier(e)).to(e.useClass), i))), 
+        this.moduleNaked.__isCurrentBound(e);
+    }
+    bindValueTokenToContainer(e) {
+        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.container.bind(f.toServiceIdentifier(e)).toConstantValue(e.useValue))), 
+        this.moduleNaked.__isCurrentBound(e);
+    }
+    bindFactoryTokenToContainer(e, i) {
+        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(f.toServiceIdentifier(e)).toResolvedValue(e.useFactory, f.toServiceIdentifiers(e.inject ?? [])), i))), 
+        this.moduleNaked.__isCurrentBound(e);
+    }
+    setBindingScope(e, i, t) {
+        if (f.isValueToken(e)) return i;
+        switch (f.getInjectionScopeByPriority(e, t)) {
+          case u.Singleton:
+            return i.inSingletonScope();
+
+          case u.Transient:
+            return i.inTransientScope();
+
+          case u.Request:
+            return i.inRequestScope();
+        }
+    }
+    setWhenBinding(e, i) {
+        if (f.isProviderIdentifier(e)) return i;
+        const t = e.when;
+        return t ? i.when(t) : i;
+    }
+    setBindingOnEvent(e, i) {
+        if (f.isProviderIdentifier(e)) return;
+        const t = e;
+        t.onEvent?.activation && i.onActivation(t.onEvent.activation), t.onEvent?.deactivation && i.onDeactivation(t.onEvent.deactivation);
+    }
+}, W = class e {
+    static {
+        o(this, "ProviderModule");
+    }
+    identifier;
+    isAppModule;
+    container;
+    defaultScope;
+    dynamicExports;
+    onReady;
+    onDispose;
+    moduleUtils;
+    providers;
+    exports;
+    imports;
+    registeredBindingSideEffects;
+    constructor({identifier: e = Symbol(c), imports: i, providers: t, exports: n, defaultScope: r, dynamicExports: o, onReady: s, onDispose: d, ...a}) {
+        const u = a;
+        this.identifier = e, this.isAppModule = u.isAppModule ?? !1, this.isAppModule || this._lazyInit({
+            imports: i,
+            providers: t,
+            exports: n,
+            defaultScope: r,
+            dynamicExports: o,
+            onReady: s,
+            onDispose: d,
+            ...a
+        });
+    }
+    get(e, i) {
+        return this.__get(e, {
+            optional: i ?? !1
+        });
+    }
+    getMany(...e) {
+        return e.map((e => {
+            const i = y(e) && "provider" in e;
+            return this.get(i ? e.provider : e, !!i && e.isOptional);
+        }));
+    }
+    onActivationEvent(e, i) {
+        this.container.onActivation(f.toServiceIdentifier(e), i);
+    }
+    onDeactivationEvent(e, i) {
+        this.container.onDeactivation(f.toServiceIdentifier(e), i);
+    }
+    toNaked() {
+        return this;
+    }
+    toString() {
+        return this.identifier.description;
+    }
+    prepareContainer(e) {
+        return this.isAppModule ? e.container?.() ?? V : e.container ? (console.warn(`[xInjection]: The '${this.toString()}' module is using a dynamic container!`), 
+        e.container()) : new L.Container({
+            parent: V,
+            defaultScope: this.defaultScope.inversify
+        });
+    }
+    injectImportedModules(i) {
+        i && 0 !== i.length && i.forEach((i => {
+            if ("GlobalAppModule" === i.toString()) throw new N(this, "The 'GlobalAppModule' can't be imported!");
+            const t = i._getExportableModulesAndProviders(), n = i.dynamicExports?.(this, t);
+            void 0 !== n && this.shouldThrowWhenModuleDynamicExportsDontMatchTheStaticExports(i, t, n), 
+            (n ?? t).forEach((t => {
+                if (t instanceof e) {
+                    const e = t.toNaked();
+                    return void this.injectImportedModules([ e ]);
+                }
+                const n = t;
+                this.moduleUtils.bindToContainer({
+                    scope: f.getInjectionScopeByPriority(n, i.defaultScope.native),
+                    provide: f.toServiceIdentifier(n),
+                    useFactory: o((() => i.get(n)), "useFactory")
+                }, i.defaultScope.native);
+            }));
+        }));
+    }
+    injectProviders() {
+        this.moduleUtils.bindManyToContainer(this.providers, this.defaultScope.native);
+    }
+    registerBindingSideEffect(e, i, t) {
+        this.registeredBindingSideEffects.has(e) || this.registeredBindingSideEffects.set(e, {
+            onBindEffects: [],
+            onRebindEffects: [],
+            onUnbindEffects: []
+        });
+        const n = this.registeredBindingSideEffects.get(e);
+        "bind" === i ? n.onBindEffects.push(t) : "rebind" === i ? n.onRebindEffects.push(t) : n.onUnbindEffects.push(t);
+    }
+    invokeRegisteredBindingSideEffects(e, i) {
+        const t = this.registeredBindingSideEffects.get(e);
+        t && t[`${i}Effects`].forEach((e => e()));
+    }
+    removeRegisteredBindingSideEffects(e) {
+        this.registeredBindingSideEffects && ("all" !== e ? this.registeredBindingSideEffects.has(e) && (this.registeredBindingSideEffects.get(e)?.onUnbindEffects.forEach((e => e())), 
+        this.registeredBindingSideEffects.delete(e)) : this.registeredBindingSideEffects.forEach((({onUnbindEffects: e}) => e.forEach((e => e())))));
+    }
+    shouldThrowWhenModuleDynamicExportsDontMatchTheStaticExports(e, i, t) {
+        if (t.length > i.length || t.some((e => !i.includes(e)))) throw new G(e);
+    }
+    shouldThrowIfDisposed() {
+        if (null === this.container) throw new U(this);
+    }
+    async _dispose() {
+        await (this.onDispose?.(this)), await this.__unbindAll(), this.container = null, 
+        this.imports = null, this.providers = null, this.exports = null, this.dynamicExports = null, 
+        this.registeredBindingSideEffects = null;
+    }
+    _lazyInit({imports: e = [], providers: i = [], exports: t = [], defaultScope: n = u.Singleton, dynamicExports: r, onReady: o, onDispose: s, ...d}) {
+        this.imports = e, this.providers = i, this.exports = t, this.defaultScope = {
+            native: n,
+            inversify: h(n)
+        }, this.dynamicExports = r, this.onReady = o, this.onDispose = s, this.container = this.prepareContainer({
+            ...d
+        }), this.moduleUtils = new X(this), this.registeredBindingSideEffects = new Map, 
+        this.injectImportedModules(this._getImportedModules()), this.injectProviders(), 
+        this.onReady?.(this);
+    }
+    _getImportedModules() {
+        return this.shouldThrowIfDisposed(), this.imports;
+    }
+    _getProviders() {
+        return this.shouldThrowIfDisposed(), this.providers;
+    }
+    _getExportableModulesAndProviders() {
+        return this.shouldThrowIfDisposed(), this.exports;
+    }
+    _onBind(e, i) {
+        this.shouldThrowIfDisposed(), this.registerBindingSideEffect(e, "bind", i);
+    }
+    _onRebind(e, i) {
+        this.shouldThrowIfDisposed(), this.registerBindingSideEffect(e, "rebind", i);
+    }
+    _onUnbind(e, i) {
+        this.shouldThrowIfDisposed(), this.registerBindingSideEffect(e, "unbind", i);
+    }
+    _overwriteContainer(e) {
+        this.container = e();
+    }
+    __bind(e) {
+        this.shouldThrowIfDisposed();
+        const i = this.container.bind(f.toServiceIdentifier(e));
+        return this.invokeRegisteredBindingSideEffects(e, "onBind"), i;
+    }
+    __get(e, i) {
+        return this.shouldThrowIfDisposed(), this.container.get(f.toServiceIdentifier(e), i);
+    }
+    async __getAsync(e, i) {
+        return this.shouldThrowIfDisposed(), this.container.getAsync(f.toServiceIdentifier(e), i);
+    }
+    __getAll(e, i) {
+        return this.shouldThrowIfDisposed(), this.container.getAll(f.toServiceIdentifier(e), i);
+    }
+    async __getAllAsync(e, i) {
+        return this.shouldThrowIfDisposed(), this.container.getAllAsync(f.toServiceIdentifier(e), i);
+    }
+    __isBound(e, i) {
+        return this.shouldThrowIfDisposed(), this.container.isBound(f.toServiceIdentifier(e), i);
+    }
+    __isCurrentBound(e, i) {
+        return this.shouldThrowIfDisposed(), this.container.isCurrentBound(f.toServiceIdentifier(e), i);
+    }
+    __takeSnapshot() {
+        this.shouldThrowIfDisposed(), this.container.snapshot();
+    }
+    __restoreSnapshot() {
+        this.shouldThrowIfDisposed(), this.container.restore();
+    }
+    async __rebind(e) {
+        this.shouldThrowIfDisposed();
+        const i = await this.container.rebind(f.toServiceIdentifier(e));
+        return this.invokeRegisteredBindingSideEffects(e, "onRebind"), i;
+    }
+    __rebindSync(e) {
+        this.shouldThrowIfDisposed();
+        const i = this.container.rebindSync(f.toServiceIdentifier(e));
+        return this.invokeRegisteredBindingSideEffects(e, "onRebind"), i;
+    }
+    async __unbind(e) {
+        this.shouldThrowIfDisposed(), await this.container.unbind(f.toServiceIdentifier(e)), 
+        this.removeRegisteredBindingSideEffects(e);
+    }
+    __unbindSync(e) {
+        this.shouldThrowIfDisposed(), this.container.unbindSync(f.toServiceIdentifier(e)), 
+        this.removeRegisteredBindingSideEffects(e);
+    }
+    async __unbindAll() {
+        this.shouldThrowIfDisposed(), await this.container.unbindAll(), this.removeRegisteredBindingSideEffects("all");
+    }
+}, $ = class extends W {
+    static {
+        o(this, "GlobalAppModule");
+    }
+    nakedModule=this;
+    isLoaded=!1;
+    constructor() {
+        super(p.buildInternalConstructorParams({
+            identifier: Symbol(d),
+            isAppModule: !0
+        }));
+    }
+    register(e) {
+        if (this.isLoaded) throw new F(`The '${this.toString()}' has already been registered!`);
+        return this.nakedModule._lazyInit(e), this.isLoaded = !0, this;
+    }
+    toNaked() {
+        return super.toNaked();
+    }
+    async _dispose() {
+        this.isLoaded = !1, super._dispose();
+    }
+}, z = new $;//# sourceMappingURL=index.cjs.map