@nx-ddd/core 3.1.0

package/di/interface/defs.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NG_INJECTOR_DEF = exports.NG_INJECTABLE_DEF = exports.NG_INJ_DEF = exports.NG_PROV_DEF = exports.getInjectorDef = exports.hasInjectaorDef = exports.getInheritedInjectableDef = exports.getInjectableDef = exports.ɵɵdefineInjector = exports.defineInjectable = exports.ɵɵdefineInjectable = void 0;
+const property_1 = require("../../util/property");
+/**
+ * Construct an injectable definition which defines how a token will be constructed by the DI
+ * system, and in which injectors (if any) it will be available.
+ *
+ * This should be assigned to a static `ɵprov` field on a type, which will then be an
+ * `InjectableType`.
+ *
+ * Options:
+ * * `providedIn` determines which injectors will include the injectable, by either associating it
+ *   with an `@NgModule` or other `InjectorType`, or by specifying that this injectable should be
+ *   provided in the `'root'` injector, which will be the application-level injector in most apps.
+ * * `factory` gives the zero argument function which will create an instance of the injectable.
+ *   The factory can call `inject` to access the `Injector` and request injection of dependencies.
+ *
+ * @codeGenApi
+ * @publicApi This instruction has been emitted by ViewEngine for some time and is deployed to npm.
+ */
+function ɵɵdefineInjectable(opts) {
+    return {
+        token: opts.token,
+        providedIn: opts.providedIn || null,
+        factory: opts.factory,
+        value: undefined,
+    };
+}
+exports.ɵɵdefineInjectable = ɵɵdefineInjectable;
+/**
+ * @deprecated in v8, delete after v10. This API should be used only by generated code, and that
+ * code should now use ɵɵdefineInjectable instead.
+ * @publicApi
+ */
+exports.defineInjectable = ɵɵdefineInjectable;
+/**
+ * Construct an `InjectorDef` which configures an injector.
+ *
+ * This should be assigned to a static injector def (`ɵinj`) field on a type, which will then be an
+ * `InjectorType`.
+ *
+ * Options:
+ *
+ * * `providers`: an optional array of providers to add to the injector. Each provider must
+ *   either have a factory or point to a type which has a `ɵprov` static property (the
+ *   type must be an `InjectableType`).
+ * * `imports`: an optional array of imports of other `InjectorType`s or `InjectorTypeWithModule`s
+ *   whose providers will also be added to the injector. Locally provided types will override
+ *   providers from imports.
+ *
+ * @codeGenApi
+ */
+function ɵɵdefineInjector(options) {
+    return { providers: options.providers || [], imports: options.imports || [] };
+}
+exports.ɵɵdefineInjector = ɵɵdefineInjector;
+/**
+ * Read the injectable def (`ɵprov`) for `type` in a way which is immune to accidentally reading
+ * inherited value.
+ *
+ * @param type A type which may have its own (non-inherited) `ɵprov`.
+ */
+function getInjectableDef(type) {
+    return getOwnDefinition(type, exports.NG_PROV_DEF) || getOwnDefinition(type, exports.NG_INJECTABLE_DEF);
+}
+exports.getInjectableDef = getInjectableDef;
+/**
+ * Return definition only if it is defined directly on `type` and is not inherited from a base
+ * class of `type`.
+ */
+function getOwnDefinition(type, field) {
+    return type.hasOwnProperty(field) ? type[field] : null;
+}
+/**
+ * Read the injectable def (`ɵprov`) for `type` or read the `ɵprov` from one of its ancestors.
+ *
+ * @param type A type which may have `ɵprov`, via inheritance.
+ *
+ * @deprecated Will be removed in a future version of Angular, where an error will occur in the
+ *     scenario if we find the `ɵprov` on an ancestor only.
+ */
+function getInheritedInjectableDef(type) {
+    const def = type && (type[exports.NG_PROV_DEF] || type[exports.NG_INJECTABLE_DEF]);
+    if (def) {
+        const typeName = getTypeName(type);
+        // TODO(FW-1307): Re-add ngDevMode when closure can handle it
+        // ngDevMode &&
+        console.warn(`DEPRECATED: DI is instantiating a token "${typeName}" that inherits its @Injectable decorator but does not provide one itself.\n` +
+            `This will become an error in a future version of Angular. Please add @Injectable() to the "${typeName}" class.`);
+        return def;
+    }
+    else {
+        return null;
+    }
+}
+exports.getInheritedInjectableDef = getInheritedInjectableDef;
+/** Gets the name of a type, accounting for some cross-browser differences. */
+function getTypeName(type) {
+    // `Function.prototype.name` behaves differently between IE and other browsers. In most browsers
+    // it'll always return the name of the function itself, no matter how many other functions it
+    // inherits from. On IE the function doesn't have its own `name` property, but it takes it from
+    // the lowest level in the prototype chain. E.g. if we have `class Foo extends Parent` most
+    // browsers will evaluate `Foo.name` to `Foo` while IE will return `Parent`. We work around
+    // the issue by converting the function to a string and parsing its name out that way via a regex.
+    if (type.hasOwnProperty('name')) {
+        return type.name;
+    }
+    const match = ('' + type).match(/^function\s*([^\s(]+)/);
+    return match === null ? '' : match[1];
+}
+function hasInjectaorDef(type) {
+    return type && (type.hasOwnProperty(exports.NG_INJ_DEF) || type.hasOwnProperty(exports.NG_INJECTOR_DEF));
+}
+exports.hasInjectaorDef = hasInjectaorDef;
+/**
+ * Read the injector def type in a way which is immune to accidentally reading inherited value.
+ *
+ * @param type type which may have an injector def (`ɵinj`)
+ */
+function getInjectorDef(type) {
+    return hasInjectaorDef(type) ? type[exports.NG_INJ_DEF] : null;
+}
+exports.getInjectorDef = getInjectorDef;
+exports.NG_PROV_DEF = (0, property_1.getClosureSafeProperty)({ ɵprov: property_1.getClosureSafeProperty });
+exports.NG_INJ_DEF = (0, property_1.getClosureSafeProperty)({ ɵinj: property_1.getClosureSafeProperty });
+// We need to keep these around so we can read off old defs if new defs are unavailable
+exports.NG_INJECTABLE_DEF = (0, property_1.getClosureSafeProperty)({ ngInjectableDef: property_1.getClosureSafeProperty });
+exports.NG_INJECTOR_DEF = (0, property_1.getClosureSafeProperty)({ ngInjectorDef: property_1.getClosureSafeProperty });
+//# sourceMappingURL=defs.js.map

package/di/interface/defs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defs.js","sourceRoot":"","sources":["../../../../../libs/core/src/di/interface/defs.ts"],"names":[],"mappings":"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"}

package/di/interface/provider.d.ts

@@ -0,0 +1,324 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Type } from "./type";
+/**
+ * Configures the `Injector` to return a value for a token.
+ * Base for `ValueProvider` decorator.
+ *
+ * @publicApi
+ */
+export interface ValueSansProvider {
+    /**
+     * The value to inject.
+     */
+    useValue: any;
+}
+/**
+ * Configures the `Injector` to return a value for a token.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='ValueProvider'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface ValueProvider extends ValueSansProvider {
+    /**
+     * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.
+     */
+    provide: any;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Configures the `Injector` to return an instance of `useClass` for a token.
+ * Base for `StaticClassProvider` decorator.
+ *
+ * @publicApi
+ */
+export interface StaticClassSansProvider {
+    /**
+     * An optional class to instantiate for the `token`. By default, the `provide`
+     * class is instantiated.
+     */
+    useClass: Type<any>;
+    /**
+     * A list of `token`s to be resolved by the injector. The list of values is then
+     * used as arguments to the `useClass` constructor.
+     */
+    deps: any[];
+}
+/**
+ * Configures the `Injector` to return an instance of `useClass` for a token.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='StaticClassProvider'}
+ *
+ * Note that following two providers are not equal:
+ *
+ * {@example core/di/ts/provider_spec.ts region='StaticClassProviderDifference'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface StaticClassProvider extends StaticClassSansProvider {
+    /**
+     * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.
+     */
+    provide: any;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Configures the `Injector` to return an instance of a token.
+ *
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * ```ts
+ * @Injectable(SomeModule, {deps: []})
+ * class MyService {}
+ * ```
+ *
+ * @publicApi
+ */
+export interface ConstructorSansProvider {
+    /**
+     * A list of `token`s to be resolved by the injector.
+     */
+    deps?: any[];
+}
+/**
+ * Configures the `Injector` to return an instance of a token.
+ *
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface ConstructorProvider extends ConstructorSansProvider {
+    /**
+     * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.
+     */
+    provide: Type<any>;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Configures the `Injector` to return a value of another `useExisting` token.
+ *
+ * @see `ExistingProvider`
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @publicApi
+ */
+export interface ExistingSansProvider {
+    /**
+     * Existing `token` to return. (Equivalent to `injector.get(useExisting)`)
+     */
+    useExisting: any;
+}
+/**
+ * Configures the `Injector` to return a value of another `useExisting` token.
+ *
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='ExistingProvider'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface ExistingProvider extends ExistingSansProvider {
+    /**
+     * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.
+     */
+    provide: any;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Configures the `Injector` to return a value by invoking a `useFactory` function.
+ *
+ * @see `FactoryProvider`
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @publicApi
+ */
+export interface FactorySansProvider {
+    /**
+     * A function to invoke to create a value for this `token`. The function is invoked with
+     * resolved values of `token`s in the `deps` field.
+     */
+    useFactory: Function;
+    /**
+     * A list of `token`s to be resolved by the injector. The list of values is then
+     * used as arguments to the `useFactory` function.
+     */
+    deps?: any[];
+}
+/**
+ * Configures the `Injector` to return a value by invoking a `useFactory` function.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='FactoryProvider'}
+ *
+ * Dependencies can also be marked as optional:
+ *
+ * {@example core/di/ts/provider_spec.ts region='FactoryProviderOptionalDeps'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface FactoryProvider extends FactorySansProvider {
+    /**
+     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+     */
+    provide: any;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Describes how an `Injector` should be configured as static (that is, without reflection).
+ * A static provider provides tokens to an injector for various types of dependencies.
+ *
+ * @see `Injector.create()`.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection-providers).
+ *
+ * @publicApi
+ */
+export declare type StaticProvider = ValueProvider | ExistingProvider | StaticClassProvider | ConstructorProvider | FactoryProvider | any[];
+/**
+ * Configures the `Injector` to return an instance of `Type` when `Type' is used as the token.
+ *
+ * Create an instance by invoking the `new` operator and supplying additional arguments.
+ * This form is a short form of `TypeProvider`;
+ *
+ * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='TypeProvider'}
+ *
+ * @publicApi
+ */
+export interface TypeProvider extends Type<any> {
+}
+/**
+ * Configures the `Injector` to return a value by invoking a `useClass` function.
+ * Base for `ClassProvider` decorator.
+ *
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @publicApi
+ */
+export interface ClassSansProvider {
+    /**
+     * Class to instantiate for the `token`.
+     */
+    useClass: Type<any>;
+}
+/**
+ * Configures the `Injector` to return an instance of `useClass` for a token.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='ClassProvider'}
+ *
+ * Note that following two providers are not equal:
+ *
+ * {@example core/di/ts/provider_spec.ts region='ClassProviderDifference'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface ClassProvider extends ClassSansProvider {
+    /**
+     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+     */
+    provide: any;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Describes how the `Injector` should be configured.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @see `StaticProvider`
+ *
+ * @publicApi
+ */
+export declare type Provider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | any[];
+/**
+ * Describes a function that is used to process provider lists (such as provider
+ * overrides).
+ */
+export declare type ProcessProvidersFunction = (providers: Provider[]) => Provider[];
+/**
+ * A wrapper around an NgModule that associates it with [providers](guide/glossary#provider
+ * "Definition"). Usage without a generic type is deprecated.
+ *
+ * @see [Deprecations](guide/deprecations#modulewithproviders-type-without-a-generic)
+ *
+ * @publicApi
+ */
+export interface ModuleWithProviders<T> {
+    nxModule: Type<T>;
+    providers?: Provider[];
+}

package/di/interface/provider.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=provider.js.map

package/di/interface/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","sourceRoot":"","sources":["../../../../../libs/core/src/di/interface/provider.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG"}

package/di/interface/type.d.ts

@@ -0,0 +1,3 @@
+export interface Type<T> extends Function {
+    new (...args: any[]): T;
+}

package/di/interface/type.js

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

package/di/interface/type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.js","sourceRoot":"","sources":["../../../../../libs/core/src/di/interface/type.ts"],"names":[],"mappings":""}

package/di/provider-collection.d.ts

@@ -0,0 +1,7 @@
+import { Type } from './interface/type';
+import { InjectorTypeWithProviders } from './interface/defs';
+import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, ModuleWithProviders, Provider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
+export declare type ImportProvidersSource = Type<unknown> | ModuleWithProviders<unknown> | Array<ImportProvidersSource>;
+export declare type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
+export declare function internalImportProvidersFrom(...sources: ImportProvidersSource[]): SingleProvider[];
+export declare function walkProviderTree(sources: (Type<unknown> | InjectorTypeWithProviders<unknown>)[], parents: Type<unknown>[], callback: (providers: Provider[]) => void, dedup?: Set<Type<unknown>>): void;

package/di/provider-collection.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkProviderTree = exports.internalImportProvidersFrom = void 0;
+const defs_1 = require("./interface/defs");
+const forward_ref_1 = require("./forward_ref");
+const array_utils_1 = require("../util/array_utils");
+const definition_factory_1 = require("./definition-factory");
+const empty_1 = require("../util/empty");
+function internalImportProvidersFrom(...sources) {
+    const providersOut = [];
+    walkProviderTree(sources, [], (providers) => {
+        (0, array_utils_1.deepForEach)(providers, provider => providersOut.push(provider));
+    });
+    return providersOut;
+}
+exports.internalImportProvidersFrom = internalImportProvidersFrom;
+function getNxModuleType(container) {
+    const isNxModuleType = (obj) => (0, defs_1.hasInjectaorDef)(obj);
+    return isNxModuleType(container) ? container : container.nxModule;
+}
+function walkProviderTree(sources, parents, callback, dedup = new Set()) {
+    (0, array_utils_1.deepForEach)(sources, container => {
+        var _a, _b, _c;
+        container = (0, forward_ref_1.resolveForwardRef)(container);
+        if (!container)
+            return;
+        const nxModuleType = getNxModuleType(container);
+        const injDef = (0, defs_1.getInjectorDef)(nxModuleType);
+        if (!injDef)
+            return;
+        if (!dedup.has(nxModuleType) && dedup.add(nxModuleType)) {
+            walkProviderTree((_a = injDef.imports) !== null && _a !== void 0 ? _a : [], parents, callback, dedup);
+            callback([
+                { provide: nxModuleType, useFactory: (0, definition_factory_1.getFactoryDef)(nxModuleType) || (() => new nxModuleType()), deps: empty_1.EMPTY_ARRAY },
+                // { provide: INJECTOR_DEF_TYPES, useValue: nxModuleType, multi: true },
+                // { provide: ENVIRONMENT_INITIALIZER, useValue: () => inject(nxModuleType!), multi: true },
+                ...((_b = injDef.providers) !== null && _b !== void 0 ? _b : []),
+            ]);
+        }
+        const isInjectorTypeWithProviders = (container) => container !== nxModuleType;
+        isInjectorTypeWithProviders(container) && callback((_c = container.providers) !== null && _c !== void 0 ? _c : []);
+    });
+}
+exports.walkProviderTree = walkProviderTree;
+//# sourceMappingURL=provider-collection.js.map

package/di/provider-collection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-collection.js","sourceRoot":"","sources":["../../../../libs/core/src/di/provider-collection.ts"],"names":[],"mappings":";;;AACA,2CAA8F;AAE9F,+CAAkD;AAClD,qDAAkD;AAClD,6DAAqD;AACrD,yCAA4C;AAc5C,SAAgB,2BAA2B,CAAC,GAAG,OAAgC;IAC7E,MAAM,YAAY,GAAqB,EAAE,CAAC;IAC1C,gBAAgB,CAAC,OAAgE,EAAE,EAAE,EAAE,CAAC,SAAgB,EAAE,EAAE;QAC1G,IAAA,yBAAW,EAAC,SAAS,EAAE,QAAQ,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IACH,OAAO,YAAY,CAAC;AACtB,CAAC;AAND,kEAMC;AAED,SAAS,eAAe,CAAC,SAA6D;IACpF,MAAM,cAAc,GAAG,CAAC,GAAG,EAAwB,EAAE,CAAC,IAAA,sBAAe,EAAC,GAAG,CAAC,CAAC;IAC3E,OAAO,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC;AACpE,CAAC;AAED,SAAgB,gBAAgB,CAC9B,OAA+D,EAC/D,OAAwB,EACxB,QAAyC,EACzC,QAAQ,IAAI,GAAG,EAAiB;IAEhC,IAAA,yBAAW,EAAC,OAAO,EAAE,SAAS,CAAC,EAAE;;QAC/B,SAAS,GAAG,IAAA,+BAAiB,EAAC,SAAS,CAAC,CAAC;QACzC,IAAI,CAAC,SAAS;YAAE,OAAO;QAEvB,MAAM,YAAY,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,IAAA,qBAAc,EAAC,YAAY,CAAC,CAAC;QAC5C,IAAI,CAAC,MAAM;YAAE,OAAO;QAEpB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;YACvD,gBAAgB,CAAC,MAAA,MAAM,CAAC,OAAO,mCAAI,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;YACjE,QAAQ,CAAC;gBACP,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,IAAA,kCAAa,EAAC,YAAY,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,YAAa,EAAE,CAAC,EAAE,IAAI,EAAE,mBAAW,EAAE;gBACpH,wEAAwE;gBACxE,4FAA4F;gBAC5F,GAAG,CAAC,MAAA,MAAM,CAAC,SAAS,mCAAI,EAAE,CAAC;aAC5B,CAAC,CAAC;SACJ;QAED,MAAM,2BAA2B,GAC/B,CAAC,SAAS,EAA+C,EAAE,CAAC,SAAS,KAAK,YAAY,CAAC;QAEzF,2BAA2B,CAAC,SAAS,CAAC,IAAI,QAAQ,CAAC,MAAA,SAAS,CAAC,SAAS,mCAAI,EAAE,CAAC,CAAC;IAChF,CAAC,CAAC,CAAC;AACL,CAAC;AA7BD,4CA6BC"}

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './di';
+export * from './nx-module';

package/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./di"), exports);
+tslib_1.__exportStar(require("./nx-module"), exports);
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../libs/core/src/index.ts"],"names":[],"mappings":";;;AAAA,+CAAqB;AACrB,sDAA4B"}

package/nx-module/index.d.ts

@@ -0,0 +1,2 @@
+export * from './nx-module-ref';
+export * from './nx-module';

package/nx-module/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./nx-module-ref"), exports);
+tslib_1.__exportStar(require("./nx-module"), exports);
+//# sourceMappingURL=index.js.map

package/nx-module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/core/src/nx-module/index.ts"],"names":[],"mappings":";;;AAAA,0DAAgC;AAChC,sDAA4B"}

package/nx-module/nx-module-ref.d.ts

@@ -0,0 +1,15 @@
+import { Injector } from 'injection-js';
+export declare type Type<T> = any;
+export declare function createNxModuleRef<T>(moduleType: Type<T>, injector?: Injector): NxModuleRef<T>;
+export declare class NxModuleRef<T = any> {
+    nxModuleType: Type<T>;
+    _parent: Injector;
+    injector: Injector;
+    instance: T;
+    constructor(nxModuleType: Type<T>, _parent: Injector);
+}
+export declare class NxModuleFactory<T> {
+    moduleType: Type<T>;
+    constructor(moduleType: Type<T>);
+    create(parentInjector: Injector | null): NxModuleRef<T>;
+}

package/nx-module/nx-module-ref.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxModuleFactory = exports.NxModuleRef = exports.createNxModuleRef = void 0;
+const create_injector_1 = require("../di/create-injector");
+function createNxModuleRef(moduleType, injector) {
+    return new NxModuleRef(moduleType, injector !== null && injector !== void 0 ? injector : null);
+}
+exports.createNxModuleRef = createNxModuleRef;
+class NxModuleRef {
+    constructor(nxModuleType, _parent) {
+        this.nxModuleType = nxModuleType;
+        this._parent = _parent;
+        this.injector = (0, create_injector_1.createInjectorWithoutInjectorInstances)(nxModuleType, _parent);
+        this.instance = this.injector.get(nxModuleType);
+    }
+}
+exports.NxModuleRef = NxModuleRef;
+class NxModuleFactory {
+    constructor(moduleType) {
+        this.moduleType = moduleType;
+    }
+    create(parentInjector) {
+        return new NxModuleRef(this.moduleType, parentInjector);
+    }
+}
+exports.NxModuleFactory = NxModuleFactory;
+//# sourceMappingURL=nx-module-ref.js.map

package/nx-module/nx-module-ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx-module-ref.js","sourceRoot":"","sources":["../../../../libs/core/src/nx-module/nx-module-ref.ts"],"names":[],"mappings":";;;AACA,2DAA+E;AAI/E,SAAgB,iBAAiB,CAAI,UAAmB,EAAE,QAAmB;IAC3E,OAAO,IAAI,WAAW,CAAC,UAAU,EAAE,QAAQ,aAAR,QAAQ,cAAR,QAAQ,GAAI,IAAI,CAAC,CAAC;AACvD,CAAC;AAFD,8CAEC;AAED,MAAa,WAAW;IAItB,YACS,YAAqB,EACrB,OAAiB;QADjB,iBAAY,GAAZ,YAAY,CAAS;QACrB,YAAO,GAAP,OAAO,CAAU;QAExB,IAAI,CAAC,QAAQ,GAAG,IAAA,wDAAsC,EAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QAC9E,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAClD,CAAC;CACF;AAXD,kCAWC;AAED,MAAa,eAAe;IAC1B,YAAmB,UAAmB;QAAnB,eAAU,GAAV,UAAU,CAAS;IAAI,CAAC;IAE3C,MAAM,CAAC,cAA6B;QAClC,OAAO,IAAI,WAAW,CAAC,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;IAC1D,CAAC;CACF;AAND,0CAMC"}

package/nx-module/nx-module.d.ts

@@ -0,0 +1,5 @@
+export interface NxModule {
+    imports?: any[];
+    providers?: any[];
+}
+export declare function NxModule(nxModule: NxModule): (target: any) => any;

package/nx-module/nx-module.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxModule = void 0;
+const defs_1 = require("../di/interface/defs");
+function NxModule(nxModule) {
+    return function (target) {
+        var _a, _b;
+        target[defs_1.NG_INJ_DEF] = {
+            imports: [...((_a = nxModule.imports) !== null && _a !== void 0 ? _a : [])],
+            providers: [...((_b = nxModule.providers) !== null && _b !== void 0 ? _b : [])],
+        };
+        return target;
+    };
+}
+exports.NxModule = NxModule;
+//# sourceMappingURL=nx-module.js.map

package/nx-module/nx-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx-module.js","sourceRoot":"","sources":["../../../../libs/core/src/nx-module/nx-module.ts"],"names":[],"mappings":";;;AAAA,+CAAkD;AAOlD,SAAgB,QAAQ,CAAC,QAAkB;IACzC,OAAO,UAAU,MAAM;;QACrB,MAAM,CAAC,iBAAU,CAAC,GAAG;YACnB,OAAO,EAAE,CAAC,GAAG,CAAC,MAAA,QAAQ,CAAC,OAAO,mCAAI,EAAE,CAAC,CAAC;YACtC,SAAS,EAAE,CAAC,GAAG,CAAC,MAAA,QAAQ,CAAC,SAAS,mCAAI,EAAE,CAAC,CAAC;SAC3C,CAAC;QACF,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC;AARD,4BAQC"}