static-injector 1.0.10 → 2.1.0

package/transform/compiler/src/render3/r3_factory.js

@@ -1,14 +1,11 @@
 "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
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -27,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isExpressionFactoryMetadata = exports.isDelegatedFactoryMetadata = exports.createFactoryType = exports.compileFactoryFunction = exports.FactoryTarget = exports.R3FactoryDelegateType = void 0;
-const outputAst = __importStar(require("../output/output_ast"));
+const o = __importStar(require("../output/output_ast"));
 const r3_identifiers_1 = require("../render3/r3_identifiers");
 const util_1 = require("./util");
 var R3FactoryDelegateType;
@@ -47,7 +44,7 @@ var FactoryTarget;
  * Construct a factory function expression for the given `R3FactoryMetadata`.
  */
 function compileFactoryFunction(meta) {
-    const t = outputAst.variable('t');
+    const t = o.variable('t');
     let baseFactoryVar = null;
     // The type to instantiate via constructor invocation. If there is no delegated factory, meaning
     // this type is always created by constructor invocation, then this is the type-to-create
@@ -55,29 +52,29 @@ function compileFactoryFunction(meta) {
     // delegated factory (which is used to create the current type) then this is only the type-to-
     // create parameter (t).
     const typeForCtor = !isDelegatedFactoryMetadata(meta)
-        ? new outputAst.BinaryOperatorExpr(outputAst.BinaryOperator.Or, t, meta.internalType)
+        ? new o.BinaryOperatorExpr(o.BinaryOperator.Or, t, meta.internalType)
         : t;
     let ctorExpr = null;
     if (meta.deps !== null) {
         // There is a constructor (either explicitly or implicitly defined).
         if (meta.deps !== 'invalid') {
-            ctorExpr = new outputAst.InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.target));
+            ctorExpr = new o.InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.target));
         }
     }
     else {
         // There is no constructor, use the base class' factory to construct typeForCtor.
-        baseFactoryVar = outputAst.variable(`ɵ${meta.name}_BaseFactory`);
+        baseFactoryVar = o.variable(`ɵ${meta.name}_BaseFactory`);
         ctorExpr = baseFactoryVar.callFn([typeForCtor]);
     }
     const body = [];
     let retExpr = null;
     function makeConditionalFactory(nonCtorExpr) {
-        const r = outputAst.variable('r');
-        body.push(r.set(outputAst.NULL_EXPR).toDeclStmt());
+        const r = o.variable('r');
+        body.push(r.set(o.NULL_EXPR).toDeclStmt());
         const ctorStmt = ctorExpr !== null
             ? r.set(ctorExpr).toStmt()
-            : outputAst.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt();
-        body.push(outputAst.ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()]));
+            : o.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt();
+        body.push(o.ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()]));
         return r;
     }
     if (isDelegatedFactoryMetadata(meta)) {
@@ -86,8 +83,8 @@ function compileFactoryFunction(meta) {
         const delegateArgs = injectDependencies(meta.delegateDeps, meta.target);
         // Either call `new delegate(...)` or `delegate(...)` depending on meta.delegateType.
         const factoryExpr = new (meta.delegateType === R3FactoryDelegateType.Class
-            ? outputAst.InstantiateExpr
-            : outputAst.InvokeFunctionExpr)(meta.delegate, delegateArgs);
+            ? o.InstantiateExpr
+            : o.InvokeFunctionExpr)(meta.delegate, delegateArgs);
         retExpr = makeConditionalFactory(factoryExpr);
     }
     else if (isExpressionFactoryMetadata(meta)) {
@@ -99,29 +96,29 @@ function compileFactoryFunction(meta) {
     }
     if (retExpr === null) {
         // The expression cannot be formed so render an `ɵɵinvalidFactory()` call.
-        body.push(outputAst.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt());
+        body.push(o.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt());
     }
     else if (baseFactoryVar !== null) {
         // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.
-        const getInheritedFactoryCall = outputAst
+        const getInheritedFactoryCall = o
             .importExpr(r3_identifiers_1.Identifiers.getInheritedFactory)
             .callFn([meta.internalType]);
         // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
-        const baseFactory = new outputAst.BinaryOperatorExpr(outputAst.BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
-        body.push(new outputAst.ReturnStatement(baseFactory.callFn([typeForCtor])));
+        const baseFactory = new o.BinaryOperatorExpr(o.BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
+        body.push(new o.ReturnStatement(baseFactory.callFn([typeForCtor])));
     }
     else {
         // This is straightforward factory, just return it.
-        body.push(new outputAst.ReturnStatement(retExpr));
+        body.push(new o.ReturnStatement(retExpr));
     }
-    let factoryFn = outputAst.fn([new outputAst.FnParam('t', outputAst.DYNAMIC_TYPE)], body, outputAst.INFERRED_TYPE, undefined, `${meta.name}_Factory`);
+    let factoryFn = o.fn([new o.FnParam('t', o.DYNAMIC_TYPE)], body, o.INFERRED_TYPE, undefined, `${meta.name}_Factory`);
     if (baseFactoryVar !== null) {
         // There is a base factory variable so wrap its declaration along with the factory function into
         // an IIFE.
-        factoryFn = outputAst
+        factoryFn = o
             .fn([], [
-            new outputAst.DeclareVarStmt(baseFactoryVar.name),
-            new outputAst.ReturnStatement(factoryFn),
+            new o.DeclareVarStmt(baseFactoryVar.name),
+            new o.ReturnStatement(factoryFn),
         ])
             .callFn([], /* sourceSpan */ undefined, /* pure */ true);
     }
@@ -135,9 +132,9 @@ exports.compileFactoryFunction = compileFactoryFunction;
 function createFactoryType(meta) {
     const ctorDepsType = meta.deps !== null && meta.deps !== 'invalid'
         ? createCtorDepsType(meta.deps)
-        : outputAst.NONE_TYPE;
-    return outputAst.expressionType(outputAst.importExpr(r3_identifiers_1.Identifiers.FactoryDeclaration, [
-        util_1.typeWithParameters(meta.type.type, meta.typeArgumentCount),
+        : o.NONE_TYPE;
+    return o.expressionType(o.importExpr(r3_identifiers_1.Identifiers.FactoryDeclaration, [
+        (0, util_1.typeWithParameters)(meta.type.type, meta.typeArgumentCount),
         ctorDepsType,
     ]));
 }
@@ -148,29 +145,29 @@ function injectDependencies(deps, target) {
 function compileInjectDependency(dep, target, index) {
     // Interpret the dependency according to its resolved type.
     if (dep.token === null) {
-        return outputAst
-            .importExpr(r3_identifiers_1.Identifiers.invalidFactoryDep)
-            .callFn([outputAst.literal(index)]);
+        return o.importExpr(r3_identifiers_1.Identifiers.invalidFactoryDep).callFn([o.literal(index)]);
     }
     else if (dep.attributeNameType === null) {
         // Build up the injection flags according to the metadata.
-        const flags = 0 /* Default */ |
-            (dep.self ? 2 /* Self */ : 0) |
-            (dep.skipSelf ? 4 /* SkipSelf */ : 0) |
-            (dep.optional ? 8 /* Optional */ : 0);
+        const flags = 0 /* InjectFlags.Default */ |
+            (dep.self ? 2 /* InjectFlags.Self */ : 0) |
+            (dep.skipSelf ? 4 /* InjectFlags.SkipSelf */ : 0) |
+            0 |
+            (dep.optional ? 8 /* InjectFlags.Optional */ : 0) |
+            0;
         // If this dependency is optional or otherwise has non-default flags, then additional
         // parameters describing how to inject the dependency must be passed to the inject function
         // that's being used.
-        let flagsParam = flags !== 0 /* Default */ || dep.optional
-            ? outputAst.literal(flags)
-            : null;
+        let flagsParam = flags !== 0 /* InjectFlags.Default */ || dep.optional ? o.literal(flags) : null;
         // Build up the arguments to the injectFn call.
         const injectArgs = [dep.token];
         if (flagsParam) {
             injectArgs.push(flagsParam);
         }
         const injectFn = getInjectFn(target);
-        return outputAst.importExpr(injectFn).callFn(injectArgs);
+        return o.importExpr(injectFn).callFn(injectArgs);
+    }
+    else {
     }
 }
 function createCtorDepsType(deps) {
@@ -182,40 +179,28 @@ function createCtorDepsType(deps) {
             return type;
         }
         else {
-            return outputAst.literal(null);
+            return o.literal(null);
         }
     });
     if (hasTypes) {
-        return outputAst.expressionType(outputAst.literalArr(attributeTypes));
+        return o.expressionType(o.literalArr(attributeTypes));
     }
     else {
-        return outputAst.NONE_TYPE;
+        return o.NONE_TYPE;
     }
 }
 function createCtorDepType(dep) {
     const entries = [];
     if (dep.optional) {
-        entries.push({
-            key: 'optional',
-            value: outputAst.literal(true),
-            quoted: false,
-        });
+        entries.push({ key: 'optional', value: o.literal(true), quoted: false });
     }
     if (dep.self) {
-        entries.push({
-            key: 'self',
-            value: outputAst.literal(true),
-            quoted: false,
-        });
+        entries.push({ key: 'self', value: o.literal(true), quoted: false });
     }
     if (dep.skipSelf) {
-        entries.push({
-            key: 'skipSelf',
-            value: outputAst.literal(true),
-            quoted: false,
-        });
+        entries.push({ key: 'skipSelf', value: o.literal(true), quoted: false });
     }
-    return entries.length > 0 ? outputAst.literalMap(entries) : null;
+    return entries.length > 0 ? o.literalMap(entries) : null;
 }
 function isDelegatedFactoryMetadata(meta) {
     return meta.delegateType !== undefined;

package/transform/compiler/src/render3/util.d.ts

@@ -19,3 +19,67 @@ export interface R3CompiledExpression {
     type: o.Type;
     statements: o.Statement[];
 }
+/**
+ * Describes an expression that may have been wrapped in a `forwardRef()` guard.
+ *
+ * This is used when describing expressions that can refer to types that may eagerly reference types
+ * that have not yet been defined.
+ */
+export interface MaybeForwardRefExpression<T extends o.Expression = o.Expression> {
+    /**
+     * The unwrapped expression.
+     */
+    expression: T;
+    /**
+     * Specified whether the `expression` contains a reference to something that has not yet been
+     * defined, and whether the expression is still wrapped in a `forwardRef()` call.
+     *
+     * If this value is `ForwardRefHandling.None` then the `expression` is safe to use as-is.
+     *
+     * Otherwise the `expression` was wrapped in a call to `forwardRef()` and must not be eagerly
+     * evaluated. Instead it must be wrapped in a function closure that will be evaluated lazily to
+     * allow the definition of the expression to be evaluated first.
+     *
+     * In full AOT compilation it can be safe to unwrap the `forwardRef()` call up front if the
+     * expression will actually be evaluated lazily inside a function call after the value of
+     * `expression` has been defined.
+     *
+     * But in other cases, such as partial AOT compilation or JIT compilation the expression will be
+     * evaluated eagerly in top level code so will need to continue to be wrapped in a `forwardRef()`
+     * call.
+     *
+     */
+    forwardRef: ForwardRefHandling;
+}
+export declare function createMayBeForwardRefExpression<T extends o.Expression>(expression: T, forwardRef: ForwardRefHandling): MaybeForwardRefExpression<T>;
+/**
+ * Convert a `MaybeForwardRefExpression` to an `Expression`, possibly wrapping its expression in a
+ * `forwardRef()` call.
+ *
+ * If `MaybeForwardRefExpression.forwardRef` is `ForwardRefHandling.Unwrapped` then the expression
+ * was originally wrapped in a `forwardRef()` call to prevent the value from being eagerly evaluated
+ * in the code.
+ *
+ * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
+ * `packages/compiler/src/jit_compiler_facade.ts` for more information.
+ */
+export declare function convertFromMaybeForwardRefExpression({ expression, forwardRef, }: MaybeForwardRefExpression): o.Expression;
+/**
+ * Generate an expression that has the given `expr` wrapped in the following form:
+ *
+ * ```
+ * forwardRef(() => expr)
+ * ```
+ */
+export declare function generateForwardRef(expr: o.Expression): o.Expression;
+/**
+ * Specifies how a forward ref has been handled in a MaybeForwardRefExpression
+ */
+export declare const enum ForwardRefHandling {
+    /** The expression was not wrapped in a `forwardRef()` call in the first place. */
+    None = 0,
+    /** The expression is still wrapped in a `forwardRef()` call. */
+    Wrapped = 1,
+    /** The expression was wrapped in a `forwardRef()` call but has since been unwrapped. */
+    Unwrapped = 2
+}

package/transform/compiler/src/render3/util.js

@@ -1,7 +1,18 @@
 "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
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -19,15 +30,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeWithParameters = void 0;
-/**
- * @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
- */
+exports.generateForwardRef = exports.convertFromMaybeForwardRefExpression = exports.createMayBeForwardRefExpression = exports.typeWithParameters = void 0;
 const o = __importStar(require("../output/output_ast"));
+const r3_identifiers_1 = require("./r3_identifiers");
 function typeWithParameters(type, numParams) {
     if (numParams === 0) {
         return o.expressionType(type);
@@ -39,3 +44,41 @@ function typeWithParameters(type, numParams) {
     return o.expressionType(type, undefined, params);
 }
 exports.typeWithParameters = typeWithParameters;
+function createMayBeForwardRefExpression(expression, forwardRef) {
+    return { expression, forwardRef };
+}
+exports.createMayBeForwardRefExpression = createMayBeForwardRefExpression;
+/**
+ * Convert a `MaybeForwardRefExpression` to an `Expression`, possibly wrapping its expression in a
+ * `forwardRef()` call.
+ *
+ * If `MaybeForwardRefExpression.forwardRef` is `ForwardRefHandling.Unwrapped` then the expression
+ * was originally wrapped in a `forwardRef()` call to prevent the value from being eagerly evaluated
+ * in the code.
+ *
+ * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
+ * `packages/compiler/src/jit_compiler_facade.ts` for more information.
+ */
+function convertFromMaybeForwardRefExpression({ expression, forwardRef, }) {
+    switch (forwardRef) {
+        case 0 /* ForwardRefHandling.None */:
+        case 1 /* ForwardRefHandling.Wrapped */:
+            return expression;
+        case 2 /* ForwardRefHandling.Unwrapped */:
+            return generateForwardRef(expression);
+    }
+}
+exports.convertFromMaybeForwardRefExpression = convertFromMaybeForwardRefExpression;
+/**
+ * Generate an expression that has the given `expr` wrapped in the following form:
+ *
+ * ```
+ * forwardRef(() => expr)
+ * ```
+ */
+function generateForwardRef(expr) {
+    return o
+        .importExpr(r3_identifiers_1.Identifiers.forwardRef)
+        .callFn([o.fn([], [new o.ReturnStatement(expr)])]);
+}
+exports.generateForwardRef = generateForwardRef;

package/transform/compiler/src/render3/view/util.d.ts

@@ -6,14 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import * as o from '../../output/output_ast';
-/**
- * Checks whether an object key contains potentially unsafe chars, thus the key should be wrapped in
- * quotes. Note: we do not wrap all keys into quotes, as it may have impact on minification and may
- * bot work in some cases when object keys are mangled by minifier.
- *
- * TODO(FW-1136): this is a temporary solution, we need to come up with a better way of working with
- * inputs that contain potentially unsafe chars.
- */
 /**
  * A representation for an object literal used during codegen of definition objects. The generic
  * type `T` allows to reference a documented type of the generated structure, such that the

package/transform/compiler/src/render3/view/util.js

@@ -8,7 +8,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -28,14 +32,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefinitionMap = void 0;
 const o = __importStar(require("../../output/output_ast"));
-/**
- * Checks whether an object key contains potentially unsafe chars, thus the key should be wrapped in
- * quotes. Note: we do not wrap all keys into quotes, as it may have impact on minification and may
- * bot work in some cases when object keys are mangled by minifier.
- *
- * TODO(FW-1136): this is a temporary solution, we need to come up with a better way of working with
- * inputs that contain potentially unsafe chars.
- */
 /**
  * A representation for an object literal used during codegen of definition objects. The generic
  * type `T` allows to reference a documented type of the generated structure, such that the

package/transform/compiler-cli/src/ngtsc/annotations/common/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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
+ */
+export * from './src/di';
+export * from './src/factory';
+export * from './src/util';

package/transform/compiler-cli/src/ngtsc/annotations/common/index.js

@@ -0,0 +1,26 @@
+"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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/di"), exports);
+__exportStar(require("./src/factory"), exports);
+__exportStar(require("./src/util"), exports);

package/transform/compiler-cli/src/ngtsc/annotations/common/src/di.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @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 { R3DependencyMetadata } from 'static-injector/transform/compiler';
+import { ClassDeclaration, CtorParameter, ReflectionHost, UnavailableValue } from '../../../reflection';
+export type ConstructorDeps = {
+    deps: R3DependencyMetadata[];
+} | {
+    deps: null;
+    errors: ConstructorDepError[];
+};
+export interface ConstructorDepError {
+    index: number;
+    param: CtorParameter;
+    reason: UnavailableValue;
+}
+export declare function getConstructorDependencies(clazz: ClassDeclaration, reflector: ReflectionHost, isCore: boolean): ConstructorDeps | null;
+/**
+ * Convert `ConstructorDeps` into the `R3DependencyMetadata` array for those deps if they're valid,
+ * or into an `'invalid'` signal if they're not.
+ *
+ * This is a companion function to `validateConstructorDependencies` which accepts invalid deps.
+ */
+export declare function unwrapConstructorDependencies(deps: ConstructorDeps | null): R3DependencyMetadata[] | 'invalid' | null;
+export declare function getValidConstructorDependencies(clazz: ClassDeclaration, reflector: ReflectionHost, isCore: boolean): R3DependencyMetadata[] | null;
+/**
+ * Validate that `ConstructorDeps` does not have any invalid dependencies and convert them into the
+ * `R3DependencyMetadata` array if so, or raise a diagnostic if some deps are invalid.
+ *
+ * This is a companion function to `unwrapConstructorDependencies` which does not accept invalid
+ * deps.
+ */
+export declare function validateConstructorDependencies(clazz: ClassDeclaration, deps: ConstructorDeps | null): R3DependencyMetadata[] | null;