static-injector 2.1.1 → 2.2.0

package/transform/compiler-cli/src/ngtsc/reflection/src/host.js

@@ -10,19 +10,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConcreteDeclaration = exports.KnownDeclaration = exports.ClassMemberKind = exports.isDecoratorIdentifier = exports.Decorator = void 0;
+exports.ClassMemberKind = exports.isDecoratorIdentifier = void 0;
 const typescript_1 = __importDefault(require("typescript"));
-exports.Decorator = {
-    nodeForError: (decorator) => {
-        if (decorator.node !== null) {
-            return decorator.node;
-        }
-        else {
-            // TODO(alxhub): we can't rely on narrowing until TS 3.6 is in g3.
-            return decorator.synthesizedFor;
-        }
-    },
-};
 function isDecoratorIdentifier(exp) {
     return (typescript_1.default.isIdentifier(exp) ||
         (typescript_1.default.isPropertyAccessExpression(exp) &&
@@ -40,42 +29,4 @@ var ClassMemberKind;
     ClassMemberKind[ClassMemberKind["Setter"] = 2] = "Setter";
     ClassMemberKind[ClassMemberKind["Property"] = 3] = "Property";
     ClassMemberKind[ClassMemberKind["Method"] = 4] = "Method";
-})(ClassMemberKind = exports.ClassMemberKind || (exports.ClassMemberKind = {}));
-/**
- * Possible declarations of known values, such as built-in objects/functions or TypeScript helpers.
- */
-var KnownDeclaration;
-(function (KnownDeclaration) {
-    /**
-     * Indicates the JavaScript global `Object` class.
-     */
-    KnownDeclaration[KnownDeclaration["JsGlobalObject"] = 0] = "JsGlobalObject";
-    /**
-     * Indicates the `__assign` TypeScript helper function.
-     */
-    KnownDeclaration[KnownDeclaration["TsHelperAssign"] = 1] = "TsHelperAssign";
-    /**
-     * Indicates the `__spread` TypeScript helper function.
-     */
-    KnownDeclaration[KnownDeclaration["TsHelperSpread"] = 2] = "TsHelperSpread";
-    /**
-     * Indicates the `__spreadArrays` TypeScript helper function.
-     */
-    KnownDeclaration[KnownDeclaration["TsHelperSpreadArrays"] = 3] = "TsHelperSpreadArrays";
-    /**
-     * Indicates the `__spreadArray` TypeScript helper function.
-     */
-    KnownDeclaration[KnownDeclaration["TsHelperSpreadArray"] = 4] = "TsHelperSpreadArray";
-    /**
-     * Indicates the `__read` TypeScript helper function.
-     */
-    KnownDeclaration[KnownDeclaration["TsHelperRead"] = 5] = "TsHelperRead";
-})(KnownDeclaration = exports.KnownDeclaration || (exports.KnownDeclaration = {}));
-/**
- * Returns true if the `decl` is a `ConcreteDeclaration` (ie. that its `node` property is a
- * `ts.Declaration`).
- */
-function isConcreteDeclaration(decl) {
-    return decl.kind === 0 /* DeclarationKind.Concrete */;
-}
-exports.isConcreteDeclaration = isConcreteDeclaration;
+})(ClassMemberKind || (exports.ClassMemberKind = ClassMemberKind = {}));

package/transform/compiler-cli/src/ngtsc/reflection/src/typescript.d.ts

@@ -21,9 +21,6 @@ export declare class TypeScriptReflectionHost implements ReflectionHost {
     hasBaseClass(clazz: ClassDeclaration): boolean;
     getBaseClassExpression(clazz: ClassDeclaration): ts.Expression | null;
     getGenericArityOfClass(clazz: ClassDeclaration): number | null;
-    getDtsDeclaration(_: ClassDeclaration): ts.Declaration | null;
-    getInternalNameOfClass(clazz: ClassDeclaration): ts.Identifier;
-    getAdjacentNameOfClass(clazz: ClassDeclaration): ts.Identifier;
     protected getDirectImportOfIdentifier(id: ts.Identifier): Import | null;
     /**
      * Try to get the import info for this identifier as though it is a namespaced import.
@@ -48,3 +45,8 @@ export declare class TypeScriptReflectionHost implements ReflectionHost {
     private _reflectMember;
 }
 export declare function reflectObjectLiteral(node: ts.ObjectLiteralExpression): Map<string, ts.Expression>;
+/**
+ * Return the ImportDeclaration for the given `node` if it is either an `ImportSpecifier` or a
+ * `NamespaceImport`. If not return `null`.
+ */
+export declare function getContainingImportDeclaration(node: ts.Node): ts.ImportDeclaration | null;

package/transform/compiler-cli/src/ngtsc/reflection/src/typescript.js

@@ -10,7 +10,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reflectObjectLiteral = exports.TypeScriptReflectionHost = void 0;
+exports.getContainingImportDeclaration = exports.reflectObjectLiteral = exports.TypeScriptReflectionHost = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const host_1 = require("./host");
 const type_to_value_1 = require("./type_to_value");
@@ -19,6 +19,7 @@ const util_1 = require("./util");
  * reflector.ts implements static reflection of declarations using the TypeScript `ts.TypeChecker`.
  */
 class TypeScriptReflectionHost {
+    checker;
     constructor(checker) {
         this.checker = checker;
     }
@@ -124,15 +125,6 @@ class TypeScriptReflectionHost {
         }
         return clazz.typeParameters !== undefined ? clazz.typeParameters.length : 0;
     }
-    getDtsDeclaration(_) {
-        return null;
-    }
-    getInternalNameOfClass(clazz) {
-        return clazz.name;
-    }
-    getAdjacentNameOfClass(clazz) {
-        return clazz.name;
-    }
     getDirectImportOfIdentifier(id) {
         const symbol = this.checker.getSymbolAtLocation(id);
         if (symbol === undefined ||
@@ -154,6 +146,7 @@ class TypeScriptReflectionHost {
         return {
             from: importDecl.moduleSpecifier.text,
             name: getExportedName(decl, id),
+            node: importDecl,
         };
     }
     /**
@@ -202,6 +195,7 @@ class TypeScriptReflectionHost {
         return {
             from: importDeclaration.moduleSpecifier.text,
             name: id.text,
+            node: namespaceDeclaration.parent.parent,
         };
     }
     _reflectDecorator(node) {
@@ -369,6 +363,7 @@ function getContainingImportDeclaration(node) {
             ? node.parent.parent
             : null;
 }
+exports.getContainingImportDeclaration = getContainingImportDeclaration;
 /**
  * Compute the name by which the `decl` was exported, not imported.
  * If no such declaration can be found (e.g. it is a namespace import)

package/transform/compiler-cli/src/ngtsc/transform/src/api.d.ts

@@ -8,25 +8,6 @@
 import { Expression, Statement, Type } from 'static-injector/transform/compiler';
 import ts from 'typescript';
 import { ClassDeclaration, Decorator } from '../../reflection';
-/**
- * A set of options which can be passed to a `DecoratorHandler` by a consumer, to tailor the output
- * of compilation beyond the decorators themselves.
- */
-export declare enum HandlerFlags {
-    /**
-     * No flags set.
-     */
-    NONE = 0,
-    /**
-     * Indicates that this decorator is fully inherited from its parent at runtime. In addition to
-     * normally inherited aspects such as inputs and queries, full inheritance applies to every aspect
-     * of the component or directive, such as the template function itself.
-     *
-     * Its primary effect is to cause the `CopyDefinitionFeature` to be applied to the definition
-     * being compiled. See that class for more information.
-     */
-    FULL_INHERITANCE = 1
-}
 /**
  * Provides the interface between a decorator compiler from @angular/compiler and the Typescript
  * compiler/transform.
@@ -64,13 +45,13 @@ export interface DecoratorHandler<D, A, R> {
      * builds. Any side effects required for compilation (e.g. registration of metadata) should happen
      * in the `register` phase, which is guaranteed to run even for incremental builds.
      */
-    analyze(node: ClassDeclaration, metadata: Readonly<D>, handlerFlags?: HandlerFlags): AnalysisOutput<A>;
+    analyze(node: ClassDeclaration, metadata: Readonly<D>): AnalysisOutput<A>;
     /**
      * Generate a description of the field which should be added to the class, including any
      * initialization code to be generated.
      *
-     * If the compilation mode is configured as partial, and an implementation of `compilePartial` is
-     * provided, then this method is not called.
+     * If the compilation mode is configured as other than full but an implementation of the
+     * corresponding method is not provided, then this method is called as a fallback.
      */
     compileFull(node: ClassDeclaration, analysis: Readonly<A>): CompileResult | CompileResult[];
 }
@@ -109,7 +90,8 @@ export interface AnalysisOutput<A> {
  */
 export interface CompileResult {
     name: string;
-    initializer: Expression;
+    initializer: Expression | null;
     statements: Statement[];
     type: Type;
+    deferrableImports: Set<ts.ImportDeclaration> | null;
 }

package/transform/compiler-cli/src/ngtsc/transform/src/api.js

@@ -7,24 +7,3 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HandlerFlags = void 0;
-/**
- * A set of options which can be passed to a `DecoratorHandler` by a consumer, to tailor the output
- * of compilation beyond the decorators themselves.
- */
-var HandlerFlags;
-(function (HandlerFlags) {
-    /**
-     * No flags set.
-     */
-    HandlerFlags[HandlerFlags["NONE"] = 0] = "NONE";
-    /**
-     * Indicates that this decorator is fully inherited from its parent at runtime. In addition to
-     * normally inherited aspects such as inputs and queries, full inheritance applies to every aspect
-     * of the component or directive, such as the template function itself.
-     *
-     * Its primary effect is to cause the `CopyDefinitionFeature` to be applied to the definition
-     * being compiled. See that class for more information.
-     */
-    HandlerFlags[HandlerFlags["FULL_INHERITANCE"] = 1] = "FULL_INHERITANCE";
-})(HandlerFlags = exports.HandlerFlags || (exports.HandlerFlags = {}));

package/transform/compiler-cli/src/ngtsc/transform/src/utils.js

@@ -12,7 +12,6 @@ exports.addImports = void 0;
  * found in the LICENSE file at https://angular.io/license
  */
 const typescript_1 = __importDefault(require("typescript"));
-const ts_compatibility_1 = require("../../ts_compatibility");
 /**
  * Adds extra imports in the import manage for this source file, after the existing imports
  * and before the module body.
@@ -26,7 +25,7 @@ function addImports(importManager, sf, extraStatements = []) {
         /* isTypeOnly */ false, 
         /* name */ undefined, 
         /* namedBindings */ typescript_1.default.factory.createNamespaceImport(qualifier));
-        const decl = (0, ts_compatibility_1.createImportDeclaration)(
+        const decl = typescript_1.default.factory.createImportDeclaration(
         /* modifiers */ undefined, 
         /* importClause */ importClause, 
         /* moduleSpecifier */ typescript_1.default.factory.createStringLiteral(i.specifier));

package/transform/compiler-cli/src/ngtsc/translator/src/api/ast_factory.d.ts

@@ -93,6 +93,13 @@ export interface AstFactory<TStatement, TExpression> {
      * @param body a statement (or a block of statements) that are the body of the function.
      */
     createFunctionExpression(functionName: string | null, parameters: string[], body: TStatement): TExpression;
+    /**
+     * Creates an expression that represents a dynamic import
+     * (e.g. `import('./some/path')`)
+     *
+     * @param url the URL that should by used in the dynamic import
+     */
+    createDynamicImport(url: string): TExpression;
     /**
      * Create an identifier.
      *

package/transform/compiler-cli/src/ngtsc/translator/src/context.js

@@ -14,6 +14,7 @@ exports.Context = void 0;
  * It tracks whether we are in the process of outputting a statement or an expression.
  */
 class Context {
+    isStatement;
     constructor(isStatement) {
         this.isStatement = isStatement;
     }

package/transform/compiler-cli/src/ngtsc/translator/src/import_manager.js

@@ -14,11 +14,13 @@ exports.ImportManager = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const imports_1 = require("../../imports");
 class ImportManager {
+    rewriter;
+    prefix;
+    specifierToIdentifier = new Map();
+    nextIndex = 0;
     constructor(rewriter = new imports_1.NoopImportRewriter(), prefix = 'i') {
         this.rewriter = rewriter;
         this.prefix = prefix;
-        this.specifierToIdentifier = new Map();
-        this.nextIndex = 0;
     }
     generateNamespaceImport(moduleName) {
         if (!this.specifierToIdentifier.has(moduleName)) {

package/transform/compiler-cli/src/ngtsc/translator/src/translator.d.ts

@@ -37,6 +37,7 @@ export declare class ExpressionTranslatorVisitor<TStatement, TExpression> implem
     visitLiteralExpr(ast: o.LiteralExpr, _context: Context): TExpression;
     visitExternalExpr(ast: o.ExternalExpr, _context: Context): TExpression;
     visitConditionalExpr(ast: o.ConditionalExpr, context: Context): TExpression;
+    visitDynamicImportExpr(ast: o.DynamicImportExpr, context: any): TExpression;
     visitNotExpr(ast: o.NotExpr, context: Context): TExpression;
     visitFunctionExpr(ast: o.FunctionExpr, context: Context): TExpression;
     visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, context: Context): TExpression;

package/transform/compiler-cli/src/ngtsc/translator/src/translator.js

@@ -56,6 +56,11 @@ const BINARY_OPERATORS = new Map([
     [o.BinaryOperator.NullishCoalesce, '??'],
 ]);
 class ExpressionTranslatorVisitor {
+    factory;
+    imports;
+    downlevelTaggedTemplates;
+    downlevelVariableDeclarations;
+    recordWrappedNode;
     constructor(factory, imports, options) {
         this.factory = factory;
         this.imports = imports;
@@ -65,13 +70,12 @@ class ExpressionTranslatorVisitor {
         this.recordWrappedNode = options.recordWrappedNode || (() => { });
     }
     visitDeclareVarStmt(stmt, context) {
-        var _a;
         const varType = this.downlevelVariableDeclarations
             ? 'var'
             : stmt.hasModifier(o.StmtModifier.Final)
                 ? 'const'
                 : 'let';
-        return this.attachComments(this.factory.createVariableDeclaration(stmt.name, (_a = stmt.value) === null || _a === void 0 ? void 0 : _a.visitExpression(this, context.withExpressionMode), varType), stmt.leadingComments);
+        return this.attachComments(this.factory.createVariableDeclaration(stmt.name, stmt.value?.visitExpression(this, context.withExpressionMode), varType), stmt.leadingComments);
     }
     visitDeclareFunctionStmt(stmt, context) {
         return this.attachComments(this.factory.createFunctionDeclaration(stmt.name, stmt.params.map((param) => param.name), this.factory.createBlock(this.visitStatements(stmt.statements, context.withStatementMode))), stmt.leadingComments);
@@ -173,12 +177,14 @@ class ExpressionTranslatorVisitor {
         }
         return this.factory.createConditional(cond, ast.trueCase.visitExpression(this, context), ast.falseCase.visitExpression(this, context));
     }
+    visitDynamicImportExpr(ast, context) {
+        return this.factory.createDynamicImport(ast.url);
+    }
     visitNotExpr(ast, context) {
         return this.factory.createUnaryExpression('!', ast.condition.visitExpression(this, context));
     }
     visitFunctionExpr(ast, context) {
-        var _a;
-        return this.factory.createFunctionExpression((_a = ast.name) !== null && _a !== void 0 ? _a : null, ast.params.map((param) => param.name), this.factory.createBlock(this.visitStatements(ast.statements, context)));
+        return this.factory.createFunctionExpression(ast.name ?? null, ast.params.map((param) => param.name), this.factory.createBlock(this.visitStatements(ast.statements, context)));
     }
     visitBinaryOperatorExpr(ast, context) {
         if (!BINARY_OPERATORS.has(ast.operator)) {

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.d.ts

@@ -15,7 +15,7 @@ export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts
     private externalSourceFiles;
     constructor(annotateForClosureCompiler: boolean);
     attachComments: typeof attachComments;
-    createArrayLiteral: (elements?: readonly ts.Expression[], multiLine?: boolean) => ts.ArrayLiteralExpression;
+    createArrayLiteral: (elements?: readonly ts.Expression[] | undefined, multiLine?: boolean | undefined) => ts.ArrayLiteralExpression;
     createAssignment(target: ts.Expression, value: ts.Expression): ts.Expression;
     createBinaryExpression(leftOperand: ts.Expression, operator: BinaryOperator, rightOperand: ts.Expression): ts.Expression;
     createBlock(body: ts.Statement[]): ts.Statement;
@@ -23,6 +23,7 @@ export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts
     createConditional(condition: ts.Expression, whenTrue: ts.Expression, whenFalse: ts.Expression): ts.Expression;
     createElementAccess: (expression: ts.Expression, index: number | ts.Expression) => ts.ElementAccessExpression;
     createExpressionStatement: (expression: ts.Expression) => ts.ExpressionStatement;
+    createDynamicImport(url: string): ts.CallExpression;
     createFunctionDeclaration(functionName: string, parameters: string[], body: ts.Statement): ts.Statement;
     createFunctionExpression(functionName: string | null, parameters: string[], body: ts.Statement): ts.Expression;
     createIdentifier: (text: string) => ts.Identifier;

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.js

@@ -12,7 +12,6 @@ exports.attachComments = exports.createTemplateTail = exports.createTemplateMidd
  * found in the LICENSE file at https://angular.io/license
  */
 const typescript_1 = __importDefault(require("typescript"));
-const ts_compatibility_1 = require("../../ts_compatibility");
 /**
  * Different optimizers use different annotations on a function or method call to indicate its pure
  * status.
@@ -60,19 +59,13 @@ const VAR_TYPES = {
  * A TypeScript flavoured implementation of the AstFactory.
  */
 class TypeScriptAstFactory {
+    annotateForClosureCompiler;
+    externalSourceFiles = new Map();
     constructor(annotateForClosureCompiler) {
         this.annotateForClosureCompiler = annotateForClosureCompiler;
-        this.externalSourceFiles = new Map();
-        this.attachComments = attachComments;
-        this.createArrayLiteral = typescript_1.default.factory.createArrayLiteralExpression;
-        this.createElementAccess = typescript_1.default.factory.createElementAccessExpression;
-        this.createExpressionStatement = typescript_1.default.factory.createExpressionStatement;
-        this.createIdentifier = typescript_1.default.factory.createIdentifier;
-        this.createParenthesizedExpression = typescript_1.default.factory.createParenthesizedExpression;
-        this.createPropertyAccess = typescript_1.default.factory.createPropertyAccessExpression;
-        this.createThrowStatement = typescript_1.default.factory.createThrowStatement;
-        this.createTypeOfExpression = typescript_1.default.factory.createTypeOfExpression;
     }
+    attachComments = attachComments;
+    createArrayLiteral = typescript_1.default.factory.createArrayLiteralExpression;
     createAssignment(target, value) {
         return typescript_1.default.factory.createBinaryExpression(target, typescript_1.default.SyntaxKind.EqualsToken, value);
     }
@@ -95,20 +88,27 @@ class TypeScriptAstFactory {
     createConditional(condition, whenTrue, whenFalse) {
         return typescript_1.default.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
     }
+    createElementAccess = typescript_1.default.factory.createElementAccessExpression;
+    createExpressionStatement = typescript_1.default.factory.createExpressionStatement;
+    createDynamicImport(url) {
+        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.ImportKeyword), 
+        /* type */ undefined, [typescript_1.default.factory.createStringLiteral(url)]);
+    }
     createFunctionDeclaration(functionName, parameters, body) {
         if (!typescript_1.default.isBlock(body)) {
             throw new Error(`Invalid syntax, expected a block, but got ${typescript_1.default.SyntaxKind[body.kind]}.`);
         }
-        return (0, ts_compatibility_1.createFunctionDeclaration)(undefined, undefined, functionName, undefined, parameters.map((param) => (0, ts_compatibility_1.createParameterDeclaration)(undefined, undefined, param)), undefined, body);
+        return typescript_1.default.factory.createFunctionDeclaration(undefined, undefined, functionName, undefined, parameters.map((param) => typescript_1.default.factory.createParameterDeclaration(undefined, undefined, param)), undefined, body);
     }
     createFunctionExpression(functionName, parameters, body) {
         if (!typescript_1.default.isBlock(body)) {
             throw new Error(`Invalid syntax, expected a block, but got ${typescript_1.default.SyntaxKind[body.kind]}.`);
         }
-        return typescript_1.default.factory.createFunctionExpression(undefined, undefined, functionName !== null && functionName !== void 0 ? functionName : undefined, undefined, parameters.map((param) => (0, ts_compatibility_1.createParameterDeclaration)(undefined, undefined, param)), undefined, body);
+        return typescript_1.default.factory.createFunctionExpression(undefined, undefined, functionName ?? undefined, undefined, parameters.map((param) => typescript_1.default.factory.createParameterDeclaration(undefined, undefined, param)), undefined, body);
     }
+    createIdentifier = typescript_1.default.factory.createIdentifier;
     createIfStatement(condition, thenStatement, elseStatement) {
-        return typescript_1.default.factory.createIfStatement(condition, thenStatement, elseStatement !== null && elseStatement !== void 0 ? elseStatement : undefined);
+        return typescript_1.default.factory.createIfStatement(condition, thenStatement, elseStatement ?? undefined);
     }
     createLiteral(value) {
         if (value === undefined) {
@@ -135,8 +135,10 @@ class TypeScriptAstFactory {
             ? typescript_1.default.factory.createStringLiteral(prop.propertyName)
             : typescript_1.default.factory.createIdentifier(prop.propertyName), prop.value)));
     }
+    createParenthesizedExpression = typescript_1.default.factory.createParenthesizedExpression;
+    createPropertyAccess = typescript_1.default.factory.createPropertyAccessExpression;
     createReturnStatement(expression) {
-        return typescript_1.default.factory.createReturnStatement(expression !== null && expression !== void 0 ? expression : undefined);
+        return typescript_1.default.factory.createReturnStatement(expression ?? undefined);
     }
     createTaggedTemplate(tag, template) {
         let templateLiteral;
@@ -172,12 +174,14 @@ class TypeScriptAstFactory {
         }
         return typescript_1.default.factory.createTaggedTemplateExpression(tag, undefined, templateLiteral);
     }
+    createThrowStatement = typescript_1.default.factory.createThrowStatement;
+    createTypeOfExpression = typescript_1.default.factory.createTypeOfExpression;
     createUnaryExpression(operator, operand) {
         return typescript_1.default.factory.createPrefixUnaryExpression(UNARY_OPERATORS[operator], operand);
     }
     createVariableDeclaration(variableName, initializer, type) {
         return typescript_1.default.factory.createVariableStatement(undefined, typescript_1.default.factory.createVariableDeclarationList([
-            typescript_1.default.factory.createVariableDeclaration(variableName, undefined, undefined, initializer !== null && initializer !== void 0 ? initializer : undefined),
+            typescript_1.default.factory.createVariableDeclaration(variableName, undefined, undefined, initializer ?? undefined),
         ], VAR_TYPES[type]));
     }
     setSourceMapRange(node, sourceMapRange) {

package/transform/injectable-transform.d.ts

@@ -4,7 +4,7 @@ import { TypeScriptReflectionHost } from './compiler-cli/src/ngtsc/reflection';
 export interface InjectableTransformerFactoryOptions {
     strictCtorDeps?: boolean;
 }
-export declare function createTransformer(program: ts.Program, options?: InjectableTransformerFactoryOptions): (context: ts.TransformationContext) => (sf: ts.SourceFile) => any;
+export declare function createTransformer(program: ts.Program, options?: InjectableTransformerFactoryOptions): (context: ts.TransformationContext) => (sf: ts.SourceFile) => ts.SourceFile;
 export declare class InjectableTransformerFactory {
     private program;
     private options;
@@ -12,7 +12,7 @@ export declare class InjectableTransformerFactory {
     reflectionHost: TypeScriptReflectionHost;
     handler: InjectableDecoratorHandler;
     constructor(program: ts.Program, options?: InjectableTransformerFactoryOptions);
-    getTransform(): (context: ts.TransformationContext) => (sf: ts.SourceFile) => any;
+    getTransform(): (context: ts.TransformationContext) => (sf: ts.SourceFile) => ts.SourceFile;
     private visit;
     private transform;
     private preAnalysis;

package/transform/injectable-transform.js

@@ -18,12 +18,17 @@ function createTransformer(program, options) {
 }
 exports.createTransformer = createTransformer;
 class InjectableTransformerFactory {
+    program;
+    options;
+    typeChecker;
+    reflectionHost;
+    handler;
     constructor(program, options = {}) {
         this.program = program;
         this.options = options;
         this.typeChecker = this.program.getTypeChecker();
         this.reflectionHost = new reflection_1.TypeScriptReflectionHost(this.typeChecker);
-        this.handler = new injectable_1.InjectableDecoratorHandler(this.reflectionHost, false, this.options.strictCtorDeps);
+        this.handler = new injectable_1.InjectableDecoratorHandler(this.reflectionHost, false, !!this.options.strictCtorDeps, false);
     }
     getTransform() {
         return (context) => this.transform(context);
@@ -34,16 +39,18 @@ class InjectableTransformerFactory {
             if (result) {
                 const filteredDecorators = 
                 // Remove the decorator which triggered this compilation, leaving the others alone.
-                maybeFilterDecorator(typescript_1.default.getDecorators(node), [result.decorator]);
+                maybeFilterDecorator(typescript_1.default.getDecorators(node), [
+                    result.decorator,
+                ]);
                 const nodeModifiers = typescript_1.default.getModifiers(node);
                 let updatedModifiers;
-                if ((filteredDecorators === null || filteredDecorators === void 0 ? void 0 : filteredDecorators.length) || (nodeModifiers === null || nodeModifiers === void 0 ? void 0 : nodeModifiers.length)) {
+                if (filteredDecorators?.length || nodeModifiers?.length) {
                     updatedModifiers = [
                         ...(filteredDecorators || []),
                         ...(nodeModifiers || []),
                     ];
                 }
-                return typescript_1.default.factory.updateClassDeclaration(node, updatedModifiers, node.name, node.typeParameters, node.heritageClauses, [
+                return typescript_1.default.factory.updateClassDeclaration(node, updatedModifiers, node.name, node.typeParameters, node.heritageClauses || [], [
                     ...node.members.map((node) => this._stripAngularDecorators(node)),
                     ...result.members,
                 ]);
@@ -66,7 +73,7 @@ class InjectableTransformerFactory {
             if (typescript_1.default.isClassDeclaration(node) &&
                 typescript_1.default.getDecorators(node) &&
                 this.reflectionHost.isClass(node)) {
-                const decorators = this.reflectionHost.getDecoratorsOfDeclaration(node);
+                const decorators = this.reflectionHost.getDecoratorsOfDeclaration(node) || [];
                 let result = this.handler.detect(node, decorators);
                 if (!result) {
                     return;
@@ -74,7 +81,10 @@ class InjectableTransformerFactory {
                 let analysisOutput = this.handler.analyze(node, result.metadata);
                 let compileResult = this.handler.compileFull(node, analysisOutput.analysis);
                 let resultNode = this.translate(compileResult, importManager);
-                classMetadataMap.set(node, Object.assign(Object.assign({}, resultNode), { decorator: result.trigger }));
+                classMetadataMap.set(node, {
+                    ...resultNode,
+                    decorator: result.trigger,
+                });
             }
         });
         // this.sourceFileMetadataMap.set(sf, {
@@ -128,6 +138,22 @@ class InjectableTransformerFactory {
             // Strip decorators from parameters (probably of the constructor).
             node = typescript_1.default.factory.updateParameterDeclaration(node, combinedModifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
         }
+        else if (typescript_1.default.isMethodDeclaration(node)) {
+            // Strip decorators of methods.
+            node = typescript_1.default.factory.updateMethodDeclaration(node, combinedModifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
+        }
+        else if (typescript_1.default.isPropertyDeclaration(node)) {
+            // Strip decorators of properties.
+            node = typescript_1.default.factory.updatePropertyDeclaration(node, combinedModifiers, node.name, node.questionToken, node.type, node.initializer);
+        }
+        else if (typescript_1.default.isGetAccessor(node)) {
+            // Strip decorators of getters.
+            node = typescript_1.default.factory.updateGetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.type, node.body);
+        }
+        else if (typescript_1.default.isSetAccessor(node)) {
+            // Strip decorators of setters.
+            node = typescript_1.default.factory.updateSetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.body);
+        }
         else if (typescript_1.default.isConstructorDeclaration(node)) {
             // For constructors, strip decorators of the parameters.
             const parameters = node.parameters.map((param) => this._stripAngularDecorators(param));