static-injector 2.2.1 → 4.0.0

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

@@ -1,11 +1,4 @@
 "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);

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

@@ -209,7 +209,7 @@ export interface ImportedTypeValueReference {
      * When `null` or empty, the `importedName` itself is the symbol being referenced.
      */
     nestedPath: string[] | null;
-    valueDeclaration: DeclarationNode;
+    valueDeclaration: DeclarationNode | null;
 }
 /**
  * A representation for a type value reference that is used when no value is available. This can
@@ -410,6 +410,11 @@ export interface Import {
  * A type that is used to identify a declaration.
  */
 export type DeclarationNode = ts.Declaration;
+export type AmbientImport = {
+    __brand: 'AmbientImport';
+};
+/** Indicates that a declaration is referenced through an ambient type. */
+export declare const AmbientImport: AmbientImport;
 /**
  * The declaration of a symbol, along with information about how it was imported into the
  * application.
@@ -420,7 +425,7 @@ export interface Declaration<T extends ts.Declaration = ts.Declaration> {
      * was imported via an absolute module (even through a chain of re-exports). If the symbol is part
      * of the application and was not imported from an absolute path, this will be `null`.
      */
-    viaModule: string | null;
+    viaModule: string | AmbientImport | null;
     /**
      * TypeScript reference to the declaration itself, if one exists.
      */

package/transform/compiler-cli/src/ngtsc/reflection/src/host.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.ClassMemberKind = exports.isDecoratorIdentifier = void 0;
+exports.AmbientImport = exports.ClassMemberKind = exports.isDecoratorIdentifier = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 function isDecoratorIdentifier(exp) {
     return (typescript_1.default.isIdentifier(exp) ||
@@ -30,3 +30,5 @@ var ClassMemberKind;
     ClassMemberKind[ClassMemberKind["Property"] = 3] = "Property";
     ClassMemberKind[ClassMemberKind["Method"] = 4] = "Method";
 })(ClassMemberKind || (exports.ClassMemberKind = ClassMemberKind = {}));
+/** Indicates that a declaration is referenced through an ambient type. */
+exports.AmbientImport = {};

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

@@ -14,7 +14,7 @@ import { TypeValueReference } from './host';
  * This can return `null` if the `typeNode` is `null`, if it does not refer to a symbol with a value
  * declaration, or if it is not possible to statically understand.
  */
-export declare function typeToValue(typeNode: ts.TypeNode | null, checker: ts.TypeChecker): TypeValueReference;
+export declare function typeToValue(typeNode: ts.TypeNode | null, checker: ts.TypeChecker, isLocalCompilation: boolean): TypeValueReference;
 /**
  * Attempt to extract a `ts.Expression` that's equivalent to a `ts.TypeNode`, as the two have
  * different AST shapes but can reference the same symbols.
@@ -22,3 +22,4 @@ export declare function typeToValue(typeNode: ts.TypeNode | null, checker: ts.Ty
  * This will return `null` if an equivalent expression cannot be constructed.
  */
 export declare function typeNodeToValueExpr(node: ts.TypeNode): ts.Expression | null;
+export declare function entityNameToValue(node: ts.EntityName): ts.Expression | null;

package/transform/compiler-cli/src/ngtsc/reflection/src/type_to_value.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.typeNodeToValueExpr = exports.typeToValue = void 0;
+exports.entityNameToValue = exports.typeNodeToValueExpr = exports.typeToValue = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 /**
  * Potentially convert a `ts.TypeNode` to a `TypeValueReference`, which indicates how to use the
@@ -19,7 +19,7 @@ const typescript_1 = __importDefault(require("typescript"));
  * This can return `null` if the `typeNode` is `null`, if it does not refer to a symbol with a value
  * declaration, or if it is not possible to statically understand.
  */
-function typeToValue(typeNode, checker) {
+function typeToValue(typeNode, checker, isLocalCompilation) {
     // It's not possible to get a value expression if the parameter doesn't even have a type.
     if (typeNode === null) {
         return missingType();
@@ -41,7 +41,17 @@ function typeToValue(typeNode, checker) {
         if (decl.declarations !== undefined && decl.declarations.length > 0) {
             typeOnlyDecl = decl.declarations[0];
         }
-        return noValueDeclaration(typeNode, typeOnlyDecl);
+        // In local compilation mode a declaration is considered invalid only if it is a type related
+        // declaration.
+        if (!isLocalCompilation ||
+            (typeOnlyDecl &&
+                [
+                    typescript_1.default.SyntaxKind.TypeParameter,
+                    typescript_1.default.SyntaxKind.TypeAliasDeclaration,
+                    typescript_1.default.SyntaxKind.InterfaceDeclaration,
+                ].includes(typeOnlyDecl.kind))) {
+            return noValueDeclaration(typeNode, typeOnlyDecl);
+        }
     }
     // The type points to a valid value declaration. Rewrite the TypeReference into an
     // Expression which references the value pointed to by the TypeReference, if possible.
@@ -85,7 +95,7 @@ function typeToValue(typeNode, checker) {
             const moduleName = extractModuleName(firstDecl.parent.parent.parent);
             return {
                 kind: 1 /* TypeValueReferenceKind.IMPORTED */,
-                valueDeclaration: decl.valueDeclaration,
+                valueDeclaration: decl.valueDeclaration ?? null,
                 moduleName,
                 importedName,
                 nestedPath,
@@ -109,7 +119,7 @@ function typeToValue(typeNode, checker) {
             const moduleName = extractModuleName(firstDecl.parent.parent);
             return {
                 kind: 1 /* TypeValueReferenceKind.IMPORTED */,
-                valueDeclaration: decl.valueDeclaration,
+                valueDeclaration: decl.valueDeclaration ?? null,
                 moduleName,
                 importedName,
                 nestedPath,
@@ -252,6 +262,7 @@ function entityNameToValue(node) {
         return null;
     }
 }
+exports.entityNameToValue = entityNameToValue;
 function extractModuleName(node) {
     if (!typescript_1.default.isStringLiteral(node.moduleSpecifier)) {
         throw new Error('not a module specifier');

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

@@ -12,7 +12,8 @@ import { ClassDeclaration, ClassMember, CtorParameter, DeclarationNode, Decorato
  */
 export declare class TypeScriptReflectionHost implements ReflectionHost {
     protected checker: ts.TypeChecker;
-    constructor(checker: ts.TypeChecker);
+    private readonly isLocalCompilation;
+    constructor(checker: ts.TypeChecker, isLocalCompilation?: boolean);
     getDecoratorsOfDeclaration(declaration: DeclarationNode): Decorator[] | null;
     getMembersOfClass(clazz: ClassDeclaration): ClassMember[];
     getConstructorParameters(clazz: ClassDeclaration): CtorParameter[] | null;
@@ -43,10 +44,10 @@ export declare class TypeScriptReflectionHost implements ReflectionHost {
     protected getImportOfNamespacedIdentifier(id: ts.Identifier, namespaceIdentifier: ts.Identifier | null): Import | null;
     private _reflectDecorator;
     private _reflectMember;
+    private _viaModule;
 }
 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`.
+ * Gets the closest ancestor `ImportDeclaration` to a node.
  */
 export declare function getContainingImportDeclaration(node: ts.Node): ts.ImportDeclaration | null;

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

@@ -20,8 +20,10 @@ const util_1 = require("./util");
  */
 class TypeScriptReflectionHost {
     checker;
-    constructor(checker) {
+    isLocalCompilation;
+    constructor(checker, isLocalCompilation = false) {
         this.checker = checker;
+        this.isLocalCompilation = isLocalCompilation;
     }
     getDecoratorsOfDeclaration(declaration) {
         const decorators = typescript_1.default.canHaveDecorators(declaration)
@@ -70,7 +72,7 @@ class TypeScriptReflectionHost {
                     typeNode = childTypeNodes[0];
                 }
             }
-            const typeValueReference = (0, type_to_value_1.typeToValue)(typeNode, this.checker);
+            const typeValueReference = (0, type_to_value_1.typeToValue)(typeNode, this.checker, this.isLocalCompilation);
             return {
                 name,
                 nameNode: node.name,
@@ -280,6 +282,18 @@ class TypeScriptReflectionHost {
             isStatic,
         };
     }
+    _viaModule(declaration, originalId, importInfo) {
+        if (importInfo === null &&
+            originalId !== null &&
+            declaration.getSourceFile() !== originalId.getSourceFile()) {
+            return host_1.AmbientImport;
+        }
+        return importInfo !== null &&
+            importInfo.from !== null &&
+            !importInfo.from.startsWith('.')
+            ? importInfo.from
+            : null;
+    }
 }
 exports.TypeScriptReflectionHost = TypeScriptReflectionHost;
 function reflectObjectLiteral(node) {
@@ -353,15 +367,17 @@ function getFarLeftIdentifier(propertyAccess) {
         : null;
 }
 /**
- * Return the ImportDeclaration for the given `node` if it is either an `ImportSpecifier` or a
- * `NamespaceImport`. If not return `null`.
+ * Gets the closest ancestor `ImportDeclaration` to a node.
  */
 function getContainingImportDeclaration(node) {
-    return typescript_1.default.isImportSpecifier(node)
-        ? node.parent.parent.parent
-        : typescript_1.default.isNamespaceImport(node)
-            ? node.parent.parent
-            : null;
+    let parent = node.parent;
+    while (parent && !typescript_1.default.isSourceFile(parent)) {
+        if (typescript_1.default.isImportDeclaration(parent)) {
+            return parent;
+        }
+        parent = parent.parent;
+    }
+    return null;
 }
 exports.getContainingImportDeclaration = getContainingImportDeclaration;
 /**

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

@@ -1,9 +1,2 @@
-/**
- * @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/api';
 export * from './src/utils';

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

@@ -1,11 +1,4 @@
 "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);

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

@@ -8,6 +8,24 @@
 import { Expression, Statement, Type } from 'static-injector/transform/compiler';
 import ts from 'typescript';
 import { ClassDeclaration, Decorator } from '../../reflection';
+/**
+ * Specifies the compilation mode that is used for the compilation.
+ */
+export declare enum CompilationMode {
+    /**
+     * Generates fully AOT compiled code using Ivy instructions.
+     */
+    FULL = 0,
+    /**
+     * Generates code using a stable, but intermediate format suitable to be published to NPM.
+     */
+    PARTIAL = 1,
+    /**
+     * Generates code based on each individual source file without using its
+     * dependencies (suitable for local dev edit/refresh workflow).
+     */
+    LOCAL = 2
+}
 /**
  * Provides the interface between a decorator compiler from @angular/compiler and the Typescript
  * compiler/transform.

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

@@ -7,3 +7,23 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompilationMode = void 0;
+/**
+ * Specifies the compilation mode that is used for the compilation.
+ */
+var CompilationMode;
+(function (CompilationMode) {
+    /**
+     * Generates fully AOT compiled code using Ivy instructions.
+     */
+    CompilationMode[CompilationMode["FULL"] = 0] = "FULL";
+    /**
+     * Generates code using a stable, but intermediate format suitable to be published to NPM.
+     */
+    CompilationMode[CompilationMode["PARTIAL"] = 1] = "PARTIAL";
+    /**
+     * Generates code based on each individual source file without using its
+     * dependencies (suitable for local dev edit/refresh workflow).
+     */
+    CompilationMode[CompilationMode["LOCAL"] = 2] = "LOCAL";
+})(CompilationMode || (exports.CompilationMode = CompilationMode = {}));

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

@@ -12,4 +12,4 @@ import { ImportManager } from '../../translator';
  * and before the module body.
  * Can optionally add extra statements (e.g. new constants) before the body as well.
  */
-export declare function addImports(importManager: ImportManager, sf: ts.SourceFile, extraStatements?: ts.Statement[]): ts.SourceFile;
+export declare function addImports(factory: ts.NodeFactory | undefined, importManager: ImportManager, sf: ts.SourceFile, extraStatements?: ts.Statement[]): ts.SourceFile;

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

@@ -17,29 +17,13 @@ const typescript_1 = __importDefault(require("typescript"));
  * and before the module body.
  * Can optionally add extra statements (e.g. new constants) before the body as well.
  */
-function addImports(importManager, sf, extraStatements = []) {
+function addImports(factory = typescript_1.default.factory, importManager, sf, extraStatements = []) {
     // Generate the import statements to prepend.
-    const addedImports = importManager.getAllImports(sf.fileName).map((i) => {
-        const qualifier = typescript_1.default.factory.createIdentifier(i.qualifier.text);
-        const importClause = typescript_1.default.factory.createImportClause(
-        /* isTypeOnly */ false, 
-        /* name */ undefined, 
-        /* namedBindings */ typescript_1.default.factory.createNamespaceImport(qualifier));
-        const decl = typescript_1.default.factory.createImportDeclaration(
-        /* modifiers */ undefined, 
-        /* importClause */ importClause, 
-        /* moduleSpecifier */ typescript_1.default.factory.createStringLiteral(i.specifier));
-        // Set the qualifier's original TS node to the `ts.ImportDeclaration`. This allows downstream
-        // transforms such as tsickle to properly process references to this import.
-        //
-        // This operation is load-bearing in g3 as some imported modules contain special metadata
-        // generated by clutz, which tsickle uses to transform imports and references to those imports.
-        //
-        // TODO(alxhub): add a test for this when tsickle is updated externally to depend on this
-        // behavior.
-        typescript_1.default.setOriginalNode(i.qualifier, decl);
-        return decl;
-    });
+    const addedImports = importManager
+        .getAllImports(sf.fileName)
+        .map((i) => i.qualifier !== null
+        ? createNamespaceImportDecl(i, factory)
+        : createSideEffectImportDecl(i, factory));
     // Filter out the existing imports and the source file body. All new statements
     // will be inserted between them.
     const existingImports = sf.statements.filter((stmt) => isImportStatement(stmt));
@@ -49,8 +33,8 @@ function addImports(importManager, sf, extraStatements = []) {
         // If we prepend imports, we also prepend NotEmittedStatement to use it as an anchor
         // for @fileoverview Closure annotation. If there is no @fileoverview annotations, this
         // statement would be a noop.
-        const fileoverviewAnchorStmt = typescript_1.default.factory.createNotEmittedStatement(sf);
-        return typescript_1.default.factory.updateSourceFile(sf, typescript_1.default.factory.createNodeArray([
+        const fileoverviewAnchorStmt = factory.createNotEmittedStatement(sf);
+        return factory.updateSourceFile(sf, factory.createNodeArray([
             fileoverviewAnchorStmt,
             ...existingImports,
             ...addedImports,
@@ -61,6 +45,33 @@ function addImports(importManager, sf, extraStatements = []) {
     return sf;
 }
 exports.addImports = addImports;
+function createNamespaceImportDecl(i, factory) {
+    const qualifier = factory.createIdentifier(i.qualifier.text);
+    const importClause = factory.createImportClause(
+    /* isTypeOnly */ false, 
+    /* name */ undefined, 
+    /* namedBindings */ factory.createNamespaceImport(qualifier));
+    const decl = factory.createImportDeclaration(
+    /* modifiers */ undefined, 
+    /* importClause */ importClause, 
+    /* moduleSpecifier */ factory.createStringLiteral(i.specifier));
+    // Set the qualifier's original TS node to the `ts.ImportDeclaration`. This allows downstream
+    // transforms such as tsickle to properly process references to this import.
+    //
+    // This operation is load-bearing in g3 as some imported modules contain special metadata
+    // generated by clutz, which tsickle uses to transform imports and references to those imports.
+    //
+    // TODO(alxhub): add a test for this when tsickle is updated externally to depend on this
+    // behavior.
+    typescript_1.default.setOriginalNode(i.qualifier, decl);
+    return decl;
+}
+function createSideEffectImportDecl(i, factory) {
+    return factory.createImportDeclaration(
+    /* modifiers */ undefined, 
+    /* importClause */ undefined, 
+    /* moduleSpecifier */ typescript_1.default.factory.createStringLiteral(i.specifier));
+}
 function isImportStatement(stmt) {
     return (typescript_1.default.isImportDeclaration(stmt) ||
         typescript_1.default.isImportEqualsDeclaration(stmt) ||

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

@@ -1,10 +1,3 @@
-/**
- * @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/context';
 export * from './src/translator';
 export * from './src/typescript_ast_factory';

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

@@ -1,11 +1,4 @@
 "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);

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

@@ -93,6 +93,14 @@ 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;
+    /**
+     * Create an expression that represents an arrow function
+     * (e.g. `(param1, param2) => body`).
+     *
+     * @param parameters the names of the function's parameters.
+     * @param body an expression or block of statements that are the body of the function.
+     */
+    createArrowFunctionExpression(parameters: string[], body: TExpression | TStatement): TExpression;
     /**
      * Creates an expression that represents a dynamic import
      * (e.g. `import('./some/path')`)
@@ -213,7 +221,7 @@ export type UnaryOperator = '+' | '-' | '!';
 /**
  * The binary operators supported by the `AstFactory`.
  */
-export type BinaryOperator = '&&' | '>' | '>=' | '&' | '/' | '==' | '===' | '<' | '<=' | '-' | '%' | '*' | '!=' | '!==' | '||' | '+' | '??';
+export type BinaryOperator = '&&' | '>' | '>=' | '&' | '|' | '/' | '==' | '===' | '<' | '<=' | '-' | '%' | '*' | '!=' | '!==' | '||' | '+' | '??';
 /**
  * The original location of the start or end of a node created by the `AstFactory`.
  */

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

@@ -9,21 +9,39 @@ import ts from 'typescript';
 import { ImportRewriter } from '../../imports';
 import { ImportGenerator, NamedImport } from './api/import_generator';
 /**
- * Information about an import that has been added to a module.
+ * Information about a namespace import that has been added to a module.
  */
-export interface Import {
+export interface NamespaceImport {
     /** The name of the module that has been imported. */
     specifier: string;
     /** The `ts.Identifier` by which the imported module is known. */
     qualifier: ts.Identifier;
 }
+/**
+ * Information about a side effect import that has been added to a module.
+ */
+export interface SideEffectImport {
+    /** The name of the module that has been imported. */
+    specifier: string;
+    /**
+     * The qualifier of a side effect import is always non-existent, and that can be used to check
+     * whether the import is side effect or not.
+     */
+    qualifier: null;
+}
+/**
+ * Information about an import that has been added to a module.
+ */
+export type Import = NamespaceImport | SideEffectImport;
 export declare class ImportManager implements ImportGenerator<ts.Identifier> {
     protected rewriter: ImportRewriter;
     private prefix;
+    private factory;
     private specifierToIdentifier;
     private nextIndex;
-    constructor(rewriter?: ImportRewriter, prefix?: string);
+    constructor(rewriter?: ImportRewriter, prefix?: string, factory?: ts.NodeFactory);
     generateNamespaceImport(moduleName: string): ts.Identifier;
     generateNamedImport(moduleName: string, originalSymbol: string): NamedImport<ts.Identifier>;
+    generateSideEffectImport(moduleName: string): void;
     getAllImports(contextPath: string): Import[];
 }

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

@@ -16,15 +16,20 @@ const imports_1 = require("../../imports");
 class ImportManager {
     rewriter;
     prefix;
+    factory;
     specifierToIdentifier = new Map();
     nextIndex = 0;
-    constructor(rewriter = new imports_1.NoopImportRewriter(), prefix = 'i') {
+    constructor(rewriter = new imports_1.NoopImportRewriter(), prefix = 'i', factory = typescript_1.default.factory) {
         this.rewriter = rewriter;
         this.prefix = prefix;
+        this.factory = factory;
     }
     generateNamespaceImport(moduleName) {
-        if (!this.specifierToIdentifier.has(moduleName)) {
-            this.specifierToIdentifier.set(moduleName, typescript_1.default.factory.createIdentifier(`${this.prefix}${this.nextIndex++}`));
+        // The case `specifierToIdentifier.get(moduleName) === null` is also considered to overwrite the
+        // side effect import since namedspace import is enough.
+        if (!this.specifierToIdentifier.has(moduleName) ||
+            this.specifierToIdentifier.get(moduleName) === null) {
+            this.specifierToIdentifier.set(moduleName, this.factory.createIdentifier(`${this.prefix}${this.nextIndex++}`));
         }
         return this.specifierToIdentifier.get(moduleName);
     }
@@ -41,6 +46,11 @@ class ImportManager {
         const moduleImport = this.generateNamespaceImport(moduleName);
         return { moduleImport, symbol };
     }
+    generateSideEffectImport(moduleName) {
+        if (!this.specifierToIdentifier.has(moduleName)) {
+            this.specifierToIdentifier.set(moduleName, null);
+        }
+    }
     getAllImports(contextPath) {
         const imports = [];
         for (const [originalSpecifier, qualifier] of this.specifierToIdentifier) {

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

@@ -40,6 +40,7 @@ export declare class ExpressionTranslatorVisitor<TStatement, TExpression> implem
     visitDynamicImportExpr(ast: o.DynamicImportExpr, context: any): TExpression;
     visitNotExpr(ast: o.NotExpr, context: Context): TExpression;
     visitFunctionExpr(ast: o.FunctionExpr, context: Context): TExpression;
+    visitArrowFunctionExpr(ast: o.ArrowFunctionExpr, context: any): TExpression;
     visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, context: Context): TExpression;
     visitReadPropExpr(ast: o.ReadPropExpr, context: Context): TExpression;
     visitReadKeyExpr(ast: o.ReadKeyExpr, context: Context): TExpression;

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

@@ -41,6 +41,7 @@ const BINARY_OPERATORS = new Map([
     [o.BinaryOperator.Bigger, '>'],
     [o.BinaryOperator.BiggerEquals, '>='],
     [o.BinaryOperator.BitwiseAnd, '&'],
+    [o.BinaryOperator.BitwiseOr, '|'],
     [o.BinaryOperator.Divide, '/'],
     [o.BinaryOperator.Equals, '=='],
     [o.BinaryOperator.Identical, '==='],
@@ -186,6 +187,11 @@ class ExpressionTranslatorVisitor {
     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]}`);

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

@@ -0,0 +1,12 @@
+/*!
+ * @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

@@ -0,0 +1,27 @@
+"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

@@ -26,6 +26,7 @@ export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts
     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;

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

@@ -12,6 +12,7 @@ exports.attachComments = exports.createTemplateTail = exports.createTemplateMidd
  * 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.
@@ -36,6 +37,7 @@ const BINARY_OPERATORS = {
     '>': 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,
@@ -106,6 +108,12 @@ class TypeScriptAstFactory {
         }
         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);
@@ -121,7 +129,7 @@ class TypeScriptAstFactory {
             return value ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createFalse();
         }
         else if (typeof value === 'number') {
-            return typescript_1.default.factory.createNumericLiteral(value);
+            return (0, ts_util_1.tsNumericExpression)(value);
         }
         else {
             return typescript_1.default.factory.createStringLiteral(value);

package/transform/index.d.ts

@@ -1 +1 @@
-export * from "./injectable-transform";
+export * from './injectable-transform';