static-injector 1.0.10 → 2.1.0

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

@@ -1,22 +1,6 @@
 "use strict";
-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]; } });
-}) : (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.attachComments = exports.createTemplateTail = exports.createTemplateMiddle = exports.TypeScriptAstFactory = void 0;
@@ -27,7 +11,8 @@ exports.attachComments = exports.createTemplateTail = exports.createTemplateMidd
  * 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
  */
-const ts = __importStar(require("typescript"));
+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.
@@ -43,33 +28,33 @@ var PureAnnotation;
     PureAnnotation["TERSER"] = "@__PURE__";
 })(PureAnnotation || (PureAnnotation = {}));
 const UNARY_OPERATORS = {
-    "+": ts.SyntaxKind.PlusToken,
-    "-": ts.SyntaxKind.MinusToken,
-    "!": ts.SyntaxKind.ExclamationToken,
+    '+': typescript_1.default.SyntaxKind.PlusToken,
+    '-': typescript_1.default.SyntaxKind.MinusToken,
+    '!': typescript_1.default.SyntaxKind.ExclamationToken,
 };
 const BINARY_OPERATORS = {
-    "&&": ts.SyntaxKind.AmpersandAmpersandToken,
-    ">": ts.SyntaxKind.GreaterThanToken,
-    ">=": ts.SyntaxKind.GreaterThanEqualsToken,
-    "&": ts.SyntaxKind.AmpersandToken,
-    "/": ts.SyntaxKind.SlashToken,
-    "==": ts.SyntaxKind.EqualsEqualsToken,
-    "===": ts.SyntaxKind.EqualsEqualsEqualsToken,
-    "<": ts.SyntaxKind.LessThanToken,
-    "<=": ts.SyntaxKind.LessThanEqualsToken,
-    "-": ts.SyntaxKind.MinusToken,
-    "%": ts.SyntaxKind.PercentToken,
-    "*": ts.SyntaxKind.AsteriskToken,
-    "!=": ts.SyntaxKind.ExclamationEqualsToken,
-    "!==": ts.SyntaxKind.ExclamationEqualsEqualsToken,
-    "||": ts.SyntaxKind.BarBarToken,
-    "+": ts.SyntaxKind.PlusToken,
-    "??": ts.SyntaxKind.QuestionQuestionToken,
+    '&&': typescript_1.default.SyntaxKind.AmpersandAmpersandToken,
+    '>': typescript_1.default.SyntaxKind.GreaterThanToken,
+    '>=': typescript_1.default.SyntaxKind.GreaterThanEqualsToken,
+    '&': typescript_1.default.SyntaxKind.AmpersandToken,
+    '/': typescript_1.default.SyntaxKind.SlashToken,
+    '==': typescript_1.default.SyntaxKind.EqualsEqualsToken,
+    '===': typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken,
+    '<': typescript_1.default.SyntaxKind.LessThanToken,
+    '<=': typescript_1.default.SyntaxKind.LessThanEqualsToken,
+    '-': typescript_1.default.SyntaxKind.MinusToken,
+    '%': typescript_1.default.SyntaxKind.PercentToken,
+    '*': typescript_1.default.SyntaxKind.AsteriskToken,
+    '!=': typescript_1.default.SyntaxKind.ExclamationEqualsToken,
+    '!==': typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken,
+    '||': typescript_1.default.SyntaxKind.BarBarToken,
+    '+': typescript_1.default.SyntaxKind.PlusToken,
+    '??': typescript_1.default.SyntaxKind.QuestionQuestionToken,
 };
 const VAR_TYPES = {
-    const: ts.NodeFlags.Const,
-    let: ts.NodeFlags.Let,
-    var: ts.NodeFlags.None,
+    const: typescript_1.default.NodeFlags.Const,
+    let: typescript_1.default.NodeFlags.Let,
+    var: typescript_1.default.NodeFlags.None,
 };
 /**
  * A TypeScript flavoured implementation of the AstFactory.
@@ -79,78 +64,86 @@ class TypeScriptAstFactory {
         this.annotateForClosureCompiler = annotateForClosureCompiler;
         this.externalSourceFiles = new Map();
         this.attachComments = attachComments;
-        this.createArrayLiteral = ts.createArrayLiteral;
-        this.createConditional = ts.createConditional;
-        this.createElementAccess = ts.createElementAccess;
-        this.createExpressionStatement = ts.createExpressionStatement;
-        this.createIdentifier = ts.createIdentifier;
-        this.createParenthesizedExpression = ts.createParen;
-        this.createPropertyAccess = ts.createPropertyAccess;
-        this.createThrowStatement = ts.createThrow;
-        this.createTypeOfExpression = ts.createTypeOf;
+        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;
     }
     createAssignment(target, value) {
-        return ts.createBinary(target, ts.SyntaxKind.EqualsToken, value);
+        return typescript_1.default.factory.createBinaryExpression(target, typescript_1.default.SyntaxKind.EqualsToken, value);
     }
     createBinaryExpression(leftOperand, operator, rightOperand) {
-        return ts.createBinary(leftOperand, BINARY_OPERATORS[operator], rightOperand);
+        return typescript_1.default.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS[operator], rightOperand);
     }
     createBlock(body) {
-        return ts.createBlock(body);
+        return typescript_1.default.factory.createBlock(body);
     }
     createCallExpression(callee, args, pure) {
-        const call = ts.createCall(callee, undefined, args);
+        const call = typescript_1.default.factory.createCallExpression(callee, undefined, args);
         if (pure) {
-            ts.addSyntheticLeadingComment(call, ts.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler
+            typescript_1.default.addSyntheticLeadingComment(call, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler
                 ? PureAnnotation.CLOSURE
                 : PureAnnotation.TERSER, 
             /* trailing newline */ false);
         }
         return call;
     }
+    createConditional(condition, whenTrue, whenFalse) {
+        return typescript_1.default.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
+    }
     createFunctionDeclaration(functionName, parameters, body) {
-        if (!ts.isBlock(body)) {
-            throw new Error(`Invalid syntax, expected a block, but got ${ts.SyntaxKind[body.kind]}.`);
+        if (!typescript_1.default.isBlock(body)) {
+            throw new Error(`Invalid syntax, expected a block, but got ${typescript_1.default.SyntaxKind[body.kind]}.`);
         }
-        return ts.createFunctionDeclaration(undefined, undefined, undefined, functionName, undefined, parameters.map((param) => ts.createParameter(undefined, undefined, undefined, param)), undefined, body);
+        return (0, ts_compatibility_1.createFunctionDeclaration)(undefined, undefined, functionName, undefined, parameters.map((param) => (0, ts_compatibility_1.createParameterDeclaration)(undefined, undefined, param)), undefined, body);
     }
     createFunctionExpression(functionName, parameters, body) {
-        if (!ts.isBlock(body)) {
-            throw new Error(`Invalid syntax, expected a block, but got ${ts.SyntaxKind[body.kind]}.`);
+        if (!typescript_1.default.isBlock(body)) {
+            throw new Error(`Invalid syntax, expected a block, but got ${typescript_1.default.SyntaxKind[body.kind]}.`);
         }
-        return ts.createFunctionExpression(undefined, undefined, functionName !== null && functionName !== void 0 ? functionName : undefined, undefined, parameters.map((param) => ts.createParameter(undefined, undefined, undefined, param)), undefined, body);
+        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);
     }
     createIfStatement(condition, thenStatement, elseStatement) {
-        return ts.createIf(condition, thenStatement, elseStatement !== null && elseStatement !== void 0 ? elseStatement : undefined);
+        return typescript_1.default.factory.createIfStatement(condition, thenStatement, elseStatement !== null && elseStatement !== void 0 ? elseStatement : undefined);
     }
     createLiteral(value) {
         if (value === undefined) {
-            return ts.createIdentifier("undefined");
+            return typescript_1.default.factory.createIdentifier('undefined');
         }
         else if (value === null) {
-            return ts.createNull();
+            return typescript_1.default.factory.createNull();
+        }
+        else if (typeof value === 'boolean') {
+            return value ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createFalse();
+        }
+        else if (typeof value === 'number') {
+            return typescript_1.default.factory.createNumericLiteral(value);
         }
         else {
-            return ts.createLiteral(value);
+            return typescript_1.default.factory.createStringLiteral(value);
         }
     }
     createNewExpression(expression, args) {
-        return ts.createNew(expression, undefined, args);
+        return typescript_1.default.factory.createNewExpression(expression, undefined, args);
     }
     createObjectLiteral(properties) {
-        return ts.createObjectLiteral(properties.map((prop) => ts.createPropertyAssignment(prop.quoted
-            ? ts.createLiteral(prop.propertyName)
-            : ts.createIdentifier(prop.propertyName), prop.value)));
+        return typescript_1.default.factory.createObjectLiteralExpression(properties.map((prop) => typescript_1.default.factory.createPropertyAssignment(prop.quoted
+            ? typescript_1.default.factory.createStringLiteral(prop.propertyName)
+            : typescript_1.default.factory.createIdentifier(prop.propertyName), prop.value)));
     }
     createReturnStatement(expression) {
-        return ts.createReturn(expression !== null && expression !== void 0 ? expression : undefined);
+        return typescript_1.default.factory.createReturnStatement(expression !== null && expression !== void 0 ? expression : undefined);
     }
     createTaggedTemplate(tag, template) {
         let templateLiteral;
         const length = template.elements.length;
         const head = template.elements[0];
         if (length === 1) {
-            templateLiteral = ts.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+            templateLiteral = typescript_1.default.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
         }
         else {
             const spans = [];
@@ -161,7 +154,7 @@ class TypeScriptAstFactory {
                 if (range !== null) {
                     this.setSourceMapRange(middle, range);
                 }
-                spans.push(ts.createTemplateSpan(template.expressions[i - 1], middle));
+                spans.push(typescript_1.default.factory.createTemplateSpan(template.expressions[i - 1], middle));
             }
             // Create the tail part
             const resolvedExpression = template.expressions[length - 2];
@@ -170,21 +163,21 @@ class TypeScriptAstFactory {
             if (templatePart.range !== null) {
                 this.setSourceMapRange(templateTail, templatePart.range);
             }
-            spans.push(ts.createTemplateSpan(resolvedExpression, templateTail));
+            spans.push(typescript_1.default.factory.createTemplateSpan(resolvedExpression, templateTail));
             // Put it all together
-            templateLiteral = ts.createTemplateExpression(ts.createTemplateHead(head.cooked, head.raw), spans);
+            templateLiteral = typescript_1.default.factory.createTemplateExpression(typescript_1.default.factory.createTemplateHead(head.cooked, head.raw), spans);
         }
         if (head.range !== null) {
             this.setSourceMapRange(templateLiteral, head.range);
         }
-        return ts.createTaggedTemplate(tag, templateLiteral);
+        return typescript_1.default.factory.createTaggedTemplateExpression(tag, undefined, templateLiteral);
     }
     createUnaryExpression(operator, operand) {
-        return ts.createPrefix(UNARY_OPERATORS[operator], operand);
+        return typescript_1.default.factory.createPrefixUnaryExpression(UNARY_OPERATORS[operator], operand);
     }
     createVariableDeclaration(variableName, initializer, type) {
-        return ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
-            ts.createVariableDeclaration(variableName, undefined, initializer !== null && initializer !== void 0 ? initializer : undefined),
+        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),
         ], VAR_TYPES[type]));
     }
     setSourceMapRange(node, sourceMapRange) {
@@ -193,10 +186,10 @@ class TypeScriptAstFactory {
         }
         const url = sourceMapRange.url;
         if (!this.externalSourceFiles.has(url)) {
-            this.externalSourceFiles.set(url, ts.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+            this.externalSourceFiles.set(url, typescript_1.default.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
         }
         const source = this.externalSourceFiles.get(url);
-        ts.setSourceMapRange(node, {
+        typescript_1.default.setSourceMapRange(node, {
             pos: sourceMapRange.start.offset,
             end: sourceMapRange.end.offset,
             source,
@@ -208,16 +201,16 @@ exports.TypeScriptAstFactory = TypeScriptAstFactory;
 // HACK: Use this in place of `ts.createTemplateMiddle()`.
 // Revert once https://github.com/microsoft/TypeScript/issues/35374 is fixed.
 function createTemplateMiddle(cooked, raw) {
-    const node = ts.createTemplateHead(cooked, raw);
-    node.kind = ts.SyntaxKind.TemplateMiddle;
+    const node = typescript_1.default.factory.createTemplateHead(cooked, raw);
+    node.kind = typescript_1.default.SyntaxKind.TemplateMiddle;
     return node;
 }
 exports.createTemplateMiddle = createTemplateMiddle;
 // HACK: Use this in place of `ts.createTemplateTail()`.
 // Revert once https://github.com/microsoft/TypeScript/issues/35374 is fixed.
 function createTemplateTail(cooked, raw) {
-    const node = ts.createTemplateHead(cooked, raw);
-    node.kind = ts.SyntaxKind.TemplateTail;
+    const node = typescript_1.default.factory.createTemplateHead(cooked, raw);
+    node.kind = typescript_1.default.SyntaxKind.TemplateTail;
     return node;
 }
 exports.createTemplateTail = createTemplateTail;
@@ -230,14 +223,14 @@ exports.createTemplateTail = createTemplateTail;
 function attachComments(statement, leadingComments) {
     for (const comment of leadingComments) {
         const commentKind = comment.multiline
-            ? ts.SyntaxKind.MultiLineCommentTrivia
-            : ts.SyntaxKind.SingleLineCommentTrivia;
+            ? typescript_1.default.SyntaxKind.MultiLineCommentTrivia
+            : typescript_1.default.SyntaxKind.SingleLineCommentTrivia;
         if (comment.multiline) {
-            ts.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+            typescript_1.default.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
         }
         else {
-            for (const line of comment.toString().split("\n")) {
-                ts.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+            for (const line of comment.toString().split('\n')) {
+                typescript_1.default.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
             }
         }
     }

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

@@ -5,9 +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 * as o from "../../../../../compiler";
-import * as ts from "typescript";
-import { ImportGenerator } from "./api/import_generator";
-import { TranslatorOptions } from "./translator";
+import * as o from 'static-injector/transform/compiler';
+import ts from 'typescript';
+import { ImportGenerator } from './api/import_generator';
+import { TranslatorOptions } from './translator';
 export declare function translateExpression(expression: o.Expression, imports: ImportGenerator<ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Expression;
 export declare function translateStatement(statement: o.Statement, imports: ImportGenerator<ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Statement;

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

@@ -0,0 +1,8 @@
+/**
+ * @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/ts_cross_version_utils';

package/transform/compiler-cli/src/ngtsc/ts_compatibility/index.js

@@ -0,0 +1,24 @@
+"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/ts_cross_version_utils"), exports);

package/transform/compiler-cli/src/ngtsc/ts_compatibility/src/ts_cross_version_utils.d.ts

@@ -0,0 +1,45 @@
+/*!
+ * @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 ts from 'typescript';
+/** Type of `ts.factory.CreateParameterDeclaration` in TS 4.9+. */
+type Ts49CreateParameterDeclarationFn = (modifiers: readonly ts.ModifierLike[] | undefined, dotDotDotToken: ts.DotDotDotToken | undefined, name: string | ts.BindingName, questionToken?: ts.QuestionToken | undefined, type?: ts.TypeNode | undefined, initializer?: ts.Expression) => ts.ParameterDeclaration;
+/**
+ * Creates a `ts.ParameterDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createParameterDeclaration: Ts49CreateParameterDeclarationFn;
+/** Type of `ts.factory.createImportDeclaration` in TS 4.9+. */
+type Ts49CreateImportDeclarationFn = (modifiers: readonly ts.Modifier[] | undefined, importClause: ts.ImportClause | undefined, moduleSpecifier: ts.Expression, assertClause?: ts.AssertClause) => ts.ImportDeclaration;
+/**
+ * Creates a `ts.ImportDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createImportDeclaration: Ts49CreateImportDeclarationFn;
+/** Type of `ts.factory.createFunctionDeclaration` in TS 4.9+. */
+type Ts49CreateFunctionDeclarationFn = (modifiers: readonly ts.ModifierLike[] | undefined, asteriskToken: ts.AsteriskToken | undefined, name: string | ts.Identifier | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.FunctionDeclaration;
+/**
+ * Creates a `ts.FunctionDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createFunctionDeclaration: Ts49CreateFunctionDeclarationFn;
+/** Type of `ts.factory.createIndexSignature` in TS 4.9+. */
+type Ts49CreateIndexSignatureFn = (modifiers: readonly ts.Modifier[] | undefined, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode) => ts.IndexSignatureDeclaration;
+/**
+ * Creates a `ts.IndexSignatureDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare const createIndexSignature: Ts49CreateIndexSignatureFn;
+export {};

package/transform/compiler-cli/src/ngtsc/ts_compatibility/src/ts_cross_version_utils.js

@@ -0,0 +1,86 @@
+"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.createIndexSignature = exports.createFunctionDeclaration = exports.createImportDeclaration = exports.createParameterDeclaration = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+/** Whether the current TypeScript version is after 4.9. */
+const IS_AFTER_TS_49 = isAfterVersion(4, 9);
+/**
+ * Creates a `ts.ParameterDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
+ * We should remove it once we have dropped support for the older versions.
+ */
+exports.createParameterDeclaration = IS_AFTER_TS_49
+    ? typescript_1.default.factory.createParameterDeclaration
+    : (modifiers, dotDotDotToken, name, questionToken, type, initializer) => typescript_1.default.factory.createParameterDeclaration(...splitModifiers(modifiers), dotDotDotToken, name, questionToken, type, initializer);
+/**
+ * Creates a `ts.ImportDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
+ * We should remove it once we have dropped support for the older versions.
+ */
+exports.createImportDeclaration = IS_AFTER_TS_49
+    ? typescript_1.default.factory.createImportDeclaration
+    : (modifiers, importClause, moduleSpecifier, assertClause) => typescript_1.default.factory.createImportDeclaration(undefined, modifiers, importClause, moduleSpecifier, assertClause);
+/**
+ * Creates a `ts.FunctionDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
+ * We should remove it once we have dropped support for the older versions.
+ */
+exports.createFunctionDeclaration = IS_AFTER_TS_49
+    ? typescript_1.default.factory.createFunctionDeclaration
+    : (modifiers, asteriskToken, name, typeParameters, parameters, type, body) => typescript_1.default.factory.createFunctionDeclaration(...splitModifiers(modifiers), asteriskToken, name, typeParameters, parameters, type, body);
+/**
+ * Creates a `ts.IndexSignatureDeclaration` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
+ * We should remove it once we have dropped support for the older versions.
+ */
+exports.createIndexSignature = IS_AFTER_TS_49
+    ? typescript_1.default.factory.createIndexSignature
+    : (modifiers, parameters, type) => typescript_1.default.factory.createIndexSignature(modifiers, parameters, type);
+/**
+ * Splits a `ModifierLike` into two arrays: decorators and modifiers. Used for backwards
+ * compatibility with TS 4.7 and below where most factory functions require separate `decorators`
+ * and `modifiers` arrays.
+ */
+function splitModifiers(allModifiers) {
+    if (!allModifiers) {
+        return [undefined, undefined];
+    }
+    const decorators = [];
+    const modifiers = [];
+    for (const current of allModifiers) {
+        if (typescript_1.default.isDecorator(current)) {
+            decorators.push(current);
+        }
+        else {
+            modifiers.push(current);
+        }
+    }
+    return [
+        decorators.length ? decorators : undefined,
+        modifiers.length ? modifiers : undefined,
+    ];
+}
+/** Checks if the current version of TypeScript is after the specified major/minor versions. */
+function isAfterVersion(targetMajor, targetMinor) {
+    const [major, minor] = typescript_1.default.versionMajorMinor
+        .split('.')
+        .map((part) => parseInt(part));
+    if (major < targetMajor) {
+        return false;
+    }
+    return major === targetMajor ? minor >= targetMinor : true;
+}

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

@@ -1,11 +1,4 @@
-/**
- * @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 * as ts from "typescript";
+import ts from 'typescript';
 export declare function identifierOfNode(decl: ts.Node & {
     name?: ts.Node;
 }): ts.Identifier | null;

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

@@ -1,35 +1,12 @@
 "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]; } });
-}) : (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.identifierOfNode = void 0;
-const ts = __importStar(require("typescript"));
+const typescript_1 = __importDefault(require("typescript"));
 function identifierOfNode(decl) {
-    if (decl.name !== undefined && ts.isIdentifier(decl.name)) {
+    if (decl.name !== undefined && typescript_1.default.isIdentifier(decl.name)) {
         return decl.name;
     }
     else {

package/transform/index.js

@@ -1,7 +1,11 @@
 "use strict";
 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];