static-injector 4.0.2 → 5.0.0-alpha.0

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

@@ -1,270 +0,0 @@
-"use strict";
-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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpressionTranslatorVisitor = void 0;
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-const o = __importStar(require("static-injector/transform/compiler"));
-const UNARY_OPERATORS = new Map([
-    [o.UnaryOperator.Minus, '-'],
-    [o.UnaryOperator.Plus, '+'],
-]);
-const BINARY_OPERATORS = new Map([
-    [o.BinaryOperator.And, '&&'],
-    [o.BinaryOperator.Bigger, '>'],
-    [o.BinaryOperator.BiggerEquals, '>='],
-    [o.BinaryOperator.BitwiseAnd, '&'],
-    [o.BinaryOperator.BitwiseOr, '|'],
-    [o.BinaryOperator.Divide, '/'],
-    [o.BinaryOperator.Equals, '=='],
-    [o.BinaryOperator.Identical, '==='],
-    [o.BinaryOperator.Lower, '<'],
-    [o.BinaryOperator.LowerEquals, '<='],
-    [o.BinaryOperator.Minus, '-'],
-    [o.BinaryOperator.Modulo, '%'],
-    [o.BinaryOperator.Multiply, '*'],
-    [o.BinaryOperator.NotEquals, '!='],
-    [o.BinaryOperator.NotIdentical, '!=='],
-    [o.BinaryOperator.Or, '||'],
-    [o.BinaryOperator.Plus, '+'],
-    [o.BinaryOperator.NullishCoalesce, '??'],
-]);
-class ExpressionTranslatorVisitor {
-    factory;
-    imports;
-    downlevelTaggedTemplates;
-    downlevelVariableDeclarations;
-    recordWrappedNode;
-    constructor(factory, imports, options) {
-        this.factory = factory;
-        this.imports = imports;
-        this.downlevelTaggedTemplates = options.downlevelTaggedTemplates === true;
-        this.downlevelVariableDeclarations =
-            options.downlevelVariableDeclarations === true;
-        this.recordWrappedNode = options.recordWrappedNode || (() => { });
-    }
-    visitDeclareVarStmt(stmt, context) {
-        const varType = this.downlevelVariableDeclarations
-            ? 'var'
-            : stmt.hasModifier(o.StmtModifier.Final)
-                ? 'const'
-                : 'let';
-        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);
-    }
-    visitExpressionStmt(stmt, context) {
-        return this.attachComments(this.factory.createExpressionStatement(stmt.expr.visitExpression(this, context.withStatementMode)), stmt.leadingComments);
-    }
-    visitReturnStmt(stmt, context) {
-        return this.attachComments(this.factory.createReturnStatement(stmt.value.visitExpression(this, context.withExpressionMode)), stmt.leadingComments);
-    }
-    visitIfStmt(stmt, context) {
-        return this.attachComments(this.factory.createIfStatement(stmt.condition.visitExpression(this, context), this.factory.createBlock(this.visitStatements(stmt.trueCase, context.withStatementMode)), stmt.falseCase.length > 0
-            ? this.factory.createBlock(this.visitStatements(stmt.falseCase, context.withStatementMode))
-            : null), stmt.leadingComments);
-    }
-    visitReadVarExpr(ast, _context) {
-        const identifier = this.factory.createIdentifier(ast.name);
-        this.setSourceMapRange(identifier, ast.sourceSpan);
-        return identifier;
-    }
-    visitWriteVarExpr(expr, context) {
-        const assignment = this.factory.createAssignment(this.setSourceMapRange(this.factory.createIdentifier(expr.name), expr.sourceSpan), expr.value.visitExpression(this, context));
-        return context.isStatement
-            ? assignment
-            : this.factory.createParenthesizedExpression(assignment);
-    }
-    visitWriteKeyExpr(expr, context) {
-        const exprContext = context.withExpressionMode;
-        const target = this.factory.createElementAccess(expr.receiver.visitExpression(this, exprContext), expr.index.visitExpression(this, exprContext));
-        const assignment = this.factory.createAssignment(target, expr.value.visitExpression(this, exprContext));
-        return context.isStatement
-            ? assignment
-            : this.factory.createParenthesizedExpression(assignment);
-    }
-    visitWritePropExpr(expr, context) {
-        const target = this.factory.createPropertyAccess(expr.receiver.visitExpression(this, context), expr.name);
-        return this.factory.createAssignment(target, expr.value.visitExpression(this, context));
-    }
-    visitInvokeFunctionExpr(ast, context) {
-        return this.setSourceMapRange(this.factory.createCallExpression(ast.fn.visitExpression(this, context), ast.args.map((arg) => arg.visitExpression(this, context)), ast.pure), ast.sourceSpan);
-    }
-    visitInstantiateExpr(ast, context) {
-        return this.factory.createNewExpression(ast.classExpr.visitExpression(this, context), ast.args.map((arg) => arg.visitExpression(this, context)));
-    }
-    visitLiteralExpr(ast, _context) {
-        return this.setSourceMapRange(this.factory.createLiteral(ast.value), ast.sourceSpan);
-    }
-    visitExternalExpr(ast, _context) {
-        if (ast.value.name === null) {
-            if (ast.value.moduleName === null) {
-                throw new Error('Invalid import without name nor moduleName');
-            }
-            return this.imports.generateNamespaceImport(ast.value.moduleName);
-        }
-        // If a moduleName is specified, this is a normal import. If there's no module name, it's a
-        // reference to a global/ambient symbol.
-        if (ast.value.moduleName !== null) {
-            // This is a normal import. Find the imported module.
-            const { moduleImport, symbol } = this.imports.generateNamedImport(ast.value.moduleName, ast.value.name);
-            if (moduleImport === null) {
-                // The symbol was ambient after all.
-                return this.factory.createIdentifier(symbol);
-            }
-            else {
-                return this.factory.createPropertyAccess(moduleImport, symbol);
-            }
-        }
-        else {
-            // The symbol is ambient, so just reference it.
-            return this.factory.createIdentifier(ast.value.name);
-        }
-    }
-    visitConditionalExpr(ast, context) {
-        let cond = ast.condition.visitExpression(this, context);
-        // Ordinarily the ternary operator is right-associative. The following are equivalent:
-        //   `a ? b : c ? d : e` => `a ? b : (c ? d : e)`
-        //
-        // However, occasionally Angular needs to produce a left-associative conditional, such as in
-        // the case of a null-safe navigation production: `{{a?.b ? c : d}}`. This template produces
-        // a ternary of the form:
-        //   `a == null ? null : rest of expression`
-        // If the rest of the expression is also a ternary though, this would produce the form:
-        //   `a == null ? null : a.b ? c : d`
-        // which, if left as right-associative, would be incorrectly associated as:
-        //   `a == null ? null : (a.b ? c : d)`
-        //
-        // In such cases, the left-associativity needs to be enforced with parentheses:
-        //   `(a == null ? null : a.b) ? c : d`
-        //
-        // Such parentheses could always be included in the condition (guaranteeing correct behavior) in
-        // all cases, but this has a code size cost. Instead, parentheses are added only when a
-        // conditional expression is directly used as the condition of another.
-        //
-        // TODO(alxhub): investigate better logic for precendence of conditional operators
-        if (ast.condition instanceof o.ConditionalExpr) {
-            // The condition of this ternary needs to be wrapped in parentheses to maintain
-            // left-associativity.
-            cond = this.factory.createParenthesizedExpression(cond);
-        }
-        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) {
-        return this.factory.createFunctionExpression(ast.name ?? null, ast.params.map((param) => param.name), this.factory.createBlock(this.visitStatements(ast.statements, context)));
-    }
-    visitArrowFunctionExpr(ast, context) {
-        return this.factory.createArrowFunctionExpression(ast.params.map((param) => param.name), Array.isArray(ast.body)
-            ? this.factory.createBlock(this.visitStatements(ast.body, context))
-            : ast.body.visitExpression(this, context));
-    }
-    visitBinaryOperatorExpr(ast, context) {
-        if (!BINARY_OPERATORS.has(ast.operator)) {
-            throw new Error(`Unknown binary operator: ${o.BinaryOperator[ast.operator]}`);
-        }
-        return this.factory.createBinaryExpression(ast.lhs.visitExpression(this, context), BINARY_OPERATORS.get(ast.operator), ast.rhs.visitExpression(this, context));
-    }
-    visitReadPropExpr(ast, context) {
-        return this.factory.createPropertyAccess(ast.receiver.visitExpression(this, context), ast.name);
-    }
-    visitReadKeyExpr(ast, context) {
-        return this.factory.createElementAccess(ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context));
-    }
-    visitLiteralArrayExpr(ast, context) {
-        return this.factory.createArrayLiteral(ast.entries.map((expr) => this.setSourceMapRange(expr.visitExpression(this, context), ast.sourceSpan)));
-    }
-    visitLiteralMapExpr(ast, context) {
-        const properties = ast.entries.map((entry) => {
-            return {
-                propertyName: entry.key,
-                quoted: entry.quoted,
-                value: entry.value.visitExpression(this, context),
-            };
-        });
-        return this.setSourceMapRange(this.factory.createObjectLiteral(properties), ast.sourceSpan);
-    }
-    visitCommaExpr(ast, context) {
-        throw new Error('Method not implemented.');
-    }
-    visitWrappedNodeExpr(ast, _context) {
-        this.recordWrappedNode(ast);
-        return ast.node;
-    }
-    visitTypeofExpr(ast, context) {
-        return this.factory.createTypeOfExpression(ast.expr.visitExpression(this, context));
-    }
-    visitUnaryOperatorExpr(ast, context) {
-        if (!UNARY_OPERATORS.has(ast.operator)) {
-            throw new Error(`Unknown unary operator: ${o.UnaryOperator[ast.operator]}`);
-        }
-        return this.factory.createUnaryExpression(UNARY_OPERATORS.get(ast.operator), ast.expr.visitExpression(this, context));
-    }
-    visitStatements(statements, context) {
-        return statements
-            .map((stmt) => stmt.visitStatement(this, context))
-            .filter((stmt) => stmt !== undefined);
-    }
-    setSourceMapRange(ast, span) {
-        return this.factory.setSourceMapRange(ast, createRange(span));
-    }
-    attachComments(statement, leadingComments) {
-        if (leadingComments !== undefined) {
-            this.factory.attachComments(statement, leadingComments);
-        }
-        return statement;
-    }
-}
-exports.ExpressionTranslatorVisitor = ExpressionTranslatorVisitor;
-/**
- * Convert an OutputAST source-span into a range that can be used by the AST factories.
- */
-function createRange(span) {
-    if (span === null) {
-        return null;
-    }
-    const { start, end } = span;
-    const { url, content } = start.file;
-    if (!url) {
-        return null;
-    }
-    return {
-        url,
-        content,
-        start: { offset: start.offset, line: start.line, column: start.col },
-        end: { offset: end.offset, line: end.line, column: end.col },
-    };
-}

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

@@ -1,12 +0,0 @@
-/*!
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import ts from 'typescript';
-/**
- * Creates a TypeScript node representing a numeric value.
- */
-export declare function tsNumericExpression(value: number): ts.NumericLiteral | ts.PrefixUnaryExpression;

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

@@ -1,27 +0,0 @@
-"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.tsNumericExpression = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-/**
- * Creates a TypeScript node representing a numeric value.
- */
-function tsNumericExpression(value) {
-    // As of TypeScript 5.3 negative numbers are represented as `prefixUnaryOperator` and passing a
-    // negative number (even as a string) into `createNumericLiteral` will result in an error.
-    if (value < 0) {
-        const operand = typescript_1.default.factory.createNumericLiteral(Math.abs(value));
-        return typescript_1.default.factory.createPrefixUnaryExpression(typescript_1.default.SyntaxKind.MinusToken, operand);
-    }
-    return typescript_1.default.factory.createNumericLiteral(value);
-}
-exports.tsNumericExpression = tsNumericExpression;

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

@@ -1,53 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import ts from 'typescript';
-import { AstFactory, BinaryOperator, LeadingComment, ObjectLiteralProperty, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from './api/ast_factory';
-/**
- * A TypeScript flavoured implementation of the AstFactory.
- */
-export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts.Expression> {
-    private annotateForClosureCompiler;
-    private externalSourceFiles;
-    constructor(annotateForClosureCompiler: boolean);
-    attachComments: typeof attachComments;
-    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;
-    createCallExpression(callee: ts.Expression, args: ts.Expression[], pure: boolean): ts.Expression;
-    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;
-    createArrowFunctionExpression(parameters: string[], body: ts.Statement | ts.Expression): ts.Expression;
-    createIdentifier: (text: string) => ts.Identifier;
-    createIfStatement(condition: ts.Expression, thenStatement: ts.Statement, elseStatement: ts.Statement | null): ts.Statement;
-    createLiteral(value: string | number | boolean | null | undefined): ts.Expression;
-    createNewExpression(expression: ts.Expression, args: ts.Expression[]): ts.Expression;
-    createObjectLiteral(properties: ObjectLiteralProperty<ts.Expression>[]): ts.Expression;
-    createParenthesizedExpression: (expression: ts.Expression) => ts.ParenthesizedExpression;
-    createPropertyAccess: (expression: ts.Expression, name: string | ts.MemberName) => ts.PropertyAccessExpression;
-    createReturnStatement(expression: ts.Expression | null): ts.Statement;
-    createTaggedTemplate(tag: ts.Expression, template: TemplateLiteral<ts.Expression>): ts.Expression;
-    createThrowStatement: (expression: ts.Expression) => ts.ThrowStatement;
-    createTypeOfExpression: (expression: ts.Expression) => ts.TypeOfExpression;
-    createUnaryExpression(operator: UnaryOperator, operand: ts.Expression): ts.Expression;
-    createVariableDeclaration(variableName: string, initializer: ts.Expression | null, type: VariableDeclarationType): ts.Statement;
-    setSourceMapRange<T extends ts.Node>(node: T, sourceMapRange: SourceMapRange | null): T;
-}
-export declare function createTemplateMiddle(cooked: string, raw: string): ts.TemplateMiddle;
-export declare function createTemplateTail(cooked: string, raw: string): ts.TemplateTail;
-/**
- * Attach the given `leadingComments` to the `statement` node.
- *
- * @param statement The statement that will have comments attached.
- * @param leadingComments The comments to attach to the statement.
- */
-export declare function attachComments(statement: ts.Statement, leadingComments: LeadingComment[]): void;

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

@@ -1,250 +0,0 @@
-"use strict";
-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;
-/**
- * @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
- */
-const typescript_1 = __importDefault(require("typescript"));
-const ts_util_1 = require("./ts_util");
-/**
- * Different optimizers use different annotations on a function or method call to indicate its pure
- * status.
- */
-var PureAnnotation;
-(function (PureAnnotation) {
-    /**
-     * Closure's annotation for purity is `@pureOrBreakMyCode`, but this needs to be in a semantic
-     * (jsdoc) enabled comment. Thus, the actual comment text for Closure must include the `*` that
-     * turns a `/*` comment into a `/**` comment, as well as surrounding whitespace.
-     */
-    PureAnnotation["CLOSURE"] = "* @pureOrBreakMyCode ";
-    PureAnnotation["TERSER"] = "@__PURE__";
-})(PureAnnotation || (PureAnnotation = {}));
-const UNARY_OPERATORS = {
-    '+': typescript_1.default.SyntaxKind.PlusToken,
-    '-': typescript_1.default.SyntaxKind.MinusToken,
-    '!': typescript_1.default.SyntaxKind.ExclamationToken,
-};
-const BINARY_OPERATORS = {
-    '&&': typescript_1.default.SyntaxKind.AmpersandAmpersandToken,
-    '>': typescript_1.default.SyntaxKind.GreaterThanToken,
-    '>=': typescript_1.default.SyntaxKind.GreaterThanEqualsToken,
-    '&': typescript_1.default.SyntaxKind.AmpersandToken,
-    '|': typescript_1.default.SyntaxKind.BarToken,
-    '/': 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: typescript_1.default.NodeFlags.Const,
-    let: typescript_1.default.NodeFlags.Let,
-    var: typescript_1.default.NodeFlags.None,
-};
-/**
- * A TypeScript flavoured implementation of the AstFactory.
- */
-class TypeScriptAstFactory {
-    annotateForClosureCompiler;
-    externalSourceFiles = new Map();
-    constructor(annotateForClosureCompiler) {
-        this.annotateForClosureCompiler = annotateForClosureCompiler;
-    }
-    attachComments = attachComments;
-    createArrayLiteral = typescript_1.default.factory.createArrayLiteralExpression;
-    createAssignment(target, value) {
-        return typescript_1.default.factory.createBinaryExpression(target, typescript_1.default.SyntaxKind.EqualsToken, value);
-    }
-    createBinaryExpression(leftOperand, operator, rightOperand) {
-        return typescript_1.default.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS[operator], rightOperand);
-    }
-    createBlock(body) {
-        return typescript_1.default.factory.createBlock(body);
-    }
-    createCallExpression(callee, args, pure) {
-        const call = typescript_1.default.factory.createCallExpression(callee, undefined, args);
-        if (pure) {
-            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);
-    }
-    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 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 ?? undefined, undefined, parameters.map((param) => typescript_1.default.factory.createParameterDeclaration(undefined, undefined, param)), undefined, body);
-    }
-    createArrowFunctionExpression(parameters, body) {
-        if (typescript_1.default.isStatement(body) && !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.createArrowFunction(undefined, undefined, parameters.map((param) => typescript_1.default.factory.createParameterDeclaration(undefined, undefined, param)), undefined, undefined, body);
-    }
-    createIdentifier = typescript_1.default.factory.createIdentifier;
-    createIfStatement(condition, thenStatement, elseStatement) {
-        return typescript_1.default.factory.createIfStatement(condition, thenStatement, elseStatement ?? undefined);
-    }
-    createLiteral(value) {
-        if (value === undefined) {
-            return typescript_1.default.factory.createIdentifier('undefined');
-        }
-        else if (value === null) {
-            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 (0, ts_util_1.tsNumericExpression)(value);
-        }
-        else {
-            return typescript_1.default.factory.createStringLiteral(value);
-        }
-    }
-    createNewExpression(expression, args) {
-        return typescript_1.default.factory.createNewExpression(expression, undefined, args);
-    }
-    createObjectLiteral(properties) {
-        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)));
-    }
-    createParenthesizedExpression = typescript_1.default.factory.createParenthesizedExpression;
-    createPropertyAccess = typescript_1.default.factory.createPropertyAccessExpression;
-    createReturnStatement(expression) {
-        return typescript_1.default.factory.createReturnStatement(expression ?? undefined);
-    }
-    createTaggedTemplate(tag, template) {
-        let templateLiteral;
-        const length = template.elements.length;
-        const head = template.elements[0];
-        if (length === 1) {
-            templateLiteral = typescript_1.default.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
-        }
-        else {
-            const spans = [];
-            // Create the middle parts
-            for (let i = 1; i < length - 1; i++) {
-                const { cooked, raw, range } = template.elements[i];
-                const middle = createTemplateMiddle(cooked, raw);
-                if (range !== null) {
-                    this.setSourceMapRange(middle, range);
-                }
-                spans.push(typescript_1.default.factory.createTemplateSpan(template.expressions[i - 1], middle));
-            }
-            // Create the tail part
-            const resolvedExpression = template.expressions[length - 2];
-            const templatePart = template.elements[length - 1];
-            const templateTail = createTemplateTail(templatePart.cooked, templatePart.raw);
-            if (templatePart.range !== null) {
-                this.setSourceMapRange(templateTail, templatePart.range);
-            }
-            spans.push(typescript_1.default.factory.createTemplateSpan(resolvedExpression, templateTail));
-            // Put it all together
-            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 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 ?? undefined),
-        ], VAR_TYPES[type]));
-    }
-    setSourceMapRange(node, sourceMapRange) {
-        if (sourceMapRange === null) {
-            return node;
-        }
-        const url = sourceMapRange.url;
-        if (!this.externalSourceFiles.has(url)) {
-            this.externalSourceFiles.set(url, typescript_1.default.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
-        }
-        const source = this.externalSourceFiles.get(url);
-        typescript_1.default.setSourceMapRange(node, {
-            pos: sourceMapRange.start.offset,
-            end: sourceMapRange.end.offset,
-            source,
-        });
-        return node;
-    }
-}
-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 = 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 = typescript_1.default.factory.createTemplateHead(cooked, raw);
-    node.kind = typescript_1.default.SyntaxKind.TemplateTail;
-    return node;
-}
-exports.createTemplateTail = createTemplateTail;
-/**
- * Attach the given `leadingComments` to the `statement` node.
- *
- * @param statement The statement that will have comments attached.
- * @param leadingComments The comments to attach to the statement.
- */
-function attachComments(statement, leadingComments) {
-    for (const comment of leadingComments) {
-        const commentKind = comment.multiline
-            ? typescript_1.default.SyntaxKind.MultiLineCommentTrivia
-            : typescript_1.default.SyntaxKind.SingleLineCommentTrivia;
-        if (comment.multiline) {
-            typescript_1.default.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
-        }
-        else {
-            for (const line of comment.toString().split('\n')) {
-                typescript_1.default.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
-            }
-        }
-    }
-}
-exports.attachComments = attachComments;

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

@@ -1,13 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-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/translator/src/typescript_translator.js

@@ -1,21 +0,0 @@
-"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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateStatement = exports.translateExpression = void 0;
-const context_1 = require("./context");
-const translator_1 = require("./translator");
-const typescript_ast_factory_1 = require("./typescript_ast_factory");
-function translateExpression(expression, imports, options = {}) {
-    return expression.visitExpression(new translator_1.ExpressionTranslatorVisitor(new typescript_ast_factory_1.TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, options), new context_1.Context(false));
-}
-exports.translateExpression = translateExpression;
-function translateStatement(statement, imports, options = {}) {
-    return statement.visitStatement(new translator_1.ExpressionTranslatorVisitor(new typescript_ast_factory_1.TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, options), new context_1.Context(true));
-}
-exports.translateStatement = translateStatement;

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

@@ -1,8 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export * from './src/ts_cross_version_utils';