static-injector 1.0.10 → 2.1.0

package/import/es2015/di/create_injector.js

@@ -0,0 +1,30 @@
+/**
+ * @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 { EMPTY_ARRAY } from '../util/empty';
+import { stringify } from '../util/stringify';
+import { getNullInjector, R3Injector } from './r3_injector';
+/**
+ * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
+ *
+ * @publicApi
+ */
+export 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`.
+ */
+export 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);
+}

package/import/es2015/di/initializer_token.js

@@ -0,0 +1,15 @@
+/**
+ * @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 { InjectionToken } from './injection_token';
+/**
+ * A multi-provider token for initialization functions that will run upon construction of an
+ * environment injector.
+ *
+ * @publicApi
+ */
+export const ENVIRONMENT_INITIALIZER = new InjectionToken('ENVIRONMENT_INITIALIZER');

package/import/es2015/di/inject_switch.js

@@ -5,10 +5,31 @@
  * 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 { throwProviderNotFoundError } from "../render3/errors_di";
-import { stringify } from "../util/stringify";
-import { getInjectableDef } from "./interface/defs";
-import { InjectFlags } from "./interface/injector";
+import { throwProviderNotFoundError } from '../render3/errors_di';
+import { stringify } from '../util/stringify';
+import { getInjectableDef } from './interface/defs';
+import { InjectFlags } from './interface/injector';
+/**
+ * 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;
+export function getInjectImplementation() {
+    return _injectImplementation;
+}
+/**
+ * Sets the current inject implementation.
+ */
+export function setInjectImplementation(impl) {
+    const previous = _injectImplementation;
+    _injectImplementation = impl;
+    return previous;
+}
 /**
  * Injects `root` tokens in limp mode.
  *
@@ -18,7 +39,7 @@ import { InjectFlags } from "./interface/injector";
  */
 export 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;
@@ -27,5 +48,5 @@ export function injectRootLimpMode(token, notFoundValue, flags) {
         return null;
     if (notFoundValue !== undefined)
         return notFoundValue;
-    throwProviderNotFoundError(stringify(token), "Injector");
+    throwProviderNotFoundError(stringify(token), 'Injector');
 }

package/import/es2015/di/injection_token.js

@@ -65,6 +65,12 @@ export class InjectionToken {
             });
         }
     }
+    /**
+     * @internal
+     */
+    get multi() {
+        return this;
+    }
     toString() {
         return `InjectionToken ${this._desc}`;
     }

package/import/es2015/di/injector.js

@@ -5,15 +5,11 @@
  * 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 { createInjector } from './create_injector';
 import { THROW_IF_NOT_FOUND, ɵɵinject } from './injector_compatibility';
 import { INJECTOR } from './injector_token';
 import { ɵɵdefineInjectable } from './interface/defs';
 import { NullInjector } from './null_injector';
-import { createInjector } from './r3_injector';
-export function INJECTOR_IMPL__POST_R3__(providers, parent, name) {
-    return createInjector({ name: name }, parent, providers, name);
-}
-export const INJECTOR_IMPL = INJECTOR_IMPL__POST_R3__;
 /**
  * Concrete injectors implement this interface. Injectors are configured
  * with [providers](guide/glossary#provider) that associate
@@ -40,11 +36,13 @@ export const INJECTOR_IMPL = INJECTOR_IMPL__POST_R3__;
  */
 export 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);
         }
     }
 }
@@ -60,4 +58,4 @@ Injector.ɵprov = ɵɵdefineInjectable({
  * @internal
  * @nocollapse
  */
-Injector.__NG_ELEMENT_ID__ = -1 /* Injector */;
+Injector.__NG_ELEMENT_ID__ = -1 /* InjectorMarkers.Injector */;

package/import/es2015/di/injector_compatibility.js

@@ -5,11 +5,11 @@
  * 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 { resolveForwardRef } from "./forward_ref";
-import { injectRootLimpMode } from "./inject_switch";
-import { InjectFlags, } from "./interface/injector";
+import { getClosureSafeProperty } from '../util/property';
+import { stringify } from '../util/stringify';
+import { resolveForwardRef } from './forward_ref';
+import { injectRootLimpMode } from './inject_switch';
+import { InjectFlags, } from './interface/injector';
 const _THROW_IF_NOT_FOUND = {};
 export const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
 /*
@@ -17,12 +17,12 @@ export 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__";
-export const NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
-const NG_TOKEN_PATH = "ngTokenPath";
+const DI_DECORATOR_FLAG = '__NG_DI_FLAG__';
+export const NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';
+const NG_TOKEN_PATH = 'ngTokenPath';
 const NEW_LINE = /\n/gm;
-const NO_NEW_LINE = "ɵ";
-export const SOURCE = "__source";
+const NO_NEW_LINE = 'ɵ';
+export const SOURCE = '__source';
 export const USE_VALUE = getClosureSafeProperty({
     provide: String,
     useValue: getClosureSafeProperty,
@@ -55,45 +55,101 @@ export function ɵɵinject(token, flags = InjectFlags.Default) {
 }
 /**
  * Injects a token from the currently active injector.
+ * `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`.
  *
- * 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.
+ * @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);
+ *   }
+ * }
+ * ```
+ *
+ * It is also legal to call `inject` from a provider's factory:
  *
- * ### Example
+ * ```typescript
+ * providers: [
+ *   {provide: Car, useFactory: () => {
+ *     // OK: a class factory
+ *     const engine = inject(Engine);
+ *     return new Car(engine);
+ *   }}
+ * ]
+ * ```
  *
- * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
+ * 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
  */
-export const inject = ɵɵinject;
+export function inject(token, flags = InjectFlags.Default) {
+    return ɵɵinject(token, convertToBitFlags(flags));
+}
+// Converts object-based DI flags (`InjectOptions`) to bit flags (`InjectFlags`).
+export 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 */));
+}
 export 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 = 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 {
@@ -140,33 +196,33 @@ export 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;
 }
 export 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  ')}`;
 }

package/import/es2015/di/injector_token.js

@@ -17,5 +17,5 @@ import { InjectionToken } from "./injection_token";
 export 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`.
 );

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

@@ -70,3 +70,42 @@ function getOwnDefinition(type, field) {
 export 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.
+ */
+export 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;
+    }
+}
+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
+    // 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];
+}

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

@@ -9,6 +9,7 @@
  * Injection flags for DI.
  *
  * @publicApi
+ * @deprecated use an options object for `inject` instead.
  */
 export var InjectFlags;
 (function (InjectFlags) {

package/import/es2015/di/internal_tokens.js

@@ -0,0 +1,9 @@
+/**
+ * @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 { InjectionToken } from './injection_token';
+export const INJECTOR_DEF_TYPES = new InjectionToken('INJECTOR_DEF_TYPES');

package/import/es2015/di/metadata.js

@@ -16,7 +16,7 @@ import { attachInjectFlag } from './injector_compatibility';
 export 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.
  *
@@ -26,7 +26,7 @@ makeParamDecorator('Inject', (token) => ({ token })), -1 /* Inject */);
 export 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.
  *
@@ -36,7 +36,7 @@ attachInjectFlag(makeParamDecorator('Optional'), 8 /* Optional */);
 export 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.
  *
@@ -46,4 +46,4 @@ attachInjectFlag(makeParamDecorator('Self'), 2 /* Self */);
 export 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 */);

package/import/es2015/di/provider_collection.js

@@ -0,0 +1,49 @@
+/**
+ * @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 { getClosureSafeProperty } from '../util/property';
+import { resolveForwardRef } from './forward_ref';
+/**
+ * The logic visits an `InjectorType`, an `InjectorTypeWithProviders`, or a standalone
+ * `ComponentType`, and all of its transitive providers and collects providers.
+ *
+ * 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)
+ */
+export function walkProviderTree(container, providersOut, parents, dedup) {
+    container = resolveForwardRef(container);
+    if (!container)
+        return false;
+    // The actual type which had the definition. Usually `container`, but may be an unwrapped type
+    // from `InjectorTypeWithProviders`.
+    let defType = null;
+    defType = container;
+    // Check for multiple imports of the same module
+    return (defType !== container &&
+        container.providers !== undefined);
+}
+export const USE_VALUE = getClosureSafeProperty({
+    provide: String,
+    useValue: getClosureSafeProperty,
+});
+export function isValueProvider(value) {
+    return value !== null && typeof value == 'object' && USE_VALUE in value;
+}
+export function isExistingProvider(value) {
+    return !!(value && value.useExisting);
+}
+export function isFactoryProvider(value) {
+    return !!(value && value.useFactory);
+}
+export function isTypeProvider(value) {
+    return typeof value === 'function';
+}
+export function isClassProvider(value) {
+    return !!value.useClass;
+}