static-injector 2.0.0 → 2.1.1

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;

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 = (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/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;
 };

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

@@ -6,96 +6,14 @@
  * 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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+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.validateConstructorDependencies = exports.getValidConstructorDependencies = exports.unwrapConstructorDependencies = exports.valueReferenceToExpression = exports.getConstructorDependencies = void 0;
-const compiler_1 = require("../../../../../../compiler");
-const ts = __importStar(require("typescript"));
-const diagnostics_1 = require("../../../diagnostics");
+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 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 = valueReferenceToExpression(param.typeValueReference);
-        let attributeNameType = null;
-        let optional = false, self = false, skipSelf = false;
-        (param.decorators || [])
-            .filter((dec) => isCore || 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 {
-                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;
 function valueReferenceToExpression(valueRef) {
     if (valueRef.kind === 2 /* TypeValueReferenceKind.UNAVAILABLE */) {
         return null;
@@ -118,121 +36,6 @@ function valueReferenceToExpression(valueRef) {
     }
 }
 exports.valueReferenceToExpression = valueReferenceToExpression;
-/**
- * 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: ts.DiagnosticCategory.Error,
-        code: 0,
-        next: [
-            {
-                messageText: chainMessage,
-                category: ts.DiagnosticCategory.Message,
-                code: 0,
-            },
-        ],
-    };
-    return new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.PARAM_MISSING_TOKEN, param.nameNode, chain, hints);
-}
-/** todo 需要改成自己的依赖包 */
 function isAngularCore(decorator) {
     return (decorator.import !== null && decorator.import.from === 'static-injector');
 }
@@ -258,7 +61,7 @@ exports.isAngularDecorator = isAngularDecorator;
  * For example, the expression "(foo as Type)" unwraps to "foo".
  */
 function unwrapExpression(node) {
-    while (ts.isAsExpression(node) || ts.isParenthesizedExpression(node)) {
+    while (typescript_1.default.isAsExpression(node) || typescript_1.default.isParenthesizedExpression(node)) {
         node = node.expression;
     }
     return node;
@@ -266,18 +69,18 @@ function unwrapExpression(node) {
 exports.unwrapExpression = unwrapExpression;
 function expandForwardRef(arg) {
     arg = unwrapExpression(arg);
-    if (!ts.isArrowFunction(arg) && !ts.isFunctionExpression(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 (ts.isBlock(body)) {
+    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 (!ts.isReturnStatement(stmt) || stmt.expression === undefined) {
+        if (!typescript_1.default.isReturnStatement(stmt) || stmt.expression === undefined) {
             return null;
         }
         return stmt.expression;
@@ -298,13 +101,13 @@ function expandForwardRef(arg) {
  */
 function tryUnwrapForwardRef(node, reflector) {
     node = unwrapExpression(node);
-    if (!ts.isCallExpression(node) || node.arguments.length !== 1) {
+    if (!typescript_1.default.isCallExpression(node) || node.arguments.length !== 1) {
         return null;
     }
-    const fn = ts.isPropertyAccessExpression(node.expression)
+    const fn = typescript_1.default.isPropertyAccessExpression(node.expression)
         ? node.expression.name
         : node.expression;
-    if (!ts.isIdentifier(fn)) {
+    if (!typescript_1.default.isIdentifier(fn)) {
         return null;
     }
     const expr = expandForwardRef(node.arguments[0]);
@@ -312,7 +115,6 @@ function tryUnwrapForwardRef(node, reflector) {
         return null;
     }
     const imp = reflector.getImportOfIdentifier(fn);
-    //todo 更换包名
     if (imp === null ||
         imp.from !== 'static-injector' ||
         imp.name !== 'forwardRef') {
@@ -323,13 +125,13 @@ function tryUnwrapForwardRef(node, reflector) {
 exports.tryUnwrapForwardRef = tryUnwrapForwardRef;
 const parensWrapperTransformerFactory = (context) => {
     const visitor = (node) => {
-        const visited = ts.visitEachChild(node, visitor, context);
-        if (ts.isArrowFunction(visited) || ts.isFunctionExpression(visited)) {
-            return ts.createParen(visited);
+        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) => ts.visitEachChild(node, visitor, context);
+    return (node) => typescript_1.default.visitEachChild(node, visitor, context);
 };
 /**
  * Wraps all functions in a given expression in parentheses. This is needed to avoid problems
@@ -342,7 +144,7 @@ const parensWrapperTransformerFactory = (context) => {
  * @param expression Expression where functions should be wrapped in parentheses
  */
 function wrapFunctionExpressionsInParens(expression) {
-    return ts.transform(expression, [parensWrapperTransformerFactory])
+    return typescript_1.default.transform(expression, [parensWrapperTransformerFactory])
         .transformed[0];
 }
 exports.wrapFunctionExpressionsInParens = wrapFunctionExpressionsInParens;
@@ -374,6 +176,6 @@ function toFactoryMetadata(meta, target) {
 exports.toFactoryMetadata = toFactoryMetadata;
 function isAbstractClassDeclaration(clazz) {
     return (clazz.modifiers !== undefined &&
-        clazz.modifiers.some((mod) => mod.kind === ts.SyntaxKind.AbstractKeyword));
+        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 {};