static-injector 1.0.10 → 2.1.0

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

@@ -0,0 +1,197 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConstructorDependencies = exports.getValidConstructorDependencies = exports.unwrapConstructorDependencies = exports.getConstructorDependencies = void 0;
+const compiler_1 = require("static-injector/transform/compiler");
+const typescript_1 = __importDefault(require("typescript"));
+const diagnostics_1 = require("../../../diagnostics");
+const reflection_1 = require("../../../reflection");
+const util_1 = require("./util");
+function getConstructorDependencies(clazz, reflector, isCore) {
+    const deps = [];
+    const errors = [];
+    let ctorParams = reflector.getConstructorParameters(clazz);
+    if (ctorParams === null) {
+        if (reflector.hasBaseClass(clazz)) {
+            return null;
+        }
+        else {
+            ctorParams = [];
+        }
+    }
+    ctorParams.forEach((param, idx) => {
+        let token = (0, util_1.valueReferenceToExpression)(param.typeValueReference);
+        let attributeNameType = null;
+        let optional = false, self = false, skipSelf = false, host = false;
+        (param.decorators || [])
+            .filter((dec) => isCore || (0, util_1.isAngularCore)(dec))
+            .forEach((dec) => {
+            const name = isCore || dec.import === null ? dec.name : dec.import.name;
+            if (name === 'Inject') {
+                if (dec.args === null || dec.args.length !== 1) {
+                    throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARITY_WRONG, reflection_1.Decorator.nodeForError(dec), `Unexpected number of arguments to @Inject().`);
+                }
+                token = new compiler_1.WrappedNodeExpr(dec.args[0]);
+            }
+            else if (name === 'Optional') {
+                optional = true;
+            }
+            else if (name === 'SkipSelf') {
+                skipSelf = true;
+            }
+            else if (name === 'Self') {
+                self = true;
+            }
+            else if (name === 'Host') {
+            }
+            else if (name === 'Attribute') {
+            }
+            else {
+                throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_UNEXPECTED, reflection_1.Decorator.nodeForError(dec), `Unexpected decorator ${name} on parameter.`);
+            }
+        });
+        if (token === null) {
+            if (param.typeValueReference.kind !== 2 /* TypeValueReferenceKind.UNAVAILABLE */) {
+                throw new Error('Illegal state: expected value reference to be unavailable if no token is present');
+            }
+            errors.push({
+                index: idx,
+                param,
+                reason: param.typeValueReference.reason,
+            });
+        }
+        else {
+            deps.push({ token, attributeNameType, optional, self, skipSelf });
+        }
+    });
+    if (errors.length === 0) {
+        return { deps };
+    }
+    else {
+        return { deps: null, errors };
+    }
+}
+exports.getConstructorDependencies = getConstructorDependencies;
+/**
+ * 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.
+ */
+function unwrapConstructorDependencies(deps) {
+    if (deps === null) {
+        return null;
+    }
+    else if (deps.deps !== null) {
+        // These constructor dependencies are valid.
+        return deps.deps;
+    }
+    else {
+        // These deps are invalid.
+        return 'invalid';
+    }
+}
+exports.unwrapConstructorDependencies = unwrapConstructorDependencies;
+function getValidConstructorDependencies(clazz, reflector, isCore) {
+    return validateConstructorDependencies(clazz, getConstructorDependencies(clazz, reflector, isCore));
+}
+exports.getValidConstructorDependencies = getValidConstructorDependencies;
+/**
+ * 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.
+ */
+function validateConstructorDependencies(clazz, deps) {
+    if (deps === null) {
+        return null;
+    }
+    else if (deps.deps !== null) {
+        return deps.deps;
+    }
+    else {
+        // TODO(alxhub): this cast is necessary because the g3 typescript version doesn't narrow here.
+        // There is at least one error.
+        const error = deps.errors[0];
+        throw createUnsuitableInjectionTokenError(clazz, error);
+    }
+}
+exports.validateConstructorDependencies = validateConstructorDependencies;
+/**
+ * Creates a fatal error with diagnostic for an invalid injection token.
+ * @param clazz The class for which the injection token was unavailable.
+ * @param error The reason why no valid injection token is available.
+ */
+function createUnsuitableInjectionTokenError(clazz, error) {
+    const { param, index, reason } = error;
+    let chainMessage = undefined;
+    let hints = undefined;
+    switch (reason.kind) {
+        case 5 /* ValueUnavailableKind.UNSUPPORTED */:
+            chainMessage =
+                'Consider using the @Inject decorator to specify an injection token.';
+            hints = [
+                (0, diagnostics_1.makeRelatedInformation)(reason.typeNode, 'This type is not supported as injection token.'),
+            ];
+            break;
+        case 1 /* ValueUnavailableKind.NO_VALUE_DECLARATION */:
+            chainMessage =
+                'Consider using the @Inject decorator to specify an injection token.';
+            hints = [
+                (0, diagnostics_1.makeRelatedInformation)(reason.typeNode, 'This type does not have a value, so it cannot be used as injection token.'),
+            ];
+            if (reason.decl !== null) {
+                hints.push((0, diagnostics_1.makeRelatedInformation)(reason.decl, 'The type is declared here.'));
+            }
+            break;
+        case 2 /* ValueUnavailableKind.TYPE_ONLY_IMPORT */:
+            chainMessage =
+                'Consider changing the type-only import to a regular import, or use the @Inject decorator to specify an injection token.';
+            hints = [
+                (0, diagnostics_1.makeRelatedInformation)(reason.typeNode, 'This type is imported using a type-only import, which prevents it from being usable as an injection token.'),
+                (0, diagnostics_1.makeRelatedInformation)(reason.node, 'The type-only import occurs here.'),
+            ];
+            break;
+        case 4 /* ValueUnavailableKind.NAMESPACE */:
+            chainMessage =
+                'Consider using the @Inject decorator to specify an injection token.';
+            hints = [
+                (0, diagnostics_1.makeRelatedInformation)(reason.typeNode, 'This type corresponds with a namespace, which cannot be used as injection token.'),
+                (0, diagnostics_1.makeRelatedInformation)(reason.importClause, 'The namespace import occurs here.'),
+            ];
+            break;
+        case 3 /* ValueUnavailableKind.UNKNOWN_REFERENCE */:
+            chainMessage = 'The type should reference a known declaration.';
+            hints = [
+                (0, diagnostics_1.makeRelatedInformation)(reason.typeNode, 'This type could not be resolved.'),
+            ];
+            break;
+        case 0 /* ValueUnavailableKind.MISSING_TYPE */:
+            chainMessage =
+                'Consider adding a type to the parameter or use the @Inject decorator to specify an injection token.';
+            break;
+    }
+    const chain = {
+        messageText: `No suitable injection token for parameter '${param.name || index}' of class '${clazz.name.text}'.`,
+        category: typescript_1.default.DiagnosticCategory.Error,
+        code: 0,
+        next: [
+            {
+                messageText: chainMessage,
+                category: typescript_1.default.DiagnosticCategory.Message,
+                code: 0,
+            },
+        ],
+    };
+    return new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.PARAM_MISSING_TOKEN, param.nameNode, chain, hints);
+}

package/transform/compiler-cli/src/ngtsc/annotations/{src → common/src}/factory.d.ts

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { R3FactoryMetadata } from "../../../../../compiler";
-import { CompileResult } from "../../transform";
-export declare type CompileFactoryFn = (metadata: R3FactoryMetadata) => CompileResult;
+import { R3FactoryMetadata } from 'static-injector/transform/compiler';
+import { CompileResult } from '../../../transform';
+export type CompileFactoryFn = (metadata: R3FactoryMetadata) => CompileResult;
 export declare function compileNgFactoryDefField(metadata: R3FactoryMetadata): CompileResult;

package/transform/compiler-cli/src/ngtsc/annotations/{src → common/src}/factory.js

@@ -8,11 +8,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileNgFactoryDefField = void 0;
-const compiler_1 = require("../../../../../compiler");
+const compiler_1 = require("static-injector/transform/compiler");
 function compileNgFactoryDefField(metadata) {
-    const res = compiler_1.compileFactoryFunction(metadata);
+    const res = (0, compiler_1.compileFactoryFunction)(metadata);
     return {
-        name: "ɵfac",
+        name: 'ɵfac',
         initializer: res.expression,
         statements: res.statements,
         type: res.type,

package/transform/compiler-cli/src/ngtsc/annotations/{src → common/src}/util.d.ts

@@ -5,23 +5,9 @@
  * 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 { Expression, R3DependencyMetadata, R3Reference } from '../../../../../compiler';
-import { R3FactoryMetadata } from '../../../../../compiler';
-import { FactoryTarget } from '../../../../../compiler/src/render3/partial/api';
-import * as ts from 'typescript';
-import { ClassDeclaration, CtorParameter, Decorator, Import, ImportedTypeValueReference, LocalTypeValueReference, ReflectionHost, TypeValueReference, UnavailableValue } from '../../reflection';
-export declare 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;
+import { Expression, FactoryTarget, R3FactoryMetadata, R3Reference } from 'static-injector/transform/compiler';
+import ts from 'typescript';
+import { ClassDeclaration, Decorator, Import, ImportedTypeValueReference, LocalTypeValueReference, ReflectionHost, TypeValueReference } from '../../../reflection';
 /**
  * Convert a `TypeValueReference` to an `Expression` which refers to the type as a value.
  *
@@ -31,23 +17,6 @@ export declare function getConstructorDependencies(clazz: ClassDeclaration, refl
  */
 export declare function valueReferenceToExpression(valueRef: LocalTypeValueReference | ImportedTypeValueReference): Expression;
 export declare function valueReferenceToExpression(valueRef: TypeValueReference): Expression | 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;
-/** todo 需要改成自己的依赖包 */
 export declare function isAngularCore(decorator: Decorator): decorator is Decorator & {
     import: Import;
 };
@@ -89,3 +58,4 @@ export declare function wrapFunctionExpressionsInParens(expression: ts.Expressio
  */
 export declare function wrapTypeReference(reflector: ReflectionHost, clazz: ClassDeclaration): R3Reference;
 export declare function toFactoryMetadata(meta: Omit<R3FactoryMetadata, 'target'>, target: FactoryTarget): R3FactoryMetadata;
+export declare function isAbstractClassDeclaration(clazz: ClassDeclaration): boolean;

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

@@ -0,0 +1,181 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbstractClassDeclaration = exports.toFactoryMetadata = exports.wrapTypeReference = exports.wrapFunctionExpressionsInParens = exports.tryUnwrapForwardRef = exports.unwrapExpression = exports.isAngularDecorator = exports.findAngularDecorator = exports.isAngularCore = exports.valueReferenceToExpression = void 0;
+const compiler_1 = require("static-injector/transform/compiler");
+const typescript_1 = __importDefault(require("typescript"));
+const reflection_1 = require("../../../reflection");
+function valueReferenceToExpression(valueRef) {
+    if (valueRef.kind === 2 /* TypeValueReferenceKind.UNAVAILABLE */) {
+        return null;
+    }
+    else if (valueRef.kind === 0 /* TypeValueReferenceKind.LOCAL */) {
+        const expr = new compiler_1.WrappedNodeExpr(valueRef.expression);
+        return expr;
+    }
+    else {
+        let importExpr = new compiler_1.ExternalExpr({
+            moduleName: valueRef.moduleName,
+            name: valueRef.importedName,
+        });
+        if (valueRef.nestedPath !== null) {
+            for (const property of valueRef.nestedPath) {
+                importExpr = new compiler_1.ReadPropExpr(importExpr, property);
+            }
+        }
+        return importExpr;
+    }
+}
+exports.valueReferenceToExpression = valueReferenceToExpression;
+function isAngularCore(decorator) {
+    return (decorator.import !== null && decorator.import.from === 'static-injector');
+}
+exports.isAngularCore = isAngularCore;
+function findAngularDecorator(decorators, name, isCore) {
+    return decorators.find((decorator) => isAngularDecorator(decorator, name, isCore));
+}
+exports.findAngularDecorator = findAngularDecorator;
+function isAngularDecorator(decorator, name, isCore) {
+    if (isCore) {
+        return decorator.name === name;
+    }
+    else if (isAngularCore(decorator)) {
+        return decorator.import.name === name;
+    }
+    return false;
+}
+exports.isAngularDecorator = isAngularDecorator;
+/**
+ * Unwrap a `ts.Expression`, removing outer type-casts or parentheses until the expression is in its
+ * lowest level form.
+ *
+ * For example, the expression "(foo as Type)" unwraps to "foo".
+ */
+function unwrapExpression(node) {
+    while (typescript_1.default.isAsExpression(node) || typescript_1.default.isParenthesizedExpression(node)) {
+        node = node.expression;
+    }
+    return node;
+}
+exports.unwrapExpression = unwrapExpression;
+function expandForwardRef(arg) {
+    arg = unwrapExpression(arg);
+    if (!typescript_1.default.isArrowFunction(arg) && !typescript_1.default.isFunctionExpression(arg)) {
+        return null;
+    }
+    const body = arg.body;
+    // Either the body is a ts.Expression directly, or a block with a single return statement.
+    if (typescript_1.default.isBlock(body)) {
+        // Block body - look for a single return statement.
+        if (body.statements.length !== 1) {
+            return null;
+        }
+        const stmt = body.statements[0];
+        if (!typescript_1.default.isReturnStatement(stmt) || stmt.expression === undefined) {
+            return null;
+        }
+        return stmt.expression;
+    }
+    else {
+        // Shorthand body - return as an expression.
+        return body;
+    }
+}
+/**
+ * If the given `node` is a forwardRef() expression then resolve its inner value, otherwise return
+ * `null`.
+ *
+ * @param node the forwardRef() expression to resolve
+ * @param reflector a ReflectionHost
+ * @returns the resolved expression, if the original expression was a forwardRef(), or `null`
+ *     otherwise.
+ */
+function tryUnwrapForwardRef(node, reflector) {
+    node = unwrapExpression(node);
+    if (!typescript_1.default.isCallExpression(node) || node.arguments.length !== 1) {
+        return null;
+    }
+    const fn = typescript_1.default.isPropertyAccessExpression(node.expression)
+        ? node.expression.name
+        : node.expression;
+    if (!typescript_1.default.isIdentifier(fn)) {
+        return null;
+    }
+    const expr = expandForwardRef(node.arguments[0]);
+    if (expr === null) {
+        return null;
+    }
+    const imp = reflector.getImportOfIdentifier(fn);
+    if (imp === null ||
+        imp.from !== 'static-injector' ||
+        imp.name !== 'forwardRef') {
+        return null;
+    }
+    return expr;
+}
+exports.tryUnwrapForwardRef = tryUnwrapForwardRef;
+const parensWrapperTransformerFactory = (context) => {
+    const visitor = (node) => {
+        const visited = typescript_1.default.visitEachChild(node, visitor, context);
+        if (typescript_1.default.isArrowFunction(visited) || typescript_1.default.isFunctionExpression(visited)) {
+            return typescript_1.default.factory.createParenthesizedExpression(visited);
+        }
+        return visited;
+    };
+    return (node) => typescript_1.default.visitEachChild(node, visitor, context);
+};
+/**
+ * Wraps all functions in a given expression in parentheses. This is needed to avoid problems
+ * where Tsickle annotations added between analyse and transform phases in Angular may trigger
+ * automatic semicolon insertion, e.g. if a function is the expression in a `return` statement.
+ * More
+ * info can be found in Tsickle source code here:
+ * https://github.com/angular/tsickle/blob/d7974262571c8a17d684e5ba07680e1b1993afdd/src/jsdoc_transformer.ts#L1021
+ *
+ * @param expression Expression where functions should be wrapped in parentheses
+ */
+function wrapFunctionExpressionsInParens(expression) {
+    return typescript_1.default.transform(expression, [parensWrapperTransformerFactory])
+        .transformed[0];
+}
+exports.wrapFunctionExpressionsInParens = wrapFunctionExpressionsInParens;
+/**
+ * Create an R3Reference for a class.
+ *
+ * The `value` is the exported declaration of the class from its source file.
+ * The `type` is an expression that would be used by ngcc in the typings (.d.ts) files.
+ */
+function wrapTypeReference(reflector, clazz) {
+    const dtsClass = reflector.getDtsDeclaration(clazz);
+    const value = new compiler_1.WrappedNodeExpr(clazz.name);
+    const type = dtsClass !== null && (0, reflection_1.isNamedClassDeclaration)(dtsClass)
+        ? new compiler_1.WrappedNodeExpr(dtsClass.name)
+        : value;
+    return { value, type };
+}
+exports.wrapTypeReference = wrapTypeReference;
+function toFactoryMetadata(meta, target) {
+    return {
+        name: meta.name,
+        type: meta.type,
+        internalType: meta.internalType,
+        typeArgumentCount: meta.typeArgumentCount,
+        deps: meta.deps,
+        target,
+    };
+}
+exports.toFactoryMetadata = toFactoryMetadata;
+function isAbstractClassDeclaration(clazz) {
+    return (clazz.modifiers !== undefined &&
+        clazz.modifiers.some((mod) => mod.kind === typescript_1.default.SyntaxKind.AbstractKeyword));
+}
+exports.isAbstractClassDeclaration = isAbstractClassDeclaration;

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

@@ -5,17 +5,17 @@
  * 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, R3InjectableMetadata } from '../../../../../compiler';
+import { R3DependencyMetadata, R3InjectableMetadata } from 'static-injector/transform/compiler';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../reflection';
 import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult } from '../../transform';
-interface InjectableHandlerData {
+export interface InjectableHandlerData {
     meta: R3InjectableMetadata;
     ctorDeps: R3DependencyMetadata[] | 'invalid' | null;
 }
 /**
  * Adapts the `compileInjectable` compiler for `@Injectable` decorators to the Ivy compiler.
  */
-export declare class InjectableDecoratorHandler implements DecoratorHandler<Decorator, InjectableHandlerData, null, unknown> {
+export declare class InjectableDecoratorHandler implements DecoratorHandler<Decorator, InjectableHandlerData, unknown> {
     private reflector;
     private isCore;
     private strictCtorDeps;
@@ -39,4 +39,3 @@ export declare class InjectableDecoratorHandler implements DecoratorHandler<Deco
     compileFull(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>): CompileResult[];
     private compile;
 }
-export {};