@adimm/x-injection 0.5.1 → 0.6.0

package/dist/index.js

@@ -5,7 +5,7 @@ var e = Object.defineProperty, i = (i, t) => e(i, "name", {
 
 import { injectable as n } from "inversify";
 
-var r, o, s = function(e) {
+var o, r, s = function(e) {
     return e[e.Singleton = 0] = "Singleton", e[e.Transient = 1] = "Transient", e[e.Request = 2] = "Request", 
     e;
 }({});
@@ -23,7 +23,7 @@ function d(e) {
     }
 }
 
-function c(e) {
+function a(e) {
     switch (e) {
       case "Singleton":
         return s.Singleton;
@@ -36,9 +36,9 @@ function c(e) {
     }
 }
 
-i(d, "injectionScopeToBindingScope"), i(c, "bindingScopeToInjectionScope");
+i(d, "injectionScopeToBindingScope"), i(a, "bindingScopeToInjectionScope");
 
-import { getClassMetadata as a } from "@inversifyjs/core";
+import { getClassMetadata as c } from "@inversifyjs/core";
 
 function u(e) {
     return "function" == typeof e && Function.prototype.toString.call(e).startsWith("class ");
@@ -52,43 +52,43 @@ function p(e) {
     return "function" == typeof e && !Function.prototype.toString.call(e).startsWith("class ");
 }
 
-function f(e) {
+function l(e) {
     return "[object Object]" === Object.prototype.toString.call(e);
 }
 
-function l(e) {
-    if (!1 === f(e)) return !1;
+function f(e) {
+    if (!1 === l(e)) return !1;
     const i = e.constructor;
     if (void 0 === i) return !0;
     const t = i.prototype;
-    return !1 !== f(t) && !1 !== t.hasOwnProperty("isPrototypeOf");
+    return !1 !== l(t) && !1 !== t.hasOwnProperty("isPrototypeOf");
 }
 
 function v(e) {
     return void 0 === e ? n() : n(d(e));
 }
 
-i(u, "isClass"), i(h, "isClassOrFunction"), i(p, "isFunction"), i(f, "isObject"), 
-i(l, "isPlainObject"), function(e) {
+i(u, "isClass"), i(h, "isClassOrFunction"), i(p, "isFunction"), i(l, "isObject"), 
+i(f, "isPlainObject"), function(e) {
     function t(e) {
         return y(e) && "useClass" in e;
     }
     function n(e) {
         return y(e) && "useValue" in e;
     }
-    function r(e) {
+    function o(e) {
         return y(e) && "useFactory" in e;
     }
-    function o(e) {
+    function r(e) {
         return "string" == typeof e || "symbol" == typeof e || h(e);
     }
     function s(e) {
-        return o(e) ? e : e.provide;
+        return r(e) ? e : e.provide;
     }
     function d(e) {
         return e.map((e => s(e)));
     }
-    function f(e, i) {
+    function l(e, i) {
         return u(e) ? {
             ...i,
             provide: i?.provide ?? e,
@@ -103,32 +103,32 @@ i(l, "isPlainObject"), function(e) {
         };
     }
     function v(e, i) {
-        return m(e) ?? S(e) ?? i;
+        return g(e) ?? S(e) ?? i;
     }
-    function g(e) {
+    function m(e) {
         if (y(e)) return e;
     }
-    function m(e) {
-        const i = g(e);
+    function g(e) {
+        const i = m(e);
         if (i) return i.scope;
     }
     function S(e) {
         const i = s(e);
         if (!u(i)) return;
-        const t = a(i)?.scope;
-        return t ? c(t) : void 0;
+        const t = c(i)?.scope;
+        return t ? a(t) : void 0;
     }
     function y(e) {
-        return l(e) && "object" == typeof e && "provide" in e;
+        return f(e) && "object" == typeof e && "provide" in e;
     }
     i(t, "isClassToken"), e.isClassToken = t, i(n, "isValueToken"), e.isValueToken = n, 
-    i(r, "isFactoryToken"), e.isFactoryToken = r, i(o, "isProviderIdentifier"), e.isProviderIdentifier = o, 
+    i(o, "isFactoryToken"), e.isFactoryToken = o, i(r, "isProviderIdentifier"), e.isProviderIdentifier = r, 
     i(s, "toServiceIdentifier"), e.toServiceIdentifier = s, i(d, "toServiceIdentifiers"), 
-    e.toServiceIdentifiers = d, i(f, "toDependencyProviderWithOptions"), e.toDependencyProviderWithOptions = f, 
-    i(v, "getInjectionScopeByPriority"), e.getInjectionScopeByPriority = v, i(g, "tryGetProviderOptions"), 
-    e.tryGetProviderOptions = g, i(m, "tryGetScopeFromProvider"), e.tryGetScopeFromProvider = m, 
+    e.toServiceIdentifiers = d, i(l, "toDependencyProviderWithOptions"), e.toDependencyProviderWithOptions = l, 
+    i(v, "getInjectionScopeByPriority"), e.getInjectionScopeByPriority = v, i(m, "tryGetProviderOptions"), 
+    e.tryGetProviderOptions = m, i(g, "tryGetScopeFromProvider"), e.tryGetScopeFromProvider = g, 
     i(S, "tryGetDecoratorScopeFromClass"), e.tryGetDecoratorScopeFromClass = S, i(y, "hasProvideProperty");
-}(r || (r = {})), function(e) {
+}(o || (o = {})), function(e) {
     function t(e) {
         return e;
     }
@@ -137,88 +137,88 @@ i(l, "isPlainObject"), function(e) {
     }
     i(t, "buildInternalConstructorParams"), e.buildInternalConstructorParams = t, i(n, "isDynamicExport"), 
     e.isDynamicExport = n;
-}(o || (o = {})), i(v, "Injectable");
+}(r || (r = {})), i(v, "Injectable");
 
-import { inject as g } from "inversify";
+import { inject as m } from "inversify";
 
-function m(e) {
-    return g(r.toServiceIdentifier(e));
+function g(e) {
+    return m(o.toServiceIdentifier(e));
 }
 
-i(m, "Inject");
+i(g, "Inject");
 
 import { multiInject as S } from "inversify";
 
 function y(e) {
-    return S(r.toServiceIdentifier(e));
+    return S(o.toServiceIdentifier(e));
 }
 
 i(y, "MultiInject");
 
 import { injectFromBase as I } from "inversify";
 
-function E(e) {
+function b(e) {
     return I(e);
 }
 
-i(E, "InjectFromBase");
+i(b, "InjectFromBase");
 
-import { named as b } from "inversify";
+import { named as E } from "inversify";
 
 function T(e) {
-    return b(e);
+    return E(e);
 }
 
 i(T, "Named");
 
-import { optional as _ } from "inversify";
+import { optional as M } from "inversify";
 
 function w() {
-    return _();
+    return M();
 }
 
 i(w, "Optional");
 
-import { postConstruct as B } from "inversify";
+import { postConstruct as _ } from "inversify";
 
-function D() {
-    return B();
+function B() {
+    return _();
 }
 
-i(D, "PostConstruct");
+i(B, "PostConstruct");
 
-import { preDestroy as P } from "inversify";
+import { preDestroy as k } from "inversify";
 
-function M() {
-    return P();
+function D() {
+    return k();
 }
 
-i(M, "PreDestroy");
+i(D, "PreDestroy");
 
-import { tagged as C } from "inversify";
+import { tagged as P } from "inversify";
 
-function k(e, i) {
-    return C(e, i);
+function A(e, i) {
+    return P(e, i);
 }
 
-i(k, "Tagged");
+i(A, "Tagged");
 
-import { unmanaged as x } from "inversify";
+import { unmanaged as C } from "inversify";
 
-function j() {
-    return x();
+function x() {
+    return C();
 }
 
-i(j, "Unmanaged");
+i(x, "Unmanaged");
 
-var A = class e extends Error {
+var j = class e extends Error {
     static {
-        i(this, "XInjectionError");
+        i(this, "InjectionError");
     }
     name=e.name;
 }, R = class e extends Error {
     static {
-        i(this, "XInjectionProviderModuleError");
+        i(this, "InjectionProviderModuleError");
     }
     name=e.name;
     constructor(e, i) {
@@ -226,72 +226,87 @@ var A = class e extends Error {
     }
 }, F = class e extends R {
     static {
-        i(this, "XInjectionProviderModuleDisposedError");
+        i(this, "InjectionProviderModuleDisposedError");
     }
     name=e.name;
     constructor(e) {
         super(e, "Has been disposed! You can re-initialize it by using the `_lazyInit` method.");
     }
-}, O = class e extends R {
+}, G = class e extends R {
     static {
-        i(this, "XInjectionDynamicExportsOutOfRange");
+        i(this, "InjectionDynamicExportsOutOfRange");
     }
     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!`);
     }
-}, N = class e extends R {
+}, O = class e extends R {
     static {
-        i(this, "XInjectionProviderModuleMissingIdentifierError");
+        i(this, "InjectionProviderModuleMissingIdentifierError");
     }
     name=e.name;
     constructor(e) {
         super(e, "An `identifier` must be supplied!");
     }
+}, N = class e extends R {
+    static {
+        i(this, "InjectionProviderModuleGlobalMarkError");
+    }
+    name=e.name;
+    constructor(e, i) {
+        super(e, i);
+    }
 };
 
 import { Container as U } from "inversify";
 
-var G = new U({
+var V = new U({
     defaultScope: "Singleton"
 });
 
-import { Container as V } from "inversify";
+import { Container as W } from "inversify";
 
-var W = class {
+var q = class {
     static {
         i(this, "ProviderModuleUtils");
     }
     get container() {
-        return this.module.toNaked().container;
+        return this.moduleNaked.container;
     }
     module;
     moduleNaked;
-    constructor(e) {
-        this.module = e, this.moduleNaked = e.toNaked();
+    appModule=L;
+    constructor(e, i) {
+        this.module = e, this.moduleNaked = e.toNaked(), this.appModule = i.appModule?.() ?? this.appModule, 
+        this.checkIfShouldBeImportedIntoAppModule();
     }
     bindToContainer(e, i) {
-        return r.isProviderIdentifier(e) ? this.bindSelfTokenToContainer(e, i) : r.isClassToken(e) ? this.bindClassTokenToContainer(e, i) : r.isValueToken(e) ? this.bindValueTokenToContainer(e) : !!r.isFactoryToken(e) && this.bindFactoryTokenToContainer(e, i);
+        return o.isProviderIdentifier(e) ? this.bindSelfTokenToContainer(e, i) : o.isClassToken(e) ? this.bindClassTokenToContainer(e, i) : o.isValueToken(e) ? this.bindValueTokenToContainer(e) : !!o.isFactoryToken(e) && this.bindFactoryTokenToContainer(e, i);
+    }
+    checkIfShouldBeImportedIntoAppModule() {
+        if (this.moduleNaked.isAppModule || !this.module.isMarkedAsGlobal) return;
+        const e = this.appModule.toNaked().imports?.some((e => this.module.toString() === e.toString()));
+        if (!e) throw new N(this.module, "Is marked as 'global' and has not been imported into the 'AppModule'!");
     }
     bindSelfTokenToContainer(e, i) {
-        return this.setBindingScope(e, this.container.bind(r.toServiceIdentifier(e)).toSelf(), i), 
+        return this.setBindingScope(e, this.container.bind(o.toServiceIdentifier(e)).toSelf(), i), 
         this.moduleNaked.__isCurrentBound(e);
     }
     bindClassTokenToContainer(e, i) {
-        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(r.toServiceIdentifier(e)).to(e.useClass), i))), 
+        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(o.toServiceIdentifier(e)).to(e.useClass), i))), 
         this.moduleNaked.__isCurrentBound(e);
     }
     bindValueTokenToContainer(e) {
-        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.container.bind(r.toServiceIdentifier(e)).toConstantValue(e.useValue))), 
+        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.container.bind(o.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(r.toServiceIdentifier(e)).toResolvedValue(e.useFactory, r.toServiceIdentifiers(e.inject ?? [])), i))), 
+        return this.setBindingOnEvent(e, this.setWhenBinding(e, this.setBindingScope(e, this.container.bind(o.toServiceIdentifier(e)).toResolvedValue(e.useFactory, o.toServiceIdentifiers(e.inject ?? [])), i))), 
         this.moduleNaked.__isCurrentBound(e);
     }
     setBindingScope(e, i, t) {
-        if (r.isValueToken(e)) return i;
-        switch (r.getInjectionScopeByPriority(e, t)) {
+        if (o.isValueToken(e)) return i;
+        switch (o.getInjectionScopeByPriority(e, t)) {
           case s.Singleton:
             return i.inSingletonScope();
 
@@ -303,20 +318,21 @@ var W = class {
         }
     }
     setWhenBinding(e, i) {
-        if (r.isProviderIdentifier(e)) return i;
+        if (o.isProviderIdentifier(e)) return i;
         const t = e.when;
         return t ? i.when(t) : i;
     }
     setBindingOnEvent(e, i) {
-        if (r.isProviderIdentifier(e)) return;
+        if (o.isProviderIdentifier(e)) return;
         const t = e;
         t.onEvent?.activation && i.onActivation(t.onEvent.activation), t.onEvent?.deactivation && i.onDeactivation(t.onEvent.deactivation);
     }
-}, q = class e {
+}, $ = class e {
     static {
         i(this, "ProviderModule");
     }
     identifier;
+    isMarkedAsGlobal=!1;
     isDisposed=!1;
     isAppModule;
     container;
@@ -331,17 +347,18 @@ var W = class {
     importedProviders;
     exports;
     registeredBindingSideEffects;
-    constructor({identifier: e, imports: i, providers: t, exports: n, defaultScope: r, dynamicExports: o, onReady: s, onDispose: d, ...c}) {
-        const a = c;
-        this.identifier = this.setIdentifier(e), this.isDisposed = a.isDisposed ?? !1, this.isAppModule = a.isAppModule ?? !1, 
+    constructor({identifier: e, imports: i, providers: t, exports: n, defaultScope: o, markAsGlobal: r, dynamicExports: s, onReady: d, onDispose: a, ...c}) {
+        const u = c;
+        this.identifier = this.setIdentifier(e), this.isDisposed = u.isDisposed ?? !1, this.isAppModule = u.isAppModule ?? !1, 
         this.isAppModule || this._lazyInit({
+            markAsGlobal: r,
             imports: i,
             providers: t,
             exports: n,
-            defaultScope: r,
-            dynamicExports: o,
-            onReady: s,
-            onDispose: d,
+            defaultScope: o,
+            dynamicExports: s,
+            onReady: d,
+            onDispose: a,
             ...c
         });
     }
@@ -352,22 +369,22 @@ var W = class {
     }
     getMany(...e) {
         return e.map((e => {
-            const i = l(e) && "provider" in e;
+            const i = f(e) && "provider" in e;
             return this.get(i ? e.provider : e, !!i && e.isOptional);
         }));
     }
     onActivationEvent(e, i) {
-        this.shouldThrowIfDisposed(), this.container.onActivation(r.toServiceIdentifier(e), i);
+        this.shouldThrowIfDisposed(), this.container.onActivation(o.toServiceIdentifier(e), i);
     }
     onDeactivationEvent(e, i) {
-        this.shouldThrowIfDisposed(), this.container.onDeactivation(r.toServiceIdentifier(e), i);
+        this.shouldThrowIfDisposed(), this.container.onDeactivation(o.toServiceIdentifier(e), i);
     }
     toNaked() {
         return this;
     }
     clone(i) {
         let t = [ ...this.providers ];
-        return i?.providersMap && (t = t.map((e => i.providersMap(e, this)))), new e(o.buildInternalConstructorParams({
+        return i?.providersMap && (t = t.map((e => i.providersMap(e, this)))), new e(r.buildInternalConstructorParams({
             isAppModule: this.isAppModule,
             identifier: this.identifier,
             defaultScope: this.defaultScope.native,
@@ -384,38 +401,48 @@ var W = class {
         return this.identifier?.description ?? "Unknown";
     }
     setIdentifier(e) {
-        if (!e) throw new N(this);
+        if (!e) throw new O(this);
         return e;
     }
     prepareContainer(e) {
-        return this.isAppModule ? e.container?.() ?? G : e.container ? (console.warn(`[xInjection]: The '${this.toString()}' module is using a dynamic container!`), 
-        e.container()) : new V({
-            parent: G,
+        return this.isAppModule ? e.container?.() ?? V : e.container ? (console.warn(`[xInjection]: The '${this.toString()}' module is using a dynamic container!`), 
+        e.container()) : new W({
+            parent: V,
             defaultScope: this.defaultScope.inversify
         });
     }
     injectImportedModules(t) {
         t && 0 !== t.length && t.forEach((t => {
             if ("GlobalAppModule" === t.toString()) throw new R(this, "The 'GlobalAppModule' can't be imported!");
-            const n = t._getExportableModulesAndProviders(), o = t.dynamicExports?.(this, n);
-            void 0 !== o && this.shouldThrowWhenModuleDynamicExportsDontMatchTheStaticExports(t, n, o), 
-            (o ?? n).forEach((n => {
+            const n = t._getExportableModulesAndProviders(), r = t.dynamicExports?.(this, n);
+            void 0 !== r && this.shouldThrowWhenModuleDynamicExportsDontMatchTheStaticExports(t, n, r), 
+            (r ?? n).forEach((n => {
                 if (n instanceof e) {
                     const e = n.toNaked();
                     return void this.injectImportedModules([ e ]);
                 }
-                const o = n, s = this.importedProvidersMap({
-                    scope: r.getInjectionScopeByPriority(o, t.defaultScope.native),
-                    provide: r.toServiceIdentifier(o),
-                    useFactory: i((() => t.get(o)), "useFactory")
-                }, o, t);
+                const r = n, s = this.importedProvidersMap({
+                    scope: o.getInjectionScopeByPriority(r, t.defaultScope.native),
+                    provide: o.toServiceIdentifier(r),
+                    useFactory: i((() => t.get(r)), "useFactory")
+                }, r, t);
                 this.importedProviders.set(t, [ ...this.importedProviders.get(t) ?? [], s ]), this.moduleUtils.bindToContainer(s, t.defaultScope.native), 
-                t._onUnbind(o, (() => this.__unbind(s)));
+                t._onUnbind(r, (() => this.__unbind(s)));
             }));
         }));
     }
     injectProviders() {
-        this.providers.forEach((e => this.moduleUtils.bindToContainer(e, this.defaultScope.native)));
+        this.providers.forEach((e => {
+            const t = o.toServiceIdentifier(e);
+            if (!(V.isCurrentBound(t) && this.exports.includes(e))) return void this.moduleUtils.bindToContainer(e, this.defaultScope.native);
+            const n = o.tryGetProviderOptions(e) ?? {};
+            delete n.useClass, delete n.useValue;
+            const r = {
+                ...n,
+                useFactory: i((() => V.get(t)), "useFactory")
+            };
+            this.moduleUtils.bindToContainer(r, this.defaultScope.native);
+        }));
     }
     registerBindingSideEffect(e, i, t) {
         this.registeredBindingSideEffects.has(e) || this.registeredBindingSideEffects.set(e, {
@@ -435,7 +462,7 @@ var W = class {
         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 O(e);
+        if (t.length > i.length || t.some((e => !i.includes(e)))) throw new G(e);
     }
     shouldThrowIfDisposed() {
         if (null === this.container) throw new F(this);
@@ -445,15 +472,16 @@ var W = class {
         this.imports = null, this.providers = null, this.importedProviders = null, this.exports = null, 
         this.dynamicExports = null, this.registeredBindingSideEffects = null, this.isDisposed = !0;
     }
-    _lazyInit({imports: e = [], providers: i = [], exports: t = [], defaultScope: n = s.Singleton, dynamicExports: r, onReady: o, onDispose: c, ...a}) {
-        return this.isDisposed = !1, this.imports = e, this.providers = i, this.importedProviders = a.importedProviders ?? new Map, 
-        this.exports = t, this.defaultScope = {
-            native: n,
-            inversify: d(n)
-        }, this.dynamicExports = r, this.onReady = o, this.onDispose = c, this.importedProvidersMap = a.importedProvidersMap ?? (e => e), 
+    _lazyInit({markAsGlobal: e, imports: i = [], providers: t = [], exports: n = [], defaultScope: o = s.Singleton, dynamicExports: r, onReady: a, onDispose: c, ...u}) {
+        return this.isMarkedAsGlobal = e ?? !1, this.isDisposed = !1, this.imports = i, 
+        this.providers = t, this.importedProviders = u.importedProviders ?? new Map, this.exports = n, 
+        this.defaultScope = {
+            native: o,
+            inversify: d(o)
+        }, this.dynamicExports = r, this.onReady = a, this.onDispose = c, this.importedProvidersMap = u.importedProvidersMap ?? (e => e), 
         this.container = this.prepareContainer({
-            ...a
-        }), this.moduleUtils = new W(this), this.registeredBindingSideEffects = new Map, 
+            ...u
+        }), this.moduleUtils = new q(this, u), this.registeredBindingSideEffects = new Map, 
         this.injectImportedModules(this._getImportedModules()), this.injectProviders(), 
         this.onReady?.(this), this;
     }
@@ -480,26 +508,26 @@ var W = class {
     }
     __bind(e) {
         this.shouldThrowIfDisposed();
-        const i = this.container.bind(r.toServiceIdentifier(e));
+        const i = this.container.bind(o.toServiceIdentifier(e));
         return this.invokeRegisteredBindingSideEffects(e, "onBind"), i;
     }
     __get(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.get(r.toServiceIdentifier(e), i);
+        return this.shouldThrowIfDisposed(), this.container.get(o.toServiceIdentifier(e), i);
     }
     async __getAsync(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.getAsync(r.toServiceIdentifier(e), i);
+        return this.shouldThrowIfDisposed(), this.container.getAsync(o.toServiceIdentifier(e), i);
     }
     __getAll(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.getAll(r.toServiceIdentifier(e), i);
+        return this.shouldThrowIfDisposed(), this.container.getAll(o.toServiceIdentifier(e), i);
     }
     async __getAllAsync(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.getAllAsync(r.toServiceIdentifier(e), i);
+        return this.shouldThrowIfDisposed(), this.container.getAllAsync(o.toServiceIdentifier(e), i);
     }
     __isBound(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.isBound(r.toServiceIdentifier(e), i);
+        return this.shouldThrowIfDisposed(), this.container.isBound(o.toServiceIdentifier(e), i);
     }
     __isCurrentBound(e, i) {
-        return this.shouldThrowIfDisposed(), this.container.isCurrentBound(r.toServiceIdentifier(e), i);
+        return this.shouldThrowIfDisposed(), this.container.isCurrentBound(o.toServiceIdentifier(e), i);
     }
     __takeSnapshot() {
         this.shouldThrowIfDisposed(), this.container.snapshot();
@@ -509,40 +537,42 @@ var W = class {
     }
     async __rebind(e) {
         this.shouldThrowIfDisposed();
-        const i = await this.container.rebind(r.toServiceIdentifier(e));
+        const i = await this.container.rebind(o.toServiceIdentifier(e));
         return this.invokeRegisteredBindingSideEffects(e, "onRebind"), i;
     }
     __rebindSync(e) {
         this.shouldThrowIfDisposed();
-        const i = this.container.rebindSync(r.toServiceIdentifier(e));
+        const i = this.container.rebindSync(o.toServiceIdentifier(e));
         return this.invokeRegisteredBindingSideEffects(e, "onRebind"), i;
     }
     async __unbind(e) {
-        this.shouldThrowIfDisposed(), await this.container.unbind(r.toServiceIdentifier(e)), 
+        this.shouldThrowIfDisposed(), await this.container.unbind(o.toServiceIdentifier(e)), 
         this.removeRegisteredBindingSideEffects(e);
     }
     __unbindSync(e) {
-        this.shouldThrowIfDisposed(), this.container.unbindSync(r.toServiceIdentifier(e)), 
+        this.shouldThrowIfDisposed(), this.container.unbindSync(o.toServiceIdentifier(e)), 
         this.removeRegisteredBindingSideEffects(e);
     }
     async __unbindAll() {
         this.shouldThrowIfDisposed(), await this.container.unbindAll(), this.removeRegisteredBindingSideEffects("all");
     }
-}, $ = class extends q {
+}, z = class extends $ {
     static {
         i(this, "GlobalAppModule");
     }
+    isMarkedAsGlobal=!0;
     nakedModule=this;
     isLoaded=!1;
     constructor() {
-        super(o.buildInternalConstructorParams({
+        super(r.buildInternalConstructorParams({
             identifier: Symbol(t),
             isAppModule: !0
         }));
     }
     register(e) {
-        if (this.isLoaded) throw new A(`The '${this.toString()}' has already been registered!`);
-        return this.nakedModule._lazyInit(e), this.isLoaded = !0, this;
+        if (this.isLoaded) throw new j(`The '${this.toString()}' has already been registered!`);
+        return this.nakedModule._lazyInit(e), this.checkIfImportsHaveGlobalMark(), this.isLoaded = !0, 
+        this;
     }
     toNaked() {
         return super.toNaked();
@@ -550,6 +580,11 @@ var W = class {
     async _dispose() {
         this.isLoaded = !1, super._dispose();
     }
-}, z = new $;
+    checkIfImportsHaveGlobalMark() {
+        this.imports.forEach((e => {
+            if (!e.isMarkedAsGlobal) throw new N(e, "Is not marked as `global` but has been imported into the `AppModule`!");
+        }));
+    }
+}, L = new z;
 
-export { z as AppModule, t as GLOBAL_APP_MODULE_ID, $ as GlobalAppModule, G as GlobalContainer, m as Inject, E as InjectFromBase, v as Injectable, s as InjectionScope, y as MultiInject, T as Named, w as Optional, D as PostConstruct, M as PreDestroy, q as ProviderModule, o as ProviderModuleHelpers, r as ProviderTokenHelpers, k as Tagged, j as Unmanaged, O as XInjectionDynamicExportsOutOfRange, A as XInjectionError, F as XInjectionProviderModuleDisposedError, R as XInjectionProviderModuleError, N as XInjectionProviderModuleMissingIdentifierError, c as bindingScopeToInjectionScope, d as injectionScopeToBindingScope, u as isClass, h as isClassOrFunction, p as isFunction, l as isPlainObject };//# sourceMappingURL=index.js.map
+export { L as AppModule, t as GLOBAL_APP_MODULE_ID, z as GlobalAppModule, V as GlobalContainer, g as Inject, b as InjectFromBase, v as Injectable, G as InjectionDynamicExportsOutOfRange, j as InjectionError, F as InjectionProviderModuleDisposedError, R as InjectionProviderModuleError, N as InjectionProviderModuleGlobalMarkError, O as InjectionProviderModuleMissingIdentifierError, s as InjectionScope, y as MultiInject, T as Named, w as Optional, B as PostConstruct, D as PreDestroy, $ as ProviderModule, r as ProviderModuleHelpers, o as ProviderTokenHelpers, A as Tagged, x as Unmanaged, a as bindingScopeToInjectionScope, d as injectionScopeToBindingScope, u as isClass, h as isClassOrFunction, p as isFunction, f as isPlainObject };//# sourceMappingURL=index.js.map