static-injector 2.0.0 → 2.1.1

package/import/es2015/di/create_injector.js

@@ -7,6 +7,7 @@
  */
 import { EMPTY_ARRAY } from '../util/empty';
 import { stringify } from '../util/stringify';
+import { importProvidersFrom } from './provider_collection';
 import { getNullInjector, R3Injector } from './r3_injector';
 /**
  * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
@@ -24,7 +25,10 @@ export function createInjector(defType, parent = null, additionalProviders = nul
  * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
  */
 export function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = new Set()) {
-    const providers = [additionalProviders || EMPTY_ARRAY];
+    const providers = [
+        additionalProviders || EMPTY_ARRAY,
+        importProvidersFrom(defType),
+    ];
     name = name || (typeof defType === 'object' ? undefined : stringify(defType));
     return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
 }

package/import/es2015/di/forward_ref.js

@@ -5,8 +5,8 @@
  * 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 { getClosureSafeProperty } from "../util/property";
-import { stringify } from "../util/stringify";
+import { getClosureSafeProperty } from '../util/property';
+import { stringify } from '../util/stringify';
 const __forward_ref__ = getClosureSafeProperty({
     __forward_ref__: getClosureSafeProperty,
 });
@@ -47,7 +47,7 @@ export function resolveForwardRef(type) {
 }
 /** Checks whether a function is wrapped by a `forwardRef`. */
 export function isForwardRef(fn) {
-    return (typeof fn === "function" &&
+    return (typeof fn === 'function' &&
         fn.hasOwnProperty(__forward_ref__) &&
         fn.__forward_ref__ === forwardRef);
 }

package/import/es2015/di/injection_token.js

@@ -14,11 +14,11 @@ import { ɵɵdefineInjectable } from './interface/defs';
  * parameterized type.
  *
  * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
- * the `Injector`. This provides additional level of type safety.
+ * the `Injector`. This provides an additional level of type safety.
  *
  * ```
  * interface MyInterface {...}
- * var myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
+ * const myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
  * // myInterface is inferred to be MyInterface.
  * ```
  *
@@ -26,14 +26,18 @@ import { ɵɵdefineInjectable } from './interface/defs';
  * (possibly by creating) a default value of the parameterized type `T`. This sets up the
  * `InjectionToken` using this factory as a provider as if it was defined explicitly in the
  * application's root injector. If the factory function, which takes zero arguments, needs to inject
- * dependencies, it can do so using the `inject` function. See below for an example.
+ * dependencies, it can do so using the `inject` function.
+ * As you can see in the Tree-shakable InjectionToken example below.
  *
  * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which
- * overrides the above behavior and marks the token as belonging to a particular `@NgModule`. As
- * mentioned above, `'root'` is the default value for `providedIn`.
+ * overrides the above behavior and marks the token as belonging to a particular `@NgModule` (note:
+ * this option is now deprecated). As mentioned above, `'root'` is the default value for
+ * `providedIn`.
+ *
+ * The `providedIn: NgModule` and `providedIn: 'any'` options are deprecated.
  *
  * @usageNotes
- * ### Basic Example
+ * ### Basic Examples
  *
  * ### Plain InjectionToken
  *
@@ -47,15 +51,18 @@ import { ɵɵdefineInjectable } from './interface/defs';
  * @publicApi
  */
 export class InjectionToken {
+    /**
+     * @param _desc   Description for the token,
+     *                used only for debugging purposes,
+     *                it should but does not need to be unique
+     * @param options Options for the token's usage, as described above
+     */
     constructor(_desc, options) {
         this._desc = _desc;
+        /** @internal */
+        this.ngMetadataName = 'InjectionToken';
         this.ɵprov = undefined;
         if (typeof options == 'number') {
-            // (typeof ngDevMode === "undefined" || ngDevMode) &&
-            //   assertLessThan(options, 0, "Only negative numbers are supported here");
-            // // This is a special hack to assign __NG_ELEMENT_ID__ to this instance.
-            // // See `InjectorMarkers`
-            // (this as any).__NG_ELEMENT_ID__ = options;
         }
         else if (options !== undefined) {
             this.ɵprov = ɵɵdefineInjectable({

package/import/es2015/di/injector_compatibility.js

@@ -5,10 +5,10 @@
  * 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 { getClosureSafeProperty } from '../util/property';
+import { RuntimeError } from '../errors';
 import { stringify } from '../util/stringify';
 import { resolveForwardRef } from './forward_ref';
-import { injectRootLimpMode } from './inject_switch';
+import { getInjectImplementation, injectRootLimpMode } from './inject_switch';
 import { InjectFlags, } from './interface/injector';
 const _THROW_IF_NOT_FOUND = {};
 export const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
@@ -23,10 +23,6 @@ const NG_TOKEN_PATH = 'ngTokenPath';
 const NEW_LINE = /\n/gm;
 const NO_NEW_LINE = 'ɵ';
 export const SOURCE = '__source';
-export const USE_VALUE = getClosureSafeProperty({
-    provide: String,
-    useValue: getClosureSafeProperty,
-});
 /**
  * Current injector value used by `inject`.
  * - `undefined`: it is an error to call `inject`
@@ -41,7 +37,7 @@ export function setCurrentInjector(injector) {
 }
 export function injectInjectorOnly(token, flags = InjectFlags.Default) {
     if (_currentInjector === undefined) {
-        throw new Error(`inject() must be called from an injection context`);
+        throw new RuntimeError(-203 /* RuntimeErrorCode.MISSING_INJECTION_CONTEXT */, null);
     }
     else if (_currentInjector === null) {
         return injectRootLimpMode(token, undefined, flags);
@@ -51,7 +47,19 @@ export function injectInjectorOnly(token, flags = InjectFlags.Default) {
     }
 }
 export function ɵɵinject(token, flags = InjectFlags.Default) {
-    return injectInjectorOnly(resolveForwardRef(token), flags);
+    return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
+}
+/**
+ * Throws an error indicating that a factory function could not be generated by the compiler for a
+ * particular class.
+ *
+ * The name of the class is not mentioned here, but will be in the generated factory function name
+ * and thus in the stack trace.
+ *
+ * @codeGenApi
+ */
+export function ɵɵinvalidFactoryDep(index) {
+    throw new RuntimeError(202 /* RuntimeErrorCode.INVALID_FACTORY_DEPENDENCY */, null);
 }
 /**
  * Injects a token from the currently active injector.
@@ -66,7 +74,7 @@ export function ɵɵinject(token, flags = InjectFlags.Default) {
  * @param token A token that represents a dependency that should be injected.
  * @param flags Optional flags that control how injection is executed.
  * The flags correspond to injection strategies that can be specified with
- * parameter decorators `@Host`, `@Self`, `@SkipSef`, and `@Optional`.
+ * parameter decorators `@Host`, `@Self`, `@SkipSelf`, and `@Optional`.
  * @returns the injected value if operation is successful, `null` otherwise.
  * @throws if called outside of a supported context.
  *
@@ -130,6 +138,7 @@ export function convertToBitFlags(flags) {
     // `InjectOptions` to `InjectFlags`.
     return (0 /* InternalInjectFlags.Default */ | // comment to force a line break in the formatter
         (flags.optional && 8 /* InternalInjectFlags.Optional */) |
+        0 |
         (flags.self && 2 /* InternalInjectFlags.Self */) |
         (flags.skipSelf &&
             4 /* InternalInjectFlags.SkipSelf */));
@@ -140,7 +149,7 @@ export function injectArgs(types) {
         const arg = resolveForwardRef(types[i]);
         if (Array.isArray(arg)) {
             if (arg.length === 0) {
-                throw new Error('Arguments array must have arguments.');
+                throw new RuntimeError(900 /* RuntimeErrorCode.INVALID_DIFFER_INPUT */, null);
             }
             let type = undefined;
             let flags = InjectFlags.Default;

package/import/es2015/di/injector_token.js

@@ -5,7 +5,7 @@
  * 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 { InjectionToken } from "./injection_token";
+import { InjectionToken } from './injection_token';
 /**
  * An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.
  *
@@ -14,8 +14,8 @@ import { InjectionToken } from "./injection_token";
  *
  * @publicApi
  */
-export const INJECTOR = new InjectionToken("INJECTOR", 
-// Dissable tslint because this is const enum which gets inlined not top level prop access.
+export const INJECTOR = new InjectionToken('INJECTOR', 
+// Disable tslint because this is const enum which gets inlined not top level prop access.
 // tslint:disable-next-line: no-toplevel-property-access
 -1 /* InjectorMarkers.Injector */ // Special value used by Ivy to identify `Injector`.
 );

package/import/es2015/di/interface/defs.js

@@ -58,7 +58,10 @@ export function ɵɵdefineInjector(options) {
  * @param type A type which may have its own (non-inherited) `ɵprov`.
  */
 export function getInjectableDef(type) {
-    return getOwnDefinition(type, NG_PROV_DEF);
+    return getOwnDefinition(type, NG_PROV_DEF) || null;
+}
+export function isInjectable(type) {
+    return getInjectableDef(type) !== null;
 }
 /**
  * Return definition only if it is defined directly on `type` and is not inherited from a base
@@ -67,9 +70,6 @@ export function getInjectableDef(type) {
 function getOwnDefinition(type, field) {
     return type.hasOwnProperty(field) ? type[field] : null;
 }
-export const NG_PROV_DEF = getClosureSafeProperty({
-    ɵprov: getClosureSafeProperty,
-});
 /**
  * Read the injectable def (`ɵprov`) for `type` or read the `ɵprov` from one of its ancestors.
  *
@@ -79,22 +79,15 @@ export const NG_PROV_DEF = getClosureSafeProperty({
  *     scenario if we find the `ɵprov` on an ancestor only.
  */
 export function getInheritedInjectableDef(type) {
-    const def = type && (type[NG_PROV_DEF] || type[NG_INJECTABLE_DEF]);
+    const def = type && (type[NG_PROV_DEF] || null);
     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;
     }
 }
-export const NG_INJECTABLE_DEF = getClosureSafeProperty({
-    ngInjectableDef: getClosureSafeProperty,
-});
 /** 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
@@ -109,3 +102,19 @@ function getTypeName(type) {
     const match = ('' + type).match(/^function\s*([^\s(]+)/);
     return match === null ? '' : match[1];
 }
+/**
+ * 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`)
+ */
+export function getInjectorDef(type) {
+    return type && (type.hasOwnProperty(NG_INJ_DEF) || false)
+        ? type[NG_INJ_DEF]
+        : null;
+}
+export const NG_PROV_DEF = getClosureSafeProperty({
+    ɵprov: getClosureSafeProperty,
+});
+export const NG_INJ_DEF = getClosureSafeProperty({
+    ɵinj: getClosureSafeProperty,
+});

package/import/es2015/di/interface/provider.js

@@ -5,4 +5,6 @@
  * 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
  */
-export {};
+export function isEnvironmentProviders(value) {
+    return value && !!value.ɵproviders;
+}

package/import/es2015/di/null_injector.js

@@ -5,13 +5,13 @@
  * 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 { stringify } from "../util/stringify";
-import { THROW_IF_NOT_FOUND } from "./injector_compatibility";
+import { stringify } from '../util/stringify';
+import { THROW_IF_NOT_FOUND } from './injector_compatibility';
 export class NullInjector {
     get(token, notFoundValue = THROW_IF_NOT_FOUND) {
         if (notFoundValue === THROW_IF_NOT_FOUND) {
             const error = new Error(`NullInjectorError: No provider for ${stringify(token)}!`);
-            error.name = "NullInjectorError";
+            error.name = 'NullInjectorError';
             throw error;
         }
         return notFoundValue;

package/import/es2015/di/provider_collection.js

@@ -5,8 +5,90 @@
  * 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 { getFactoryDef } from '../render3/definition_factory';
+import { deepForEach } from '../util/array_utils';
+import { EMPTY_ARRAY } from '../util/empty';
 import { getClosureSafeProperty } from '../util/property';
 import { resolveForwardRef } from './forward_ref';
+import { ENVIRONMENT_INITIALIZER } from './initializer_token';
+import { ɵɵinject as inject } from './injector_compatibility';
+import { getInjectorDef, } from './interface/defs';
+import { isEnvironmentProviders, } from './interface/provider';
+import { INJECTOR_DEF_TYPES } from './internal_tokens';
+/**
+ * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
+ * referenced in `@Component in a component injector.
+ */
+export function makeEnvironmentProviders(providers) {
+    return {
+        ɵproviders: providers,
+    };
+}
+/**
+ * Collects providers from all NgModules and standalone components, including transitively imported
+ * ones.
+ *
+ * Providers extracted via `importProvidersFrom` are only usable in an application injector or
+ * another environment injector (such as a route injector). They should not be used in component
+ * providers.
+ *
+ * More information about standalone components can be found in [this
+ * guide](guide/standalone-components).
+ *
+ * @usageNotes
+ * The results of the `importProvidersFrom` call can be used in the `bootstrapApplication` call:
+ *
+ * ```typescript
+ * await bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     importProvidersFrom(NgModuleOne, NgModuleTwo)
+ *   ]
+ * });
+ * ```
+ *
+ * You can also use the `importProvidersFrom` results in the `providers` field of a route, when a
+ * standalone component is used:
+ *
+ * ```typescript
+ * export const ROUTES: Route[] = [
+ *   {
+ *     path: 'foo',
+ *     providers: [
+ *       importProvidersFrom(NgModuleOne, NgModuleTwo)
+ *     ],
+ *     component: YourStandaloneComponent
+ *   }
+ * ];
+ * ```
+ *
+ * @returns Collected providers from the specified list of types.
+ * @publicApi
+ */
+export function importProvidersFrom(...sources) {
+    return {
+        ɵproviders: internalImportProvidersFrom(true, sources),
+        ɵfromNgModule: true,
+    };
+}
+export function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
+    const providersOut = [];
+    const dedup = new Set(); // already seen types
+    let injectorTypesWithProviders;
+    // Collect all providers from `ModuleWithProviders` types.
+    if (injectorTypesWithProviders !== undefined) {
+        processInjectorTypesWithProviders(injectorTypesWithProviders, providersOut);
+    }
+    return providersOut;
+}
+/**
+ * Collects all providers from the list of `ModuleWithProviders` and appends them to the provided
+ * array.
+ */
+function processInjectorTypesWithProviders(typesWithProviders, providersOut) {
+    for (let i = 0; i < typesWithProviders.length; i++) {
+        const { ngModule, providers } = typesWithProviders[i];
+    }
+}
 /**
  * The logic visits an `InjectorType`, an `InjectorTypeWithProviders`, or a standalone
  * `ComponentType`, and all of its transitive providers and collects providers.
@@ -23,11 +105,124 @@ export function walkProviderTree(container, providersOut, parents, dedup) {
     // The actual type which had the definition. Usually `container`, but may be an unwrapped type
     // from `InjectorTypeWithProviders`.
     let defType = null;
-    defType = container;
+    let injDef = getInjectorDef(container);
+    const cmpDef = !injDef && null;
+    if (!injDef && !cmpDef) {
+        // `container` is not an injector type or a component type. It might be:
+        //  * An `InjectorTypeWithProviders` that wraps an injector type.
+        //  * A standalone directive or pipe that got pulled in from a standalone component's
+        //    dependencies.
+        // Try to unwrap it as an `InjectorTypeWithProviders` first.
+        const ngModule = container.ngModule;
+        injDef = getInjectorDef(ngModule);
+        if (injDef) {
+            defType = ngModule;
+        }
+        else {
+            // Not a component or injector type, so ignore it.
+            return false;
+        }
+    }
+    else if (cmpDef && !cmpDef.standalone) {
+        return false;
+    }
+    else {
+        defType = container;
+    }
+    // Check for circular dependencies.
+    if (false) {
+    }
     // Check for multiple imports of the same module
+    const isDuplicate = dedup.has(defType);
+    if (cmpDef) {
+        if (isDuplicate) {
+            // This component definition has already been processed.
+            return false;
+        }
+        dedup.add(defType);
+        if (cmpDef.dependencies) {
+            const deps = typeof cmpDef.dependencies === 'function'
+                ? cmpDef.dependencies()
+                : cmpDef.dependencies;
+            for (const dep of deps) {
+                walkProviderTree(dep, providersOut, parents, dedup);
+            }
+        }
+    }
+    else if (injDef) {
+        // First, include providers from any imports.
+        if (injDef.imports != null && !isDuplicate) {
+            // Before processing defType's imports, add it to the set of parents. This way, if it ends
+            // up deeply importing itself, this can be detected.
+            // Add it to the set of dedups. This way we can detect multiple imports of the same module
+            dedup.add(defType);
+            let importTypesWithProviders;
+            try {
+                deepForEach(injDef.imports, (imported) => {
+                    if (walkProviderTree(imported, providersOut, parents, dedup)) {
+                        importTypesWithProviders || (importTypesWithProviders = []);
+                        // If the processed import is an injector type with providers, we store it in the
+                        // list of import types with providers, so that we can process those afterwards.
+                        importTypesWithProviders.push(imported);
+                    }
+                });
+            }
+            finally {
+                // Remove it from the parents set when finished.
+            }
+            // Imports which are declared with providers (TypeWithProviders) need to be processed
+            // after all imported modules are processed. This is similar to how View Engine
+            // processes/merges module imports in the metadata resolver. See: FW-1349.
+            if (importTypesWithProviders !== undefined) {
+                processInjectorTypesWithProviders(importTypesWithProviders, providersOut);
+            }
+        }
+        if (!isDuplicate) {
+            // Track the InjectorType and add a provider for it.
+            // It's important that this is done after the def's imports.
+            const factory = getFactoryDef(defType) || (() => new defType());
+            // Append extra providers to make more info available for consumers (to retrieve an injector
+            // type), as well as internally (to calculate an injection scope correctly and eagerly
+            // instantiate a `defType` when an injector is created).
+            providersOut.push(
+            // Provider to create `defType` using its factory.
+            { provide: defType, useFactory: factory, deps: EMPTY_ARRAY }, 
+            // Make this `defType` available to an internal logic that calculates injector scope.
+            { provide: INJECTOR_DEF_TYPES, useValue: defType, multi: true }, 
+            // Provider to eagerly instantiate `defType` via `ENVIRONMENT_INITIALIZER`.
+            {
+                provide: ENVIRONMENT_INITIALIZER,
+                useValue: () => inject(defType),
+                multi: true,
+            } //
+            );
+        }
+        // Next, include providers listed on the definition itself.
+        const defProviders = injDef.providers;
+        if (defProviders != null && !isDuplicate) {
+            const injectorType = container;
+        }
+    }
+    else {
+        // Should not happen, but just in case.
+        return false;
+    }
     return (defType !== container &&
         container.providers !== undefined);
 }
+function deepForEachProvider(providers, fn) {
+    for (let provider of providers) {
+        if (isEnvironmentProviders(provider)) {
+            provider = provider.ɵproviders;
+        }
+        if (Array.isArray(provider)) {
+            deepForEachProvider(provider, fn);
+        }
+        else {
+            fn(provider);
+        }
+    }
+}
 export const USE_VALUE = getClosureSafeProperty({
     provide: String,
     useValue: getClosureSafeProperty,