static-injector 1.0.10 → 2.0.0

package/import/es2015/di/r3_injector.js

@@ -6,14 +6,18 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { getFactoryDef } from '../render3/definition_factory';
-import { deepForEach, newArray } from '../util/array_utils';
+import { newArray } from '../util/array_utils';
+import { EMPTY_ARRAY } from '../util/empty';
 import { stringify } from '../util/stringify';
 import { resolveForwardRef } from './forward_ref';
+import { ENVIRONMENT_INITIALIZER } from './initializer_token';
 import { InjectionToken } from './injection_token';
-import { catchInjectorError, injectArgs, NG_TEMP_TOKEN_PATH, setCurrentInjector, THROW_IF_NOT_FOUND, USE_VALUE, ɵɵinject, } from './injector_compatibility';
+import { catchInjectorError, convertToBitFlags, injectArgs, NG_TEMP_TOKEN_PATH, setCurrentInjector, THROW_IF_NOT_FOUND, USE_VALUE, ɵɵinject, } from './injector_compatibility';
 import { INJECTOR } from './injector_token';
-import { getInjectableDef, } from './interface/defs';
+import { setInjectImplementation } from './inject_switch';
+import { getInheritedInjectableDef, getInjectableDef, } from './interface/defs';
 import { InjectFlags } from './interface/injector';
+import { INJECTOR_DEF_TYPES } from './internal_tokens';
 import { NullInjector } from './null_injector';
 import { INJECTOR_SCOPE } from './scope';
 /**
@@ -32,61 +36,51 @@ const CIRCULAR = {};
  * A lazily initialized NullInjector.
  */
 let NULL_INJECTOR = undefined;
-function getNullInjector() {
+export function getNullInjector() {
     if (NULL_INJECTOR === undefined) {
         NULL_INJECTOR = new NullInjector();
     }
     return NULL_INJECTOR;
 }
 /**
- * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
- *
- * @publicApi
+ * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
+ * component tree.
  */
-export function createInjector(defType, parent = null, additionalProviders = null, name) {
-    const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
-    injector._resolveInjectorDefTypes();
-    return injector;
+export class EnvironmentInjector {
 }
-/**
- * Creates a new injector without eagerly resolving its injector types. Can be used in places
- * where resolving the injector types immediately can lead to an infinite loop. The injector types
- * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
- */
-export function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name) {
-    return new R3Injector(defType, additionalProviders, parent || getNullInjector(), name);
-}
-export class R3Injector {
-    constructor(def, additionalProviders, parent, source = null) {
+export class R3Injector extends EnvironmentInjector {
+    constructor(providers, parent, source, scopes) {
+        super();
         this.parent = parent;
+        this.source = source;
+        this.scopes = scopes;
         /**
          * Map of tokens to records which contain the instances of those tokens.
          * - `null` value implies that we don't have the record. Used by tree-shakable injectors
          * to prevent further searches.
          */
         this.records = new Map();
-        /**
-         * The transitive set of `InjectorType`s which define this injector.
-         */
-        this.injectorDefTypes = new Set();
         /**
          * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
          */
-        this.onDestroy = new Set();
+        this._ngOnDestroyHooks = new Set();
+        this._onDestroyHooks = [];
         this._destroyed = false;
-        // Start off by creating Records for every provider declared in every InjectorType
-        // included transitively in additional providers then do the same for `def`. This order is
-        // important because `def` may include providers that override ones in additionalProviders.
-        additionalProviders &&
-            deepForEach(additionalProviders, (provider) => this.processProvider(provider, def, additionalProviders));
+        // Start off by creating Records for every provider.
+        forEachSingleProvider(providers, (provider) => this.processProvider(provider));
         // Make sure the INJECTOR token provides this injector.
         this.records.set(INJECTOR, makeRecord(undefined, this));
+        // And `EnvironmentInjector` if the current injector is supposed to be env-scoped.
+        if (scopes.has('environment')) {
+            this.records.set(EnvironmentInjector, makeRecord(undefined, this));
+        }
         // Detect whether this injector has the APP_ROOT_SCOPE token and thus should provide
         // any injectable scoped to APP_ROOT_SCOPE.
         const record = this.records.get(INJECTOR_SCOPE);
-        this.scope = record != null ? record.value : null;
-        // Source name, used for debugging
-        this.source = source || (typeof def === 'object' ? null : stringify(def));
+        if (record != null && typeof record.value === 'string') {
+            this.scopes.add(record.value);
+        }
+        this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES.multi, EMPTY_ARRAY, InjectFlags.Self));
     }
     /**
      * Flag indicating that this injector was previously destroyed.
@@ -106,19 +100,42 @@ export class R3Injector {
         this._destroyed = true;
         try {
             // Call all the lifecycle hooks.
-            this.onDestroy.forEach((service) => service.ngOnDestroy());
+            for (const service of this._ngOnDestroyHooks) {
+                service.ngOnDestroy();
+            }
+            for (const hook of this._onDestroyHooks) {
+                hook();
+            }
         }
         finally {
             // Release all references.
             this.records.clear();
-            this.onDestroy.clear();
+            this._ngOnDestroyHooks.clear();
             this.injectorDefTypes.clear();
+            this._onDestroyHooks.length = 0;
+        }
+    }
+    onDestroy(callback) {
+        this._onDestroyHooks.push(callback);
+    }
+    runInContext(fn) {
+        this.assertNotDestroyed();
+        const previousInjector = setCurrentInjector(this);
+        const previousInjectImplementation = setInjectImplementation(undefined);
+        try {
+            return fn();
+        }
+        finally {
+            setCurrentInjector(previousInjector);
+            setInjectImplementation(previousInjectImplementation);
         }
     }
     get(token, notFoundValue = THROW_IF_NOT_FOUND, flags = InjectFlags.Default) {
         this.assertNotDestroyed();
+        flags = convertToBitFlags(flags);
         // Set the injection context.
         const previousInjector = setCurrentInjector(this);
+        const previousInjectImplementation = setInjectImplementation(undefined);
         try {
             // Check for the SkipSelf flag.
             if (!(flags & InjectFlags.SkipSelf)) {
@@ -176,16 +193,31 @@ export class R3Injector {
         }
         finally {
             // Lastly, restore the previous injection context.
+            setInjectImplementation(previousInjectImplementation);
             setCurrentInjector(previousInjector);
         }
     }
     /** @internal */
-    _resolveInjectorDefTypes() {
-        this.injectorDefTypes.forEach((defType) => this.get(defType));
+    resolveInjectorInitializers() {
+        const previousInjector = setCurrentInjector(this);
+        const previousInjectImplementation = setInjectImplementation(undefined);
+        try {
+            const initializers = this.get(ENVIRONMENT_INITIALIZER.multi, EMPTY_ARRAY, InjectFlags.Self);
+            for (const initializer of initializers) {
+                initializer();
+            }
+        }
+        finally {
+            setCurrentInjector(previousInjector);
+            setInjectImplementation(previousInjectImplementation);
+        }
     }
     toString() {
-        const tokens = [], records = this.records;
-        records.forEach((v, token) => tokens.push(stringify(token)));
+        const tokens = [];
+        const records = this.records;
+        for (const token of records.keys()) {
+            tokens.push(stringify(token));
+        }
         return `R3Injector[${tokens.join(', ')}]`;
     }
     assertNotDestroyed() {
@@ -193,19 +225,10 @@ export class R3Injector {
             throw new Error('Injector has already been destroyed.');
         }
     }
-    /**
-     * Add an `InjectorType` or `InjectorTypeWithProviders` and all of its transitive providers
-     * to this injector.
-     *
-     * If an `InjectorTypeWithProviders` that declares providers besides the type is specified,
-     * the function will return "true" to indicate that the providers of the type definition need
-     * to be processed. This allows us to process providers of injector types after all imports of
-     * an injector definition are processed. (following View Engine semantics: see FW-1349)
-     */
     /**
      * Process a `SingleProvider` and add it.
      */
-    processProvider(provider, ngModuleType, providers) {
+    processProvider(provider) {
         // Determine the token from the provider. Either it's its own token, or has a {provide: ...}
         // property.
         provider = resolveForwardRef(provider);
@@ -213,16 +236,13 @@ export class R3Injector {
             ? provider
             : resolveForwardRef(provider && provider.provide);
         // Construct a `Record` for the provider.
-        const record = providerToRecord(provider, ngModuleType, providers);
+        const record = providerToRecord(provider);
         if (!isTypeProvider(provider) && provider.multi === true) {
             // If the provider indicates that it's a multi-provider, process it specially.
             // First check whether it's been defined already.
             let multiRecord = this.records.get(token);
             if (multiRecord) {
                 // It has. Throw a nice error if
-                // if (ngDevMode && multiRecord.multi === undefined) {
-                //   throwMixedMultiProviderError();
-                // }
             }
             else {
                 multiRecord = makeRecord(undefined, NOT_YET, true);
@@ -233,17 +253,11 @@ export class R3Injector {
             multiRecord.multi.push(provider);
         }
         else {
-            // const existing = this.records.get(token);
-            // if (ngDevMode && existing && existing.multi !== undefined) {
-            //   throwMixedMultiProviderError();
-            // }
+            const existing = this.records.get(token);
         }
         this.records.set(token, record);
     }
     hydrate(token, record) {
-        // if (ngDevMode && record.value === CIRCULAR) {
-        //   throwCyclicDependencyError(stringify(token));
-        // } else
         if (record.value === NOT_YET) {
             record.value = CIRCULAR;
             record.value = record.factory();
@@ -251,7 +265,7 @@ export class R3Injector {
         if (typeof record.value === 'object' &&
             record.value &&
             hasOnDestroy(record.value)) {
-            this.onDestroy.add(record.value);
+            this._ngOnDestroyHooks.add(record.value);
         }
         return record.value;
     }
@@ -261,7 +275,7 @@ export class R3Injector {
         }
         const providedIn = resolveForwardRef(def.providedIn);
         if (typeof providedIn === 'string') {
-            return providedIn === 'any' || providedIn === this.scope;
+            return providedIn === 'any' || this.scopes.has(providedIn);
         }
         else {
             return this.injectorDefTypes.has(providedIn);
@@ -299,14 +313,20 @@ function getUndecoratedInjectableFactory(token) {
     // def from an ancestor if there is one.
     // Otherwise this really is a simple class with no dependencies, so return a factory that
     // just instantiates the zero-arg constructor.
-    return () => new token();
+    const inheritedInjectableDef = getInheritedInjectableDef(token);
+    if (inheritedInjectableDef !== null) {
+        return () => inheritedInjectableDef.factory(token);
+    }
+    else {
+        return () => new token();
+    }
 }
-function providerToRecord(provider, ngModuleType, providers) {
+function providerToRecord(provider) {
     if (isValueProvider(provider)) {
         return makeRecord(undefined, provider.useValue);
     }
     else {
-        const factory = providerToFactory(provider, ngModuleType, providers);
+        const factory = providerToFactory(provider);
         return makeRecord(factory, NOT_YET);
     }
 }
@@ -380,3 +400,13 @@ function couldBeInjectableType(value) {
     return (typeof value === 'function' ||
         (typeof value === 'object' && value instanceof InjectionToken));
 }
+function forEachSingleProvider(providers, fn) {
+    for (const provider of providers) {
+        if (Array.isArray(provider)) {
+            forEachSingleProvider(provider, fn);
+        }
+        else {
+            fn(provider);
+        }
+    }
+}

package/import/es2015/di/scope.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 { InjectionToken } from "./injection_token";
+import { InjectionToken } from './injection_token';
 /**
  * An internal token whose presence in an injector indicates that the injector should treat itself
  * as a root scoped injector when processing requests for unknown tokens which may indicate
  * they are provided in the root scope.
  */
-export const INJECTOR_SCOPE = new InjectionToken("Set Injector scope.");
+export const INJECTOR_SCOPE = new InjectionToken('Set Injector scope.');

package/import/es2015/index.js

@@ -1,4 +1,4 @@
-export * from './decorator/injectable';
+export * from './di/injectable';
 export * from './di/metadata';
 export * from './di/r3_injector';
 export * from './di/interface/defs';

package/import/es2015/render3/errors_di.js

@@ -10,5 +10,5 @@ import { stringifyForError } from './util/stringify_utils';
 /** Throws an error when a token is not found in DI. */
 export function throwProviderNotFoundError(token, injectorName) {
     const injectorDetails = injectorName ? ` in ${injectorName}` : '';
-    throw new RuntimeError("201" /* PROVIDER_NOT_FOUND */, `No provider for ${stringifyForError(token)} found${injectorDetails}`);
+    throw new RuntimeError("201" /* RuntimeErrorCode.PROVIDER_NOT_FOUND */, `No provider for ${stringifyForError(token)} found${injectorDetails}`);
 }