static-injector 1.0.9 → 2.0.0

package/import/commonjs/index.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -244,7 +242,7 @@ function stringifyForError(value) {
 /** Throws an error when a token is not found in DI. */
 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}`);
 }
 
 /**
@@ -318,6 +316,45 @@ function getOwnDefinition(type, field) {
 const NG_PROV_DEF = getClosureSafeProperty({
     ɵprov: getClosureSafeProperty,
 });
+/**
+ * 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[NG_PROV_DEF] || type[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;
+    }
+}
+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
+    // 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];
+}
 
 /**
  * @license
@@ -330,6 +367,7 @@ const NG_PROV_DEF = getClosureSafeProperty({
  * Injection flags for DI.
  *
  * @publicApi
+ * @deprecated use an options object for `inject` instead.
  */
 exports.InjectFlags = void 0;
 (function (InjectFlags) {
@@ -352,6 +390,27 @@ exports.InjectFlags = void 0;
  * 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
  */
+/**
+ * Current implementation of inject.
+ *
+ * By default, it is `injectInjectorOnly`, which makes it `Injector`-only aware. It can be changed
+ * to `directiveInject`, which brings in the `NodeInjector` system of ivy. It is designed this
+ * way for two reasons:
+ *  1. `Injector` should not depend on ivy logic.
+ *  2. To maintain tree shake-ability we don't want to bring in unnecessary code.
+ */
+let _injectImplementation;
+function getInjectImplementation() {
+    return _injectImplementation;
+}
+/**
+ * Sets the current inject implementation.
+ */
+function setInjectImplementation(impl) {
+    const previous = _injectImplementation;
+    _injectImplementation = impl;
+    return previous;
+}
 /**
  * Injects `root` tokens in limp mode.
  *
@@ -361,7 +420,7 @@ exports.InjectFlags = void 0;
  */
 function injectRootLimpMode(token, notFoundValue, flags) {
     const injectableDef = getInjectableDef(token);
-    if (injectableDef && injectableDef.providedIn == "root") {
+    if (injectableDef && injectableDef.providedIn == 'root') {
         return injectableDef.value === undefined
             ? (injectableDef.value = injectableDef.factory())
             : injectableDef.value;
@@ -370,7 +429,7 @@ function injectRootLimpMode(token, notFoundValue, flags) {
         return null;
     if (notFoundValue !== undefined)
         return notFoundValue;
-    throwProviderNotFoundError(stringify(token), "Injector");
+    throwProviderNotFoundError(stringify(token), 'Injector');
 }
 
 /**
@@ -387,12 +446,12 @@ const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
  * InjectFlag this decorator represents. This allows to avoid direct references to the DI decorators
  * in the code, thus making them tree-shakable.
  */
-const DI_DECORATOR_FLAG = "__NG_DI_FLAG__";
-const NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
-const NG_TOKEN_PATH = "ngTokenPath";
+const DI_DECORATOR_FLAG = '__NG_DI_FLAG__';
+const NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';
+const NG_TOKEN_PATH = 'ngTokenPath';
 const NEW_LINE = /\n/gm;
-const NO_NEW_LINE = "ɵ";
-const SOURCE = "__source";
+const NO_NEW_LINE = 'ɵ';
+const SOURCE = '__source';
 const USE_VALUE = getClosureSafeProperty({
     provide: String,
     useValue: getClosureSafeProperty,
@@ -425,45 +484,101 @@ function ɵɵinject(token, flags = exports.InjectFlags.Default) {
 }
 /**
  * Injects a token from the currently active injector.
- *
- * Must be used in the context of a factory function such as one defined for an
- * `InjectionToken`. Throws an error if not called from such a context.
- *
- * Within such a factory function, using this function to request injection of a dependency
- * is faster and more type-safe than providing an additional array of dependencies
- * (as has been common with `useFactory` providers).
- *
- * @param token The injection token for the dependency to be injected.
+ * `inject` is only supported during instantiation of a dependency by the DI system. It can be used
+ * during:
+ * - Construction (via the `constructor`) of a class being instantiated by the DI system, such
+ * as an `@Injectable` or `@Component`.
+ * - In the initializer for fields of such classes.
+ * - In the factory function specified for `useFactory` of a `Provider` or an `@Injectable`.
+ * - In the `factory` function specified for an `InjectionToken`.
+ *
+ * @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`.
- * @returns the injected value if injection is successful, `null` otherwise.
+ * @returns the injected value if operation is successful, `null` otherwise.
+ * @throws if called outside of a supported context.
  *
  * @usageNotes
+ * In practice the `inject()` calls are allowed in a constructor, a constructor parameter and a
+ * field initializer:
+ *
+ * ```typescript
+ * @Injectable({providedIn: 'root'})
+ * export class Car {
+ *   radio: Radio|undefined;
+ *   // OK: field initializer
+ *   spareTyre = inject(Tyre);
+ *
+ *   constructor() {
+ *     // OK: constructor body
+ *     this.radio = inject(Radio);
+ *   }
+ * }
+ * ```
  *
- * ### Example
+ * It is also legal to call `inject` from a provider's factory:
  *
- * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
+ * ```typescript
+ * providers: [
+ *   {provide: Car, useFactory: () => {
+ *     // OK: a class factory
+ *     const engine = inject(Engine);
+ *     return new Car(engine);
+ *   }}
+ * ]
+ * ```
+ *
+ * Calls to the `inject()` function outside of the class creation context will result in error. Most
+ * notably, calls to `inject()` are disallowed after a class instance was created, in methods
+ * (including lifecycle hooks):
+ *
+ * ```typescript
+ * @Component({ ... })
+ * export class CarComponent {
+ *   ngOnInit() {
+ *     // ERROR: too late, the component instance was already created
+ *     const engine = inject(Engine);
+ *     engine.start();
+ *   }
+ * }
+ * ```
  *
  * @publicApi
  */
-const inject = ɵɵinject;
+function inject(token, flags = exports.InjectFlags.Default) {
+    return ɵɵinject(token, convertToBitFlags(flags));
+}
+// Converts object-based DI flags (`InjectOptions`) to bit flags (`InjectFlags`).
+function convertToBitFlags(flags) {
+    if (typeof flags === 'undefined' || typeof flags === 'number') {
+        return flags;
+    }
+    // While TypeScript doesn't accept it without a cast, bitwise OR with false-y values in
+    // JavaScript is a no-op. We can use that for a very codesize-efficient conversion from
+    // `InjectOptions` to `InjectFlags`.
+    return (0 /* InternalInjectFlags.Default */ | // comment to force a line break in the formatter
+        (flags.optional && 8 /* InternalInjectFlags.Optional */) |
+        (flags.self && 2 /* InternalInjectFlags.Self */) |
+        (flags.skipSelf &&
+            4 /* InternalInjectFlags.SkipSelf */));
+}
 function injectArgs(types) {
     const args = [];
     for (let i = 0; i < types.length; i++) {
         const arg = resolveForwardRef(types[i]);
         if (Array.isArray(arg)) {
             if (arg.length === 0) {
-                throw new Error("Arguments array must have arguments.");
+                throw new Error('Arguments array must have arguments.');
             }
             let type = undefined;
             let flags = exports.InjectFlags.Default;
             for (let j = 0; j < arg.length; j++) {
                 const meta = arg[j];
                 const flag = getInjectFlag(meta);
-                if (typeof flag === "number") {
+                if (typeof flag === 'number') {
                     // Special case when we handle @Inject decorator.
-                    if (flag === -1 /* Inject */) {
+                    if (flag === -1 /* DecoratorFlags.Inject */) {
                         type = meta.token;
                     }
                     else {
@@ -510,35 +625,35 @@ function catchInjectorError(e, token, injectorErrorName, source) {
     if (token[SOURCE]) {
         tokenPath.unshift(token[SOURCE]);
     }
-    e.message = formatError("\n" + e.message, tokenPath, injectorErrorName, source);
+    e.message = formatError('\n' + e.message, tokenPath, injectorErrorName, source);
     e[NG_TOKEN_PATH] = tokenPath;
     e[NG_TEMP_TOKEN_PATH] = null;
     throw e;
 }
 function formatError(text, obj, injectorErrorName, source = null) {
     text =
-        text && text.charAt(0) === "\n" && text.charAt(1) == NO_NEW_LINE
-            ? text.substr(2)
+        text && text.charAt(0) === '\n' && text.charAt(1) == NO_NEW_LINE
+            ? text.slice(2)
             : text;
     let context = stringify(obj);
     if (Array.isArray(obj)) {
-        context = obj.map(stringify).join(" -> ");
+        context = obj.map(stringify).join(' -> ');
     }
-    else if (typeof obj === "object") {
+    else if (typeof obj === 'object') {
         let parts = [];
         for (let key in obj) {
             if (obj.hasOwnProperty(key)) {
                 let value = obj[key];
                 parts.push(key +
-                    ":" +
-                    (typeof value === "string"
+                    ':' +
+                    (typeof value === 'string'
                         ? JSON.stringify(value)
                         : stringify(value)));
             }
         }
-        context = `{${parts.join(", ")}}`;
+        context = `{${parts.join(', ')}}`;
     }
-    return `${injectorErrorName}${source ? "(" + source + ")" : ""}[${context}]: ${text.replace(NEW_LINE, "\n  ")}`;
+    return `${injectorErrorName}${source ? '(' + source + ')' : ''}[${context}]: ${text.replace(NEW_LINE, '\n  ')}`;
 }
 
 /**
@@ -557,7 +672,7 @@ function formatError(text, obj, injectorErrorName, source = null) {
 const Inject = attachInjectFlag(
 // Disable tslint because `DecoratorFlags` is a const enum which gets inlined.
 // tslint:disable-next-line: no-toplevel-property-access
-makeParamDecorator('Inject', (token) => ({ token })), -1 /* Inject */);
+makeParamDecorator('Inject', (token) => ({ token })), -1 /* DecoratorFlags.Inject */);
 /**
  * Optional decorator and metadata.
  *
@@ -567,7 +682,7 @@ makeParamDecorator('Inject', (token) => ({ token })), -1 /* Inject */);
 const Optional = 
 // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
 // tslint:disable-next-line: no-toplevel-property-access
-attachInjectFlag(makeParamDecorator('Optional'), 8 /* Optional */);
+attachInjectFlag(makeParamDecorator('Optional'), 8 /* InternalInjectFlags.Optional */);
 /**
  * Self decorator and metadata.
  *
@@ -577,7 +692,7 @@ attachInjectFlag(makeParamDecorator('Optional'), 8 /* Optional */);
 const Self = 
 // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
 // tslint:disable-next-line: no-toplevel-property-access
-attachInjectFlag(makeParamDecorator('Self'), 2 /* Self */);
+attachInjectFlag(makeParamDecorator('Self'), 2 /* InternalInjectFlags.Self */);
 /**
  * `SkipSelf` decorator and metadata.
  *
@@ -587,7 +702,7 @@ attachInjectFlag(makeParamDecorator('Self'), 2 /* Self */);
 const SkipSelf = 
 // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
 // tslint:disable-next-line: no-toplevel-property-access
-attachInjectFlag(makeParamDecorator('SkipSelf'), 4 /* SkipSelf */);
+attachInjectFlag(makeParamDecorator('SkipSelf'), 4 /* InternalInjectFlags.SkipSelf */);
 
 /**
  * @license
@@ -633,6 +748,21 @@ function newArray(size, value) {
     return list;
 }
 
+/**
+ * @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
+ */
+/**
+ * This file contains reuseable "empty" symbols that can be used as default return values
+ * in different parts of the rendering code. Because the same symbols are returned, this
+ * allows for identity checks against these values to be consistently used by the framework
+ * code.
+ */
+const EMPTY_ARRAY = [];
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -699,11 +829,32 @@ class InjectionToken {
             });
         }
     }
+    /**
+     * @internal
+     */
+    get multi() {
+        return this;
+    }
     toString() {
         return `InjectionToken ${this._desc}`;
     }
 }
 
+/**
+ * @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
+ */
+/**
+ * A multi-provider token for initialization functions that will run upon construction of an
+ * environment injector.
+ *
+ * @publicApi
+ */
+const ENVIRONMENT_INITIALIZER = new InjectionToken('ENVIRONMENT_INITIALIZER');
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -722,9 +873,18 @@ class InjectionToken {
 const INJECTOR = new InjectionToken("INJECTOR", 
 // Dissable tslint because this is const enum which gets inlined not top level prop access.
 // tslint:disable-next-line: no-toplevel-property-access
--1 /* Injector */ // Special value used by Ivy to identify `Injector`.
+-1 /* InjectorMarkers.Injector */ // Special value used by Ivy to identify `Injector`.
 );
 
+/**
+ * @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
+ */
+const INJECTOR_DEF_TYPES = new InjectionToken('INJECTOR_DEF_TYPES');
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -755,7 +915,7 @@ class NullInjector {
  * as a root scoped injector when processing requests for unknown tokens which may indicate
  * they are provided in the root scope.
  */
-const INJECTOR_SCOPE = new InjectionToken("Set Injector scope.");
+const INJECTOR_SCOPE = new InjectionToken('Set Injector scope.');
 
 /**
  * @license
@@ -787,54 +947,44 @@ function getNullInjector() {
     return NULL_INJECTOR;
 }
 /**
- * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
- *
- * @publicApi
- */
-function createInjector(defType, parent = null, additionalProviders = null, name) {
-    const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
-    injector._resolveInjectorDefTypes();
-    return injector;
-}
-/**
- * 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`.
+ * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
+ * component tree.
  */
-function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name) {
-    return new R3Injector(defType, additionalProviders, parent || getNullInjector(), name);
+class EnvironmentInjector {
 }
-class R3Injector {
-    constructor(def, additionalProviders, parent, source = null) {
+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, exports.InjectFlags.Self));
     }
     /**
      * Flag indicating that this injector was previously destroyed.
@@ -854,19 +1004,42 @@ 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 = exports.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 & exports.InjectFlags.SkipSelf)) {
@@ -924,16 +1097,31 @@ 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, exports.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() {
@@ -941,19 +1129,10 @@ 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);
@@ -961,16 +1140,13 @@ 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);
@@ -981,17 +1157,11 @@ 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();
@@ -999,7 +1169,7 @@ 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;
     }
@@ -1009,7 +1179,7 @@ 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);
@@ -1047,14 +1217,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);
     }
 }
@@ -1128,6 +1304,16 @@ 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);
+        }
+    }
+}
 
 /**
  * @license
@@ -1136,10 +1322,34 @@ function couldBeInjectableType(value) {
  * 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
  */
-function INJECTOR_IMPL__POST_R3__(providers, parent, name) {
-    return createInjector({ name: name }, parent, providers, name);
+/**
+ * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
+ *
+ * @publicApi
+ */
+function createInjector(defType, parent = null, additionalProviders = null, name) {
+    const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
+    injector.resolveInjectorInitializers();
+    return injector;
+}
+/**
+ * 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`.
+ */
+function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = new Set()) {
+    const providers = [additionalProviders || EMPTY_ARRAY];
+    name = name || (typeof defType === 'object' ? undefined : stringify(defType));
+    return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
 }
-const INJECTOR_IMPL = INJECTOR_IMPL__POST_R3__;
+
+/**
+ * @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
+ */
 /**
  * Concrete injectors implement this interface. Injectors are configured
  * with [providers](guide/glossary#provider) that associate
@@ -1166,11 +1376,13 @@ const INJECTOR_IMPL = INJECTOR_IMPL__POST_R3__;
  */
 class Injector {
     static create(options, parent) {
+        var _a;
         if (Array.isArray(options)) {
-            return INJECTOR_IMPL(options, parent, '');
+            return createInjector({ name: '' }, parent, options, '');
         }
         else {
-            return INJECTOR_IMPL(options.providers, options.parent, options.name || '');
+            const name = (_a = options.name) !== null && _a !== void 0 ? _a : '';
+            return createInjector({ name }, options.parent, options.providers, name);
         }
     }
 }
@@ -1186,7 +1398,7 @@ Injector.ɵprov = ɵɵdefineInjectable({
  * @internal
  * @nocollapse
  */
-Injector.__NG_ELEMENT_ID__ = -1 /* Injector */;
+Injector.__NG_ELEMENT_ID__ = -1 /* InjectorMarkers.Injector */;
 
 /**
  * @license
@@ -1258,13 +1470,13 @@ function getFactoryOf(type) {
     return getFactoryDef(type);
 }
 
-exports.INJECTOR_IMPL = INJECTOR_IMPL;
-exports.INJECTOR_IMPL__POST_R3__ = INJECTOR_IMPL__POST_R3__;
+exports.EnvironmentInjector = EnvironmentInjector;
 exports.INJECTOR_SCOPE = INJECTOR_SCOPE;
 exports.Inject = Inject;
 exports.Injectable = Injectable;
 exports.InjectionToken = InjectionToken;
 exports.Injector = Injector;
+exports.NG_INJECTABLE_DEF = NG_INJECTABLE_DEF;
 exports.NG_PROV_DEF = NG_PROV_DEF;
 exports.NG_TEMP_TOKEN_PATH = NG_TEMP_TOKEN_PATH;
 exports.NullInjector = NullInjector;
@@ -1277,19 +1489,20 @@ exports.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
 exports.USE_VALUE = USE_VALUE;
 exports.attachInjectFlag = attachInjectFlag;
 exports.catchInjectorError = catchInjectorError;
-exports.createInjector = createInjector;
-exports.createInjectorWithoutInjectorInstances = createInjectorWithoutInjectorInstances;
+exports.convertToBitFlags = convertToBitFlags;
 exports.formatError = formatError;
+exports.getInheritedInjectableDef = getInheritedInjectableDef;
 exports.getInjectFlag = getInjectFlag;
 exports.getInjectableDef = getInjectableDef;
+exports.getNullInjector = getNullInjector;
 exports.inject = inject;
 exports.injectArgs = injectArgs;
 exports.injectInjectorOnly = injectInjectorOnly;
 exports.isTypeProvider = isTypeProvider;
 exports.providerToFactory = providerToFactory;
 exports.setCurrentInjector = setCurrentInjector;
-exports.ɵɵdefineInjectable = ɵɵdefineInjectable;
-exports.ɵɵdefineInjector = ɵɵdefineInjector;
-exports.ɵɵgetInheritedFactory = ɵɵgetInheritedFactory;
-exports.ɵɵinject = ɵɵinject;
-exports.ɵɵinvalidFactory = ɵɵinvalidFactory;
+exports["ɵɵdefineInjectable"] = ɵɵdefineInjectable;
+exports["ɵɵdefineInjector"] = ɵɵdefineInjector;
+exports["ɵɵgetInheritedFactory"] = ɵɵgetInheritedFactory;
+exports["ɵɵinject"] = ɵɵinject;
+exports["ɵɵinvalidFactory"] = ɵɵinvalidFactory;