2508 lines
98 KiB
JavaScript
Executable file
2508 lines
98 KiB
JavaScript
Executable file
|
|
import {createRequire as __cjsCompatRequire} from 'module';
|
|
const require = __cjsCompatRequire(import.meta.url);
|
|
|
|
import {
|
|
LogicalProjectPath,
|
|
absoluteFrom,
|
|
absoluteFromSourceFile,
|
|
dirname,
|
|
getFileSystem,
|
|
relative,
|
|
resolve,
|
|
stripExtension,
|
|
toRelativeImport
|
|
} from "./chunk-UM6JO3VZ.js";
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
|
|
import ts4 from "typescript";
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/host.mjs
|
|
import ts from "typescript";
|
|
function isDecoratorIdentifier(exp) {
|
|
return ts.isIdentifier(exp) || ts.isPropertyAccessExpression(exp) && ts.isIdentifier(exp.expression) && ts.isIdentifier(exp.name);
|
|
}
|
|
var ClassMemberKind;
|
|
(function(ClassMemberKind2) {
|
|
ClassMemberKind2[ClassMemberKind2["Constructor"] = 0] = "Constructor";
|
|
ClassMemberKind2[ClassMemberKind2["Getter"] = 1] = "Getter";
|
|
ClassMemberKind2[ClassMemberKind2["Setter"] = 2] = "Setter";
|
|
ClassMemberKind2[ClassMemberKind2["Property"] = 3] = "Property";
|
|
ClassMemberKind2[ClassMemberKind2["Method"] = 4] = "Method";
|
|
})(ClassMemberKind || (ClassMemberKind = {}));
|
|
var AmbientImport = {};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/type_to_value.mjs
|
|
import ts2 from "typescript";
|
|
function typeToValue(typeNode, checker, isLocalCompilation) {
|
|
var _a, _b;
|
|
if (typeNode === null) {
|
|
return missingType();
|
|
}
|
|
if (!ts2.isTypeReferenceNode(typeNode)) {
|
|
return unsupportedType(typeNode);
|
|
}
|
|
const symbols = resolveTypeSymbols(typeNode, checker);
|
|
if (symbols === null) {
|
|
return unknownReference(typeNode);
|
|
}
|
|
const { local, decl } = symbols;
|
|
if (decl.valueDeclaration === void 0 || decl.flags & ts2.SymbolFlags.ConstEnum) {
|
|
let typeOnlyDecl = null;
|
|
if (decl.declarations !== void 0 && decl.declarations.length > 0) {
|
|
typeOnlyDecl = decl.declarations[0];
|
|
}
|
|
if (!isLocalCompilation || typeOnlyDecl && [
|
|
ts2.SyntaxKind.TypeParameter,
|
|
ts2.SyntaxKind.TypeAliasDeclaration,
|
|
ts2.SyntaxKind.InterfaceDeclaration
|
|
].includes(typeOnlyDecl.kind)) {
|
|
return noValueDeclaration(typeNode, typeOnlyDecl);
|
|
}
|
|
}
|
|
const firstDecl = local.declarations && local.declarations[0];
|
|
if (firstDecl !== void 0) {
|
|
if (ts2.isImportClause(firstDecl) && firstDecl.name !== void 0) {
|
|
if (firstDecl.isTypeOnly) {
|
|
return typeOnlyImport(typeNode, firstDecl);
|
|
}
|
|
return {
|
|
kind: 0,
|
|
expression: firstDecl.name,
|
|
defaultImportStatement: firstDecl.parent
|
|
};
|
|
} else if (ts2.isImportSpecifier(firstDecl)) {
|
|
if (firstDecl.isTypeOnly) {
|
|
return typeOnlyImport(typeNode, firstDecl);
|
|
}
|
|
if (firstDecl.parent.parent.isTypeOnly) {
|
|
return typeOnlyImport(typeNode, firstDecl.parent.parent);
|
|
}
|
|
const importedName = (firstDecl.propertyName || firstDecl.name).text;
|
|
const [_localName, ...nestedPath] = symbols.symbolNames;
|
|
const moduleName = extractModuleName(firstDecl.parent.parent.parent);
|
|
return {
|
|
kind: 1,
|
|
valueDeclaration: (_a = decl.valueDeclaration) != null ? _a : null,
|
|
moduleName,
|
|
importedName,
|
|
nestedPath
|
|
};
|
|
} else if (ts2.isNamespaceImport(firstDecl)) {
|
|
if (firstDecl.parent.isTypeOnly) {
|
|
return typeOnlyImport(typeNode, firstDecl.parent);
|
|
}
|
|
if (symbols.symbolNames.length === 1) {
|
|
return namespaceImport(typeNode, firstDecl.parent);
|
|
}
|
|
const [_ns, importedName, ...nestedPath] = symbols.symbolNames;
|
|
const moduleName = extractModuleName(firstDecl.parent.parent);
|
|
return {
|
|
kind: 1,
|
|
valueDeclaration: (_b = decl.valueDeclaration) != null ? _b : null,
|
|
moduleName,
|
|
importedName,
|
|
nestedPath
|
|
};
|
|
}
|
|
}
|
|
const expression = typeNodeToValueExpr(typeNode);
|
|
if (expression !== null) {
|
|
return {
|
|
kind: 0,
|
|
expression,
|
|
defaultImportStatement: null
|
|
};
|
|
} else {
|
|
return unsupportedType(typeNode);
|
|
}
|
|
}
|
|
function unsupportedType(typeNode) {
|
|
return {
|
|
kind: 2,
|
|
reason: { kind: 5, typeNode }
|
|
};
|
|
}
|
|
function noValueDeclaration(typeNode, decl) {
|
|
return {
|
|
kind: 2,
|
|
reason: { kind: 1, typeNode, decl }
|
|
};
|
|
}
|
|
function typeOnlyImport(typeNode, node) {
|
|
return {
|
|
kind: 2,
|
|
reason: { kind: 2, typeNode, node }
|
|
};
|
|
}
|
|
function unknownReference(typeNode) {
|
|
return {
|
|
kind: 2,
|
|
reason: { kind: 3, typeNode }
|
|
};
|
|
}
|
|
function namespaceImport(typeNode, importClause) {
|
|
return {
|
|
kind: 2,
|
|
reason: { kind: 4, typeNode, importClause }
|
|
};
|
|
}
|
|
function missingType() {
|
|
return {
|
|
kind: 2,
|
|
reason: { kind: 0 }
|
|
};
|
|
}
|
|
function typeNodeToValueExpr(node) {
|
|
if (ts2.isTypeReferenceNode(node)) {
|
|
return entityNameToValue(node.typeName);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
function resolveTypeSymbols(typeRef, checker) {
|
|
const typeName = typeRef.typeName;
|
|
const typeRefSymbol = checker.getSymbolAtLocation(typeName);
|
|
if (typeRefSymbol === void 0) {
|
|
return null;
|
|
}
|
|
let local = typeRefSymbol;
|
|
let leftMost = typeName;
|
|
const symbolNames = [];
|
|
while (ts2.isQualifiedName(leftMost)) {
|
|
symbolNames.unshift(leftMost.right.text);
|
|
leftMost = leftMost.left;
|
|
}
|
|
symbolNames.unshift(leftMost.text);
|
|
if (leftMost !== typeName) {
|
|
const localTmp = checker.getSymbolAtLocation(leftMost);
|
|
if (localTmp !== void 0) {
|
|
local = localTmp;
|
|
}
|
|
}
|
|
let decl = typeRefSymbol;
|
|
if (typeRefSymbol.flags & ts2.SymbolFlags.Alias) {
|
|
decl = checker.getAliasedSymbol(typeRefSymbol);
|
|
}
|
|
return { local, decl, symbolNames };
|
|
}
|
|
function entityNameToValue(node) {
|
|
if (ts2.isQualifiedName(node)) {
|
|
const left = entityNameToValue(node.left);
|
|
return left !== null ? ts2.factory.createPropertyAccessExpression(left, node.right) : null;
|
|
} else if (ts2.isIdentifier(node)) {
|
|
const clone = ts2.setOriginalNode(ts2.factory.createIdentifier(node.text), node);
|
|
clone.parent = node.parent;
|
|
return clone;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
function extractModuleName(node) {
|
|
if (!ts2.isStringLiteral(node.moduleSpecifier)) {
|
|
throw new Error("not a module specifier");
|
|
}
|
|
return node.moduleSpecifier.text;
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/util.mjs
|
|
import ts3 from "typescript";
|
|
function isNamedClassDeclaration(node) {
|
|
return ts3.isClassDeclaration(node) && isIdentifier(node.name);
|
|
}
|
|
function isIdentifier(node) {
|
|
return node !== void 0 && ts3.isIdentifier(node);
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
|
|
var TypeScriptReflectionHost = class {
|
|
constructor(checker, isLocalCompilation = false) {
|
|
this.checker = checker;
|
|
this.isLocalCompilation = isLocalCompilation;
|
|
}
|
|
getDecoratorsOfDeclaration(declaration) {
|
|
const decorators = ts4.canHaveDecorators(declaration) ? ts4.getDecorators(declaration) : void 0;
|
|
return decorators !== void 0 && decorators.length ? decorators.map((decorator) => this._reflectDecorator(decorator)).filter((dec) => dec !== null) : null;
|
|
}
|
|
getMembersOfClass(clazz) {
|
|
const tsClazz = castDeclarationToClassOrDie(clazz);
|
|
return tsClazz.members.map((member) => this._reflectMember(member)).filter((member) => member !== null);
|
|
}
|
|
getConstructorParameters(clazz) {
|
|
const tsClazz = castDeclarationToClassOrDie(clazz);
|
|
const isDeclaration2 = tsClazz.getSourceFile().isDeclarationFile;
|
|
const ctor = tsClazz.members.find((member) => ts4.isConstructorDeclaration(member) && (isDeclaration2 || member.body !== void 0));
|
|
if (ctor === void 0) {
|
|
return null;
|
|
}
|
|
return ctor.parameters.map((node) => {
|
|
const name = parameterName(node.name);
|
|
const decorators = this.getDecoratorsOfDeclaration(node);
|
|
let originalTypeNode = node.type || null;
|
|
let typeNode = originalTypeNode;
|
|
if (typeNode && ts4.isUnionTypeNode(typeNode)) {
|
|
let childTypeNodes = typeNode.types.filter((childTypeNode) => !(ts4.isLiteralTypeNode(childTypeNode) && childTypeNode.literal.kind === ts4.SyntaxKind.NullKeyword));
|
|
if (childTypeNodes.length === 1) {
|
|
typeNode = childTypeNodes[0];
|
|
}
|
|
}
|
|
const typeValueReference = typeToValue(typeNode, this.checker, this.isLocalCompilation);
|
|
return {
|
|
name,
|
|
nameNode: node.name,
|
|
typeValueReference,
|
|
typeNode: originalTypeNode,
|
|
decorators
|
|
};
|
|
});
|
|
}
|
|
getImportOfIdentifier(id) {
|
|
const directImport = this.getDirectImportOfIdentifier(id);
|
|
if (directImport !== null) {
|
|
return directImport;
|
|
} else if (ts4.isQualifiedName(id.parent) && id.parent.right === id) {
|
|
return this.getImportOfNamespacedIdentifier(id, getQualifiedNameRoot(id.parent));
|
|
} else if (ts4.isPropertyAccessExpression(id.parent) && id.parent.name === id) {
|
|
return this.getImportOfNamespacedIdentifier(id, getFarLeftIdentifier(id.parent));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
getExportsOfModule(node) {
|
|
if (!ts4.isSourceFile(node)) {
|
|
throw new Error(`getExportsOfModule() called on non-SourceFile in TS code`);
|
|
}
|
|
const symbol = this.checker.getSymbolAtLocation(node);
|
|
if (symbol === void 0) {
|
|
return null;
|
|
}
|
|
const map = /* @__PURE__ */ new Map();
|
|
this.checker.getExportsOfModule(symbol).forEach((exportSymbol) => {
|
|
const decl = this.getDeclarationOfSymbol(exportSymbol, null);
|
|
if (decl !== null) {
|
|
map.set(exportSymbol.name, decl);
|
|
}
|
|
});
|
|
return map;
|
|
}
|
|
isClass(node) {
|
|
return isNamedClassDeclaration(node);
|
|
}
|
|
hasBaseClass(clazz) {
|
|
return this.getBaseClassExpression(clazz) !== null;
|
|
}
|
|
getBaseClassExpression(clazz) {
|
|
if (!(ts4.isClassDeclaration(clazz) || ts4.isClassExpression(clazz)) || clazz.heritageClauses === void 0) {
|
|
return null;
|
|
}
|
|
const extendsClause = clazz.heritageClauses.find((clause) => clause.token === ts4.SyntaxKind.ExtendsKeyword);
|
|
if (extendsClause === void 0) {
|
|
return null;
|
|
}
|
|
const extendsType = extendsClause.types[0];
|
|
if (extendsType === void 0) {
|
|
return null;
|
|
}
|
|
return extendsType.expression;
|
|
}
|
|
getDeclarationOfIdentifier(id) {
|
|
let symbol = this.checker.getSymbolAtLocation(id);
|
|
if (symbol === void 0) {
|
|
return null;
|
|
}
|
|
return this.getDeclarationOfSymbol(symbol, id);
|
|
}
|
|
getDefinitionOfFunction(node) {
|
|
if (!ts4.isFunctionDeclaration(node) && !ts4.isMethodDeclaration(node) && !ts4.isFunctionExpression(node) && !ts4.isArrowFunction(node)) {
|
|
return null;
|
|
}
|
|
let body = null;
|
|
if (node.body !== void 0) {
|
|
body = ts4.isBlock(node.body) ? Array.from(node.body.statements) : [ts4.factory.createReturnStatement(node.body)];
|
|
}
|
|
const type = this.checker.getTypeAtLocation(node);
|
|
const signatures = this.checker.getSignaturesOfType(type, ts4.SignatureKind.Call);
|
|
return {
|
|
node,
|
|
body,
|
|
signatureCount: signatures.length,
|
|
typeParameters: node.typeParameters === void 0 ? null : Array.from(node.typeParameters),
|
|
parameters: node.parameters.map((param) => {
|
|
const name = parameterName(param.name);
|
|
const initializer = param.initializer || null;
|
|
return { name, node: param, initializer, type: param.type || null };
|
|
})
|
|
};
|
|
}
|
|
getGenericArityOfClass(clazz) {
|
|
if (!ts4.isClassDeclaration(clazz)) {
|
|
return null;
|
|
}
|
|
return clazz.typeParameters !== void 0 ? clazz.typeParameters.length : 0;
|
|
}
|
|
getVariableValue(declaration) {
|
|
return declaration.initializer || null;
|
|
}
|
|
isStaticallyExported(decl) {
|
|
let topLevel = decl;
|
|
if (ts4.isVariableDeclaration(decl) && ts4.isVariableDeclarationList(decl.parent)) {
|
|
topLevel = decl.parent.parent;
|
|
}
|
|
const modifiers = ts4.canHaveModifiers(topLevel) ? ts4.getModifiers(topLevel) : void 0;
|
|
if (modifiers !== void 0 && modifiers.some((modifier) => modifier.kind === ts4.SyntaxKind.ExportKeyword)) {
|
|
return true;
|
|
}
|
|
if (topLevel.parent === void 0 || !ts4.isSourceFile(topLevel.parent)) {
|
|
return false;
|
|
}
|
|
const localExports = this.getLocalExportedDeclarationsOfSourceFile(decl.getSourceFile());
|
|
return localExports.has(decl);
|
|
}
|
|
getDirectImportOfIdentifier(id) {
|
|
const symbol = this.checker.getSymbolAtLocation(id);
|
|
if (symbol === void 0 || symbol.declarations === void 0 || symbol.declarations.length !== 1) {
|
|
return null;
|
|
}
|
|
const decl = symbol.declarations[0];
|
|
const importDecl = getContainingImportDeclaration(decl);
|
|
if (importDecl === null) {
|
|
return null;
|
|
}
|
|
if (!ts4.isStringLiteral(importDecl.moduleSpecifier)) {
|
|
return null;
|
|
}
|
|
return {
|
|
from: importDecl.moduleSpecifier.text,
|
|
name: getExportedName(decl, id),
|
|
node: importDecl
|
|
};
|
|
}
|
|
getImportOfNamespacedIdentifier(id, namespaceIdentifier) {
|
|
if (namespaceIdentifier === null) {
|
|
return null;
|
|
}
|
|
const namespaceSymbol = this.checker.getSymbolAtLocation(namespaceIdentifier);
|
|
if (!namespaceSymbol || namespaceSymbol.declarations === void 0) {
|
|
return null;
|
|
}
|
|
const declaration = namespaceSymbol.declarations.length === 1 ? namespaceSymbol.declarations[0] : null;
|
|
if (!declaration) {
|
|
return null;
|
|
}
|
|
const namespaceDeclaration = ts4.isNamespaceImport(declaration) ? declaration : null;
|
|
if (!namespaceDeclaration) {
|
|
return null;
|
|
}
|
|
const importDeclaration = namespaceDeclaration.parent.parent;
|
|
if (!ts4.isStringLiteral(importDeclaration.moduleSpecifier)) {
|
|
return null;
|
|
}
|
|
return {
|
|
from: importDeclaration.moduleSpecifier.text,
|
|
name: id.text,
|
|
node: namespaceDeclaration.parent.parent
|
|
};
|
|
}
|
|
getDeclarationOfSymbol(symbol, originalId) {
|
|
let valueDeclaration = void 0;
|
|
if (symbol.valueDeclaration !== void 0) {
|
|
valueDeclaration = symbol.valueDeclaration;
|
|
} else if (symbol.declarations !== void 0 && symbol.declarations.length > 0) {
|
|
valueDeclaration = symbol.declarations[0];
|
|
}
|
|
if (valueDeclaration !== void 0 && ts4.isShorthandPropertyAssignment(valueDeclaration)) {
|
|
const shorthandSymbol = this.checker.getShorthandAssignmentValueSymbol(valueDeclaration);
|
|
if (shorthandSymbol === void 0) {
|
|
return null;
|
|
}
|
|
return this.getDeclarationOfSymbol(shorthandSymbol, originalId);
|
|
} else if (valueDeclaration !== void 0 && ts4.isExportSpecifier(valueDeclaration)) {
|
|
const targetSymbol = this.checker.getExportSpecifierLocalTargetSymbol(valueDeclaration);
|
|
if (targetSymbol === void 0) {
|
|
return null;
|
|
}
|
|
return this.getDeclarationOfSymbol(targetSymbol, originalId);
|
|
}
|
|
const importInfo = originalId && this.getImportOfIdentifier(originalId);
|
|
while (symbol.flags & ts4.SymbolFlags.Alias) {
|
|
symbol = this.checker.getAliasedSymbol(symbol);
|
|
}
|
|
if (symbol.valueDeclaration !== void 0) {
|
|
return {
|
|
node: symbol.valueDeclaration,
|
|
viaModule: this._viaModule(symbol.valueDeclaration, originalId, importInfo)
|
|
};
|
|
} else if (symbol.declarations !== void 0 && symbol.declarations.length > 0) {
|
|
return {
|
|
node: symbol.declarations[0],
|
|
viaModule: this._viaModule(symbol.declarations[0], originalId, importInfo)
|
|
};
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
_reflectDecorator(node) {
|
|
let decoratorExpr = node.expression;
|
|
let args = null;
|
|
if (ts4.isCallExpression(decoratorExpr)) {
|
|
args = Array.from(decoratorExpr.arguments);
|
|
decoratorExpr = decoratorExpr.expression;
|
|
}
|
|
if (!isDecoratorIdentifier(decoratorExpr)) {
|
|
return null;
|
|
}
|
|
const decoratorIdentifier = ts4.isIdentifier(decoratorExpr) ? decoratorExpr : decoratorExpr.name;
|
|
const importDecl = this.getImportOfIdentifier(decoratorIdentifier);
|
|
return {
|
|
name: decoratorIdentifier.text,
|
|
identifier: decoratorExpr,
|
|
import: importDecl,
|
|
node,
|
|
args
|
|
};
|
|
}
|
|
_reflectMember(node) {
|
|
let kind = null;
|
|
let value = null;
|
|
let name = null;
|
|
let nameNode = null;
|
|
if (ts4.isPropertyDeclaration(node)) {
|
|
kind = ClassMemberKind.Property;
|
|
value = node.initializer || null;
|
|
} else if (ts4.isGetAccessorDeclaration(node)) {
|
|
kind = ClassMemberKind.Getter;
|
|
} else if (ts4.isSetAccessorDeclaration(node)) {
|
|
kind = ClassMemberKind.Setter;
|
|
} else if (ts4.isMethodDeclaration(node)) {
|
|
kind = ClassMemberKind.Method;
|
|
} else if (ts4.isConstructorDeclaration(node)) {
|
|
kind = ClassMemberKind.Constructor;
|
|
} else {
|
|
return null;
|
|
}
|
|
if (ts4.isConstructorDeclaration(node)) {
|
|
name = "constructor";
|
|
} else if (ts4.isIdentifier(node.name)) {
|
|
name = node.name.text;
|
|
nameNode = node.name;
|
|
} else if (ts4.isStringLiteral(node.name)) {
|
|
name = node.name.text;
|
|
nameNode = node.name;
|
|
} else {
|
|
return null;
|
|
}
|
|
const decorators = this.getDecoratorsOfDeclaration(node);
|
|
const modifiers = ts4.getModifiers(node);
|
|
const isStatic = modifiers !== void 0 && modifiers.some((mod) => mod.kind === ts4.SyntaxKind.StaticKeyword);
|
|
return {
|
|
node,
|
|
implementation: node,
|
|
kind,
|
|
type: node.type || null,
|
|
name,
|
|
nameNode,
|
|
decorators,
|
|
value,
|
|
isStatic
|
|
};
|
|
}
|
|
getLocalExportedDeclarationsOfSourceFile(file) {
|
|
const cacheSf = file;
|
|
if (cacheSf[LocalExportedDeclarations] !== void 0) {
|
|
return cacheSf[LocalExportedDeclarations];
|
|
}
|
|
const exportSet = /* @__PURE__ */ new Set();
|
|
cacheSf[LocalExportedDeclarations] = exportSet;
|
|
const sfSymbol = this.checker.getSymbolAtLocation(cacheSf);
|
|
if (sfSymbol === void 0 || sfSymbol.exports === void 0) {
|
|
return exportSet;
|
|
}
|
|
const iter = sfSymbol.exports.values();
|
|
let item = iter.next();
|
|
while (item.done !== true) {
|
|
let exportedSymbol = item.value;
|
|
if (exportedSymbol.flags & ts4.SymbolFlags.Alias) {
|
|
exportedSymbol = this.checker.getAliasedSymbol(exportedSymbol);
|
|
}
|
|
if (exportedSymbol.valueDeclaration !== void 0 && exportedSymbol.valueDeclaration.getSourceFile() === file) {
|
|
exportSet.add(exportedSymbol.valueDeclaration);
|
|
}
|
|
item = iter.next();
|
|
}
|
|
return exportSet;
|
|
}
|
|
_viaModule(declaration, originalId, importInfo) {
|
|
if (importInfo === null && originalId !== null && declaration.getSourceFile() !== originalId.getSourceFile()) {
|
|
return AmbientImport;
|
|
}
|
|
return importInfo !== null && importInfo.from !== null && !importInfo.from.startsWith(".") ? importInfo.from : null;
|
|
}
|
|
};
|
|
function reflectTypeEntityToDeclaration(type, checker) {
|
|
let realSymbol = checker.getSymbolAtLocation(type);
|
|
if (realSymbol === void 0) {
|
|
throw new Error(`Cannot resolve type entity ${type.getText()} to symbol`);
|
|
}
|
|
while (realSymbol.flags & ts4.SymbolFlags.Alias) {
|
|
realSymbol = checker.getAliasedSymbol(realSymbol);
|
|
}
|
|
let node = null;
|
|
if (realSymbol.valueDeclaration !== void 0) {
|
|
node = realSymbol.valueDeclaration;
|
|
} else if (realSymbol.declarations !== void 0 && realSymbol.declarations.length === 1) {
|
|
node = realSymbol.declarations[0];
|
|
} else {
|
|
throw new Error(`Cannot resolve type entity symbol to declaration`);
|
|
}
|
|
if (ts4.isQualifiedName(type)) {
|
|
if (!ts4.isIdentifier(type.left)) {
|
|
throw new Error(`Cannot handle qualified name with non-identifier lhs`);
|
|
}
|
|
const symbol = checker.getSymbolAtLocation(type.left);
|
|
if (symbol === void 0 || symbol.declarations === void 0 || symbol.declarations.length !== 1) {
|
|
throw new Error(`Cannot resolve qualified type entity lhs to symbol`);
|
|
}
|
|
const decl = symbol.declarations[0];
|
|
if (ts4.isNamespaceImport(decl)) {
|
|
const clause = decl.parent;
|
|
const importDecl = clause.parent;
|
|
if (!ts4.isStringLiteral(importDecl.moduleSpecifier)) {
|
|
throw new Error(`Module specifier is not a string`);
|
|
}
|
|
return { node, from: importDecl.moduleSpecifier.text };
|
|
} else if (ts4.isModuleDeclaration(decl)) {
|
|
return { node, from: null };
|
|
} else {
|
|
throw new Error(`Unknown import type?`);
|
|
}
|
|
} else {
|
|
return { node, from: null };
|
|
}
|
|
}
|
|
function filterToMembersWithDecorator(members, name, module) {
|
|
return members.filter((member) => !member.isStatic).map((member) => {
|
|
if (member.decorators === null) {
|
|
return null;
|
|
}
|
|
const decorators = member.decorators.filter((dec) => {
|
|
if (dec.import !== null) {
|
|
return dec.import.name === name && (module === void 0 || dec.import.from === module);
|
|
} else {
|
|
return dec.name === name && module === void 0;
|
|
}
|
|
});
|
|
if (decorators.length === 0) {
|
|
return null;
|
|
}
|
|
return { member, decorators };
|
|
}).filter((value) => value !== null);
|
|
}
|
|
function reflectObjectLiteral(node) {
|
|
const map = /* @__PURE__ */ new Map();
|
|
node.properties.forEach((prop) => {
|
|
if (ts4.isPropertyAssignment(prop)) {
|
|
const name = propertyNameToString(prop.name);
|
|
if (name === null) {
|
|
return;
|
|
}
|
|
map.set(name, prop.initializer);
|
|
} else if (ts4.isShorthandPropertyAssignment(prop)) {
|
|
map.set(prop.name.text, prop.name);
|
|
} else {
|
|
return;
|
|
}
|
|
});
|
|
return map;
|
|
}
|
|
function castDeclarationToClassOrDie(declaration) {
|
|
if (!ts4.isClassDeclaration(declaration)) {
|
|
throw new Error(`Reflecting on a ${ts4.SyntaxKind[declaration.kind]} instead of a ClassDeclaration.`);
|
|
}
|
|
return declaration;
|
|
}
|
|
function parameterName(name) {
|
|
if (ts4.isIdentifier(name)) {
|
|
return name.text;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
function propertyNameToString(node) {
|
|
if (ts4.isIdentifier(node) || ts4.isStringLiteral(node) || ts4.isNumericLiteral(node)) {
|
|
return node.text;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
function getQualifiedNameRoot(qualifiedName) {
|
|
while (ts4.isQualifiedName(qualifiedName.left)) {
|
|
qualifiedName = qualifiedName.left;
|
|
}
|
|
return ts4.isIdentifier(qualifiedName.left) ? qualifiedName.left : null;
|
|
}
|
|
function getFarLeftIdentifier(propertyAccess) {
|
|
while (ts4.isPropertyAccessExpression(propertyAccess.expression)) {
|
|
propertyAccess = propertyAccess.expression;
|
|
}
|
|
return ts4.isIdentifier(propertyAccess.expression) ? propertyAccess.expression : null;
|
|
}
|
|
function getContainingImportDeclaration(node) {
|
|
let parent = node.parent;
|
|
while (parent && !ts4.isSourceFile(parent)) {
|
|
if (ts4.isImportDeclaration(parent)) {
|
|
return parent;
|
|
}
|
|
parent = parent.parent;
|
|
}
|
|
return null;
|
|
}
|
|
function getExportedName(decl, originalId) {
|
|
return ts4.isImportSpecifier(decl) ? (decl.propertyName !== void 0 ? decl.propertyName : decl.name).text : originalId.text;
|
|
}
|
|
var LocalExportedDeclarations = Symbol("LocalExportedDeclarations");
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/typescript.mjs
|
|
import ts5 from "typescript";
|
|
var TS = /\.tsx?$/i;
|
|
var D_TS = /\.d\.ts$/i;
|
|
function isSymbolWithValueDeclaration(symbol) {
|
|
return symbol != null && symbol.valueDeclaration !== void 0 && symbol.declarations !== void 0;
|
|
}
|
|
function isDtsPath(filePath) {
|
|
return D_TS.test(filePath);
|
|
}
|
|
function isNonDeclarationTsPath(filePath) {
|
|
return TS.test(filePath) && !D_TS.test(filePath);
|
|
}
|
|
function isFromDtsFile(node) {
|
|
let sf = node.getSourceFile();
|
|
if (sf === void 0) {
|
|
sf = ts5.getOriginalNode(node).getSourceFile();
|
|
}
|
|
return sf !== void 0 && sf.isDeclarationFile;
|
|
}
|
|
function nodeNameForError(node) {
|
|
if (node.name !== void 0 && ts5.isIdentifier(node.name)) {
|
|
return node.name.text;
|
|
} else {
|
|
const kind = ts5.SyntaxKind[node.kind];
|
|
const { line, character } = ts5.getLineAndCharacterOfPosition(node.getSourceFile(), node.getStart());
|
|
return `${kind}@${line}:${character}`;
|
|
}
|
|
}
|
|
function getSourceFile(node) {
|
|
const directSf = node.getSourceFile();
|
|
return directSf !== void 0 ? directSf : ts5.getOriginalNode(node).getSourceFile();
|
|
}
|
|
function getSourceFileOrNull(program, fileName) {
|
|
return program.getSourceFile(fileName) || null;
|
|
}
|
|
function getTokenAtPosition(sf, pos) {
|
|
return ts5.getTokenAtPosition(sf, pos);
|
|
}
|
|
function identifierOfNode(decl) {
|
|
if (decl.name !== void 0 && ts5.isIdentifier(decl.name)) {
|
|
return decl.name;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
function isDeclaration(node) {
|
|
return isValueDeclaration(node) || isTypeDeclaration(node);
|
|
}
|
|
function isValueDeclaration(node) {
|
|
return ts5.isClassDeclaration(node) || ts5.isFunctionDeclaration(node) || ts5.isVariableDeclaration(node);
|
|
}
|
|
function isTypeDeclaration(node) {
|
|
return ts5.isEnumDeclaration(node) || ts5.isTypeAliasDeclaration(node) || ts5.isInterfaceDeclaration(node);
|
|
}
|
|
function isNamedDeclaration(node) {
|
|
const namedNode = node;
|
|
return namedNode.name !== void 0 && ts5.isIdentifier(namedNode.name);
|
|
}
|
|
function getRootDirs(host, options) {
|
|
const rootDirs = [];
|
|
const cwd = host.getCurrentDirectory();
|
|
const fs = getFileSystem();
|
|
if (options.rootDirs !== void 0) {
|
|
rootDirs.push(...options.rootDirs);
|
|
} else if (options.rootDir !== void 0) {
|
|
rootDirs.push(options.rootDir);
|
|
} else {
|
|
rootDirs.push(cwd);
|
|
}
|
|
return rootDirs.map((rootDir) => fs.resolve(cwd, host.getCanonicalFileName(rootDir)));
|
|
}
|
|
function nodeDebugInfo(node) {
|
|
const sf = getSourceFile(node);
|
|
const { line, character } = ts5.getLineAndCharacterOfPosition(sf, node.pos);
|
|
return `[${sf.fileName}: ${ts5.SyntaxKind[node.kind]} @ ${line}:${character}]`;
|
|
}
|
|
function resolveModuleName(moduleName, containingFile, compilerOptions, compilerHost, moduleResolutionCache) {
|
|
if (compilerHost.resolveModuleNames) {
|
|
return compilerHost.resolveModuleNames(
|
|
[moduleName],
|
|
containingFile,
|
|
void 0,
|
|
void 0,
|
|
compilerOptions
|
|
)[0];
|
|
} else {
|
|
return ts5.resolveModuleName(moduleName, containingFile, compilerOptions, compilerHost, moduleResolutionCache !== null ? moduleResolutionCache : void 0).resolvedModule;
|
|
}
|
|
}
|
|
function isAssignment(node) {
|
|
return ts5.isBinaryExpression(node) && node.operatorToken.kind === ts5.SyntaxKind.EqualsToken;
|
|
}
|
|
function toUnredirectedSourceFile(sf) {
|
|
const redirectInfo = sf.redirectInfo;
|
|
if (redirectInfo === void 0) {
|
|
return sf;
|
|
}
|
|
return redirectInfo.unredirected;
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/references.mjs
|
|
var Reference = class {
|
|
constructor(node, bestGuessOwningModule = null) {
|
|
this.node = node;
|
|
this.identifiers = [];
|
|
this.synthetic = false;
|
|
this._alias = null;
|
|
if (bestGuessOwningModule === AmbientImport) {
|
|
this.isAmbient = true;
|
|
this.bestGuessOwningModule = null;
|
|
} else {
|
|
this.isAmbient = false;
|
|
this.bestGuessOwningModule = bestGuessOwningModule;
|
|
}
|
|
const id = identifierOfNode(node);
|
|
if (id !== null) {
|
|
this.identifiers.push(id);
|
|
}
|
|
}
|
|
get ownedByModuleGuess() {
|
|
if (this.bestGuessOwningModule !== null) {
|
|
return this.bestGuessOwningModule.specifier;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
get hasOwningModuleGuess() {
|
|
return this.bestGuessOwningModule !== null;
|
|
}
|
|
get debugName() {
|
|
const id = identifierOfNode(this.node);
|
|
return id !== null ? id.text : null;
|
|
}
|
|
get alias() {
|
|
return this._alias;
|
|
}
|
|
addIdentifier(identifier) {
|
|
this.identifiers.push(identifier);
|
|
}
|
|
getIdentityIn(context) {
|
|
return this.identifiers.find((id) => id.getSourceFile() === context) || null;
|
|
}
|
|
getIdentityInExpression(expr) {
|
|
const sf = expr.getSourceFile();
|
|
return this.identifiers.find((id) => {
|
|
if (id.getSourceFile() !== sf) {
|
|
return false;
|
|
}
|
|
return id.pos >= expr.pos && id.end <= expr.end;
|
|
}) || null;
|
|
}
|
|
getOriginForDiagnostics(container, fallback = container) {
|
|
const id = this.getIdentityInExpression(container);
|
|
return id !== null ? id : fallback;
|
|
}
|
|
cloneWithAlias(alias) {
|
|
const ref = new Reference(this.node, this.isAmbient ? AmbientImport : this.bestGuessOwningModule);
|
|
ref.identifiers = [...this.identifiers];
|
|
ref._alias = alias;
|
|
return ref;
|
|
}
|
|
cloneWithNoIdentifiers() {
|
|
const ref = new Reference(this.node, this.isAmbient ? AmbientImport : this.bestGuessOwningModule);
|
|
ref._alias = this._alias;
|
|
ref.identifiers = [];
|
|
return ref;
|
|
}
|
|
};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
|
|
import { ExternalExpr as ExternalExpr2 } from "@angular/compiler";
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
|
|
import { ExternalExpr, ExternalReference, WrappedNodeExpr } from "@angular/compiler";
|
|
import ts7 from "typescript";
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_code.mjs
|
|
var ErrorCode;
|
|
(function(ErrorCode2) {
|
|
ErrorCode2[ErrorCode2["DECORATOR_ARG_NOT_LITERAL"] = 1001] = "DECORATOR_ARG_NOT_LITERAL";
|
|
ErrorCode2[ErrorCode2["DECORATOR_ARITY_WRONG"] = 1002] = "DECORATOR_ARITY_WRONG";
|
|
ErrorCode2[ErrorCode2["DECORATOR_NOT_CALLED"] = 1003] = "DECORATOR_NOT_CALLED";
|
|
ErrorCode2[ErrorCode2["DECORATOR_UNEXPECTED"] = 1005] = "DECORATOR_UNEXPECTED";
|
|
ErrorCode2[ErrorCode2["DECORATOR_COLLISION"] = 1006] = "DECORATOR_COLLISION";
|
|
ErrorCode2[ErrorCode2["VALUE_HAS_WRONG_TYPE"] = 1010] = "VALUE_HAS_WRONG_TYPE";
|
|
ErrorCode2[ErrorCode2["VALUE_NOT_LITERAL"] = 1011] = "VALUE_NOT_LITERAL";
|
|
ErrorCode2[ErrorCode2["SIGNAL_INPUT_AND_DISALLOWED_DECORATOR"] = 1050] = "SIGNAL_INPUT_AND_DISALLOWED_DECORATOR";
|
|
ErrorCode2[ErrorCode2["SIGNAL_INPUT_AND_INPUTS_ARRAY_COLLISION"] = 1051] = "SIGNAL_INPUT_AND_INPUTS_ARRAY_COLLISION";
|
|
ErrorCode2[ErrorCode2["INPUT_DECLARED_ON_STATIC_MEMBER"] = 1100] = "INPUT_DECLARED_ON_STATIC_MEMBER";
|
|
ErrorCode2[ErrorCode2["COMPONENT_MISSING_TEMPLATE"] = 2001] = "COMPONENT_MISSING_TEMPLATE";
|
|
ErrorCode2[ErrorCode2["PIPE_MISSING_NAME"] = 2002] = "PIPE_MISSING_NAME";
|
|
ErrorCode2[ErrorCode2["PARAM_MISSING_TOKEN"] = 2003] = "PARAM_MISSING_TOKEN";
|
|
ErrorCode2[ErrorCode2["DIRECTIVE_MISSING_SELECTOR"] = 2004] = "DIRECTIVE_MISSING_SELECTOR";
|
|
ErrorCode2[ErrorCode2["UNDECORATED_PROVIDER"] = 2005] = "UNDECORATED_PROVIDER";
|
|
ErrorCode2[ErrorCode2["DIRECTIVE_INHERITS_UNDECORATED_CTOR"] = 2006] = "DIRECTIVE_INHERITS_UNDECORATED_CTOR";
|
|
ErrorCode2[ErrorCode2["UNDECORATED_CLASS_USING_ANGULAR_FEATURES"] = 2007] = "UNDECORATED_CLASS_USING_ANGULAR_FEATURES";
|
|
ErrorCode2[ErrorCode2["COMPONENT_RESOURCE_NOT_FOUND"] = 2008] = "COMPONENT_RESOURCE_NOT_FOUND";
|
|
ErrorCode2[ErrorCode2["COMPONENT_INVALID_SHADOW_DOM_SELECTOR"] = 2009] = "COMPONENT_INVALID_SHADOW_DOM_SELECTOR";
|
|
ErrorCode2[ErrorCode2["COMPONENT_NOT_STANDALONE"] = 2010] = "COMPONENT_NOT_STANDALONE";
|
|
ErrorCode2[ErrorCode2["COMPONENT_IMPORT_NOT_STANDALONE"] = 2011] = "COMPONENT_IMPORT_NOT_STANDALONE";
|
|
ErrorCode2[ErrorCode2["COMPONENT_UNKNOWN_IMPORT"] = 2012] = "COMPONENT_UNKNOWN_IMPORT";
|
|
ErrorCode2[ErrorCode2["HOST_DIRECTIVE_INVALID"] = 2013] = "HOST_DIRECTIVE_INVALID";
|
|
ErrorCode2[ErrorCode2["HOST_DIRECTIVE_NOT_STANDALONE"] = 2014] = "HOST_DIRECTIVE_NOT_STANDALONE";
|
|
ErrorCode2[ErrorCode2["HOST_DIRECTIVE_COMPONENT"] = 2015] = "HOST_DIRECTIVE_COMPONENT";
|
|
ErrorCode2[ErrorCode2["INJECTABLE_INHERITS_INVALID_CONSTRUCTOR"] = 2016] = "INJECTABLE_INHERITS_INVALID_CONSTRUCTOR";
|
|
ErrorCode2[ErrorCode2["HOST_DIRECTIVE_UNDEFINED_BINDING"] = 2017] = "HOST_DIRECTIVE_UNDEFINED_BINDING";
|
|
ErrorCode2[ErrorCode2["HOST_DIRECTIVE_CONFLICTING_ALIAS"] = 2018] = "HOST_DIRECTIVE_CONFLICTING_ALIAS";
|
|
ErrorCode2[ErrorCode2["HOST_DIRECTIVE_MISSING_REQUIRED_BINDING"] = 2019] = "HOST_DIRECTIVE_MISSING_REQUIRED_BINDING";
|
|
ErrorCode2[ErrorCode2["CONFLICTING_INPUT_TRANSFORM"] = 2020] = "CONFLICTING_INPUT_TRANSFORM";
|
|
ErrorCode2[ErrorCode2["COMPONENT_INVALID_STYLE_URLS"] = 2021] = "COMPONENT_INVALID_STYLE_URLS";
|
|
ErrorCode2[ErrorCode2["COMPONENT_UNKNOWN_DEFERRED_IMPORT"] = 2022] = "COMPONENT_UNKNOWN_DEFERRED_IMPORT";
|
|
ErrorCode2[ErrorCode2["SYMBOL_NOT_EXPORTED"] = 3001] = "SYMBOL_NOT_EXPORTED";
|
|
ErrorCode2[ErrorCode2["IMPORT_CYCLE_DETECTED"] = 3003] = "IMPORT_CYCLE_DETECTED";
|
|
ErrorCode2[ErrorCode2["IMPORT_GENERATION_FAILURE"] = 3004] = "IMPORT_GENERATION_FAILURE";
|
|
ErrorCode2[ErrorCode2["CONFIG_FLAT_MODULE_NO_INDEX"] = 4001] = "CONFIG_FLAT_MODULE_NO_INDEX";
|
|
ErrorCode2[ErrorCode2["CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK"] = 4002] = "CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK";
|
|
ErrorCode2[ErrorCode2["CONFIG_EXTENDED_DIAGNOSTICS_IMPLIES_STRICT_TEMPLATES"] = 4003] = "CONFIG_EXTENDED_DIAGNOSTICS_IMPLIES_STRICT_TEMPLATES";
|
|
ErrorCode2[ErrorCode2["CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL"] = 4004] = "CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL";
|
|
ErrorCode2[ErrorCode2["CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK"] = 4005] = "CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK";
|
|
ErrorCode2[ErrorCode2["HOST_BINDING_PARSE_ERROR"] = 5001] = "HOST_BINDING_PARSE_ERROR";
|
|
ErrorCode2[ErrorCode2["TEMPLATE_PARSE_ERROR"] = 5002] = "TEMPLATE_PARSE_ERROR";
|
|
ErrorCode2[ErrorCode2["NGMODULE_INVALID_DECLARATION"] = 6001] = "NGMODULE_INVALID_DECLARATION";
|
|
ErrorCode2[ErrorCode2["NGMODULE_INVALID_IMPORT"] = 6002] = "NGMODULE_INVALID_IMPORT";
|
|
ErrorCode2[ErrorCode2["NGMODULE_INVALID_EXPORT"] = 6003] = "NGMODULE_INVALID_EXPORT";
|
|
ErrorCode2[ErrorCode2["NGMODULE_INVALID_REEXPORT"] = 6004] = "NGMODULE_INVALID_REEXPORT";
|
|
ErrorCode2[ErrorCode2["NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC"] = 6005] = "NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC";
|
|
ErrorCode2[ErrorCode2["NGMODULE_REEXPORT_NAME_COLLISION"] = 6006] = "NGMODULE_REEXPORT_NAME_COLLISION";
|
|
ErrorCode2[ErrorCode2["NGMODULE_DECLARATION_NOT_UNIQUE"] = 6007] = "NGMODULE_DECLARATION_NOT_UNIQUE";
|
|
ErrorCode2[ErrorCode2["NGMODULE_DECLARATION_IS_STANDALONE"] = 6008] = "NGMODULE_DECLARATION_IS_STANDALONE";
|
|
ErrorCode2[ErrorCode2["NGMODULE_BOOTSTRAP_IS_STANDALONE"] = 6009] = "NGMODULE_BOOTSTRAP_IS_STANDALONE";
|
|
ErrorCode2[ErrorCode2["WARN_NGMODULE_ID_UNNECESSARY"] = 6100] = "WARN_NGMODULE_ID_UNNECESSARY";
|
|
ErrorCode2[ErrorCode2["SCHEMA_INVALID_ELEMENT"] = 8001] = "SCHEMA_INVALID_ELEMENT";
|
|
ErrorCode2[ErrorCode2["SCHEMA_INVALID_ATTRIBUTE"] = 8002] = "SCHEMA_INVALID_ATTRIBUTE";
|
|
ErrorCode2[ErrorCode2["MISSING_REFERENCE_TARGET"] = 8003] = "MISSING_REFERENCE_TARGET";
|
|
ErrorCode2[ErrorCode2["MISSING_PIPE"] = 8004] = "MISSING_PIPE";
|
|
ErrorCode2[ErrorCode2["WRITE_TO_READ_ONLY_VARIABLE"] = 8005] = "WRITE_TO_READ_ONLY_VARIABLE";
|
|
ErrorCode2[ErrorCode2["DUPLICATE_VARIABLE_DECLARATION"] = 8006] = "DUPLICATE_VARIABLE_DECLARATION";
|
|
ErrorCode2[ErrorCode2["SPLIT_TWO_WAY_BINDING"] = 8007] = "SPLIT_TWO_WAY_BINDING";
|
|
ErrorCode2[ErrorCode2["MISSING_REQUIRED_INPUTS"] = 8008] = "MISSING_REQUIRED_INPUTS";
|
|
ErrorCode2[ErrorCode2["ILLEGAL_FOR_LOOP_TRACK_ACCESS"] = 8009] = "ILLEGAL_FOR_LOOP_TRACK_ACCESS";
|
|
ErrorCode2[ErrorCode2["INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT"] = 8010] = "INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT";
|
|
ErrorCode2[ErrorCode2["CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION"] = 8011] = "CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION";
|
|
ErrorCode2[ErrorCode2["DEFERRED_PIPE_USED_EAGERLY"] = 8012] = "DEFERRED_PIPE_USED_EAGERLY";
|
|
ErrorCode2[ErrorCode2["DEFERRED_DIRECTIVE_USED_EAGERLY"] = 8013] = "DEFERRED_DIRECTIVE_USED_EAGERLY";
|
|
ErrorCode2[ErrorCode2["DEFERRED_DEPENDENCY_IMPORTED_EAGERLY"] = 8014] = "DEFERRED_DEPENDENCY_IMPORTED_EAGERLY";
|
|
ErrorCode2[ErrorCode2["INVALID_BANANA_IN_BOX"] = 8101] = "INVALID_BANANA_IN_BOX";
|
|
ErrorCode2[ErrorCode2["NULLISH_COALESCING_NOT_NULLABLE"] = 8102] = "NULLISH_COALESCING_NOT_NULLABLE";
|
|
ErrorCode2[ErrorCode2["MISSING_CONTROL_FLOW_DIRECTIVE"] = 8103] = "MISSING_CONTROL_FLOW_DIRECTIVE";
|
|
ErrorCode2[ErrorCode2["TEXT_ATTRIBUTE_NOT_BINDING"] = 8104] = "TEXT_ATTRIBUTE_NOT_BINDING";
|
|
ErrorCode2[ErrorCode2["MISSING_NGFOROF_LET"] = 8105] = "MISSING_NGFOROF_LET";
|
|
ErrorCode2[ErrorCode2["SUFFIX_NOT_SUPPORTED"] = 8106] = "SUFFIX_NOT_SUPPORTED";
|
|
ErrorCode2[ErrorCode2["OPTIONAL_CHAIN_NOT_NULLABLE"] = 8107] = "OPTIONAL_CHAIN_NOT_NULLABLE";
|
|
ErrorCode2[ErrorCode2["SKIP_HYDRATION_NOT_STATIC"] = 8108] = "SKIP_HYDRATION_NOT_STATIC";
|
|
ErrorCode2[ErrorCode2["INTERPOLATED_SIGNAL_NOT_INVOKED"] = 8109] = "INTERPOLATED_SIGNAL_NOT_INVOKED";
|
|
ErrorCode2[ErrorCode2["INLINE_TCB_REQUIRED"] = 8900] = "INLINE_TCB_REQUIRED";
|
|
ErrorCode2[ErrorCode2["INLINE_TYPE_CTOR_REQUIRED"] = 8901] = "INLINE_TYPE_CTOR_REQUIRED";
|
|
ErrorCode2[ErrorCode2["INJECTABLE_DUPLICATE_PROV"] = 9001] = "INJECTABLE_DUPLICATE_PROV";
|
|
ErrorCode2[ErrorCode2["SUGGEST_STRICT_TEMPLATES"] = 10001] = "SUGGEST_STRICT_TEMPLATES";
|
|
ErrorCode2[ErrorCode2["SUGGEST_SUBOPTIMAL_TYPE_INFERENCE"] = 10002] = "SUGGEST_SUBOPTIMAL_TYPE_INFERENCE";
|
|
ErrorCode2[ErrorCode2["LOCAL_COMPILATION_IMPORTED_TEMPLATE_STRING"] = 11001] = "LOCAL_COMPILATION_IMPORTED_TEMPLATE_STRING";
|
|
ErrorCode2[ErrorCode2["LOCAL_COMPILATION_IMPORTED_STYLES_STRING"] = 11002] = "LOCAL_COMPILATION_IMPORTED_STYLES_STRING";
|
|
})(ErrorCode || (ErrorCode = {}));
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/docs.mjs
|
|
var COMPILER_ERRORS_WITH_GUIDES = /* @__PURE__ */ new Set([
|
|
ErrorCode.DECORATOR_ARG_NOT_LITERAL,
|
|
ErrorCode.IMPORT_CYCLE_DETECTED,
|
|
ErrorCode.PARAM_MISSING_TOKEN,
|
|
ErrorCode.SCHEMA_INVALID_ELEMENT,
|
|
ErrorCode.SCHEMA_INVALID_ATTRIBUTE,
|
|
ErrorCode.MISSING_REFERENCE_TARGET,
|
|
ErrorCode.COMPONENT_INVALID_SHADOW_DOM_SELECTOR,
|
|
ErrorCode.WARN_NGMODULE_ID_UNNECESSARY
|
|
]);
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
|
|
import ts6 from "typescript";
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/util.mjs
|
|
var ERROR_CODE_MATCHER = /(\u001b\[\d+m ?)TS-99(\d+: ?\u001b\[\d+m)/g;
|
|
function replaceTsWithNgInErrors(errors) {
|
|
return errors.replace(ERROR_CODE_MATCHER, "$1NG$2");
|
|
}
|
|
function ngErrorCode(code) {
|
|
return parseInt("-99" + code);
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
|
|
var FatalDiagnosticError = class extends Error {
|
|
constructor(code, node, diagnosticMessage, relatedInformation) {
|
|
super(`FatalDiagnosticError #${code}: ${diagnosticMessage}`);
|
|
this.code = code;
|
|
this.node = node;
|
|
this.diagnosticMessage = diagnosticMessage;
|
|
this.relatedInformation = relatedInformation;
|
|
this.message = null;
|
|
this._isFatalDiagnosticError = true;
|
|
Object.setPrototypeOf(this, new.target.prototype);
|
|
}
|
|
toDiagnostic() {
|
|
return makeDiagnostic(this.code, this.node, this.diagnosticMessage, this.relatedInformation);
|
|
}
|
|
};
|
|
function makeDiagnostic(code, node, messageText, relatedInformation) {
|
|
node = ts6.getOriginalNode(node);
|
|
return {
|
|
category: ts6.DiagnosticCategory.Error,
|
|
code: ngErrorCode(code),
|
|
file: ts6.getOriginalNode(node).getSourceFile(),
|
|
start: node.getStart(void 0, false),
|
|
length: node.getWidth(),
|
|
messageText,
|
|
relatedInformation
|
|
};
|
|
}
|
|
function makeDiagnosticChain(messageText, next) {
|
|
return {
|
|
category: ts6.DiagnosticCategory.Message,
|
|
code: 0,
|
|
messageText,
|
|
next
|
|
};
|
|
}
|
|
function makeRelatedInformation(node, messageText) {
|
|
node = ts6.getOriginalNode(node);
|
|
return {
|
|
category: ts6.DiagnosticCategory.Message,
|
|
code: 0,
|
|
file: node.getSourceFile(),
|
|
start: node.getStart(),
|
|
length: node.getWidth(),
|
|
messageText
|
|
};
|
|
}
|
|
function addDiagnosticChain(messageText, add) {
|
|
if (typeof messageText === "string") {
|
|
return makeDiagnosticChain(messageText, add);
|
|
}
|
|
if (messageText.next === void 0) {
|
|
messageText.next = add;
|
|
} else {
|
|
messageText.next.push(...add);
|
|
}
|
|
return messageText;
|
|
}
|
|
function isFatalDiagnosticError(err) {
|
|
return err._isFatalDiagnosticError === true;
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.mjs
|
|
var ERROR_DETAILS_PAGE_BASE_URL = "https://angular.io/errors";
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/extended_template_diagnostic_name.mjs
|
|
var ExtendedTemplateDiagnosticName;
|
|
(function(ExtendedTemplateDiagnosticName2) {
|
|
ExtendedTemplateDiagnosticName2["INVALID_BANANA_IN_BOX"] = "invalidBananaInBox";
|
|
ExtendedTemplateDiagnosticName2["NULLISH_COALESCING_NOT_NULLABLE"] = "nullishCoalescingNotNullable";
|
|
ExtendedTemplateDiagnosticName2["OPTIONAL_CHAIN_NOT_NULLABLE"] = "optionalChainNotNullable";
|
|
ExtendedTemplateDiagnosticName2["MISSING_CONTROL_FLOW_DIRECTIVE"] = "missingControlFlowDirective";
|
|
ExtendedTemplateDiagnosticName2["TEXT_ATTRIBUTE_NOT_BINDING"] = "textAttributeNotBinding";
|
|
ExtendedTemplateDiagnosticName2["MISSING_NGFOROF_LET"] = "missingNgForOfLet";
|
|
ExtendedTemplateDiagnosticName2["SUFFIX_NOT_SUPPORTED"] = "suffixNotSupported";
|
|
ExtendedTemplateDiagnosticName2["SKIP_HYDRATION_NOT_STATIC"] = "skipHydrationNotStatic";
|
|
ExtendedTemplateDiagnosticName2["INTERPOLATED_SIGNAL_NOT_INVOKED"] = "interpolatedSignalNotInvoked";
|
|
ExtendedTemplateDiagnosticName2["CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION"] = "controlFlowPreventingContentProjection";
|
|
})(ExtendedTemplateDiagnosticName || (ExtendedTemplateDiagnosticName = {}));
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/find_export.mjs
|
|
function findExportedNameOfNode(target, file, reflector) {
|
|
const exports = reflector.getExportsOfModule(file);
|
|
if (exports === null) {
|
|
return null;
|
|
}
|
|
const declaredName = isNamedDeclaration(target) ? target.name.text : null;
|
|
let foundExportName = null;
|
|
for (const [exportName, declaration] of exports) {
|
|
if (declaration.node !== target) {
|
|
continue;
|
|
}
|
|
if (exportName === declaredName) {
|
|
return exportName;
|
|
}
|
|
foundExportName = exportName;
|
|
}
|
|
return foundExportName;
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
|
|
var ImportFlags;
|
|
(function(ImportFlags2) {
|
|
ImportFlags2[ImportFlags2["None"] = 0] = "None";
|
|
ImportFlags2[ImportFlags2["ForceNewImport"] = 1] = "ForceNewImport";
|
|
ImportFlags2[ImportFlags2["NoAliasing"] = 2] = "NoAliasing";
|
|
ImportFlags2[ImportFlags2["AllowTypeImports"] = 4] = "AllowTypeImports";
|
|
ImportFlags2[ImportFlags2["AllowRelativeDtsImports"] = 8] = "AllowRelativeDtsImports";
|
|
ImportFlags2[ImportFlags2["AllowAmbientReferences"] = 16] = "AllowAmbientReferences";
|
|
})(ImportFlags || (ImportFlags = {}));
|
|
function assertSuccessfulReferenceEmit(result, origin, typeKind) {
|
|
if (result.kind === 0) {
|
|
return;
|
|
}
|
|
const message = makeDiagnosticChain(`Unable to import ${typeKind} ${nodeNameForError(result.ref.node)}.`, [makeDiagnosticChain(result.reason)]);
|
|
throw new FatalDiagnosticError(ErrorCode.IMPORT_GENERATION_FAILURE, origin, message, [makeRelatedInformation(result.ref.node, `The ${typeKind} is declared here.`)]);
|
|
}
|
|
var ReferenceEmitter = class {
|
|
constructor(strategies) {
|
|
this.strategies = strategies;
|
|
}
|
|
emit(ref, context, importFlags = ImportFlags.None) {
|
|
for (const strategy of this.strategies) {
|
|
const emitted = strategy.emit(ref, context, importFlags);
|
|
if (emitted !== null) {
|
|
return emitted;
|
|
}
|
|
}
|
|
return {
|
|
kind: 1,
|
|
ref,
|
|
context,
|
|
reason: `Unable to write a reference to ${nodeNameForError(ref.node)}.`
|
|
};
|
|
}
|
|
};
|
|
var LocalIdentifierStrategy = class {
|
|
emit(ref, context, importFlags) {
|
|
const refSf = getSourceFile(ref.node);
|
|
if (importFlags & ImportFlags.ForceNewImport && refSf !== context) {
|
|
return null;
|
|
}
|
|
if (!isDeclaration(ref.node) && refSf === context) {
|
|
return {
|
|
kind: 0,
|
|
expression: new WrappedNodeExpr(ref.node),
|
|
importedFile: null
|
|
};
|
|
}
|
|
if (ref.isAmbient && importFlags & ImportFlags.AllowAmbientReferences) {
|
|
const identifier2 = identifierOfNode(ref.node);
|
|
if (identifier2 !== null) {
|
|
return {
|
|
kind: 0,
|
|
expression: new WrappedNodeExpr(identifier2),
|
|
importedFile: null
|
|
};
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
const identifier = ref.getIdentityIn(context);
|
|
if (identifier !== null) {
|
|
return {
|
|
kind: 0,
|
|
expression: new WrappedNodeExpr(identifier),
|
|
importedFile: null
|
|
};
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
var AbsoluteModuleStrategy = class {
|
|
constructor(program, checker, moduleResolver, reflectionHost) {
|
|
this.program = program;
|
|
this.checker = checker;
|
|
this.moduleResolver = moduleResolver;
|
|
this.reflectionHost = reflectionHost;
|
|
this.moduleExportsCache = /* @__PURE__ */ new Map();
|
|
}
|
|
emit(ref, context, importFlags) {
|
|
if (ref.bestGuessOwningModule === null) {
|
|
return null;
|
|
} else if (!isDeclaration(ref.node)) {
|
|
throw new Error(`Debug assert: unable to import a Reference to non-declaration of type ${ts7.SyntaxKind[ref.node.kind]}.`);
|
|
} else if ((importFlags & ImportFlags.AllowTypeImports) === 0 && isTypeDeclaration(ref.node)) {
|
|
throw new Error(`Importing a type-only declaration of type ${ts7.SyntaxKind[ref.node.kind]} in a value position is not allowed.`);
|
|
}
|
|
const { specifier, resolutionContext } = ref.bestGuessOwningModule;
|
|
const exports = this.getExportsOfModule(specifier, resolutionContext);
|
|
if (exports.module === null) {
|
|
return {
|
|
kind: 1,
|
|
ref,
|
|
context,
|
|
reason: `The module '${specifier}' could not be found.`
|
|
};
|
|
} else if (exports.exportMap === null || !exports.exportMap.has(ref.node)) {
|
|
return {
|
|
kind: 1,
|
|
ref,
|
|
context,
|
|
reason: `The symbol is not exported from ${exports.module.fileName} (module '${specifier}').`
|
|
};
|
|
}
|
|
const symbolName = exports.exportMap.get(ref.node);
|
|
return {
|
|
kind: 0,
|
|
expression: new ExternalExpr(new ExternalReference(specifier, symbolName)),
|
|
importedFile: exports.module
|
|
};
|
|
}
|
|
getExportsOfModule(moduleName, fromFile) {
|
|
if (!this.moduleExportsCache.has(moduleName)) {
|
|
this.moduleExportsCache.set(moduleName, this.enumerateExportsOfModule(moduleName, fromFile));
|
|
}
|
|
return this.moduleExportsCache.get(moduleName);
|
|
}
|
|
enumerateExportsOfModule(specifier, fromFile) {
|
|
const entryPointFile = this.moduleResolver.resolveModule(specifier, fromFile);
|
|
if (entryPointFile === null) {
|
|
return { module: null, exportMap: null };
|
|
}
|
|
const exports = this.reflectionHost.getExportsOfModule(entryPointFile);
|
|
if (exports === null) {
|
|
return { module: entryPointFile, exportMap: null };
|
|
}
|
|
const exportMap = /* @__PURE__ */ new Map();
|
|
for (const [name, declaration] of exports) {
|
|
if (exportMap.has(declaration.node)) {
|
|
const existingExport = exportMap.get(declaration.node);
|
|
if (isNamedDeclaration(declaration.node) && declaration.node.name.text === existingExport) {
|
|
continue;
|
|
}
|
|
}
|
|
exportMap.set(declaration.node, name);
|
|
}
|
|
return { module: entryPointFile, exportMap };
|
|
}
|
|
};
|
|
var LogicalProjectStrategy = class {
|
|
constructor(reflector, logicalFs) {
|
|
this.reflector = reflector;
|
|
this.logicalFs = logicalFs;
|
|
this.relativePathStrategy = new RelativePathStrategy(this.reflector);
|
|
}
|
|
emit(ref, context, importFlags) {
|
|
const destSf = getSourceFile(ref.node);
|
|
const destPath = this.logicalFs.logicalPathOfSf(destSf);
|
|
if (destPath === null) {
|
|
if (destSf.isDeclarationFile && importFlags & ImportFlags.AllowRelativeDtsImports) {
|
|
return this.relativePathStrategy.emit(ref, context);
|
|
}
|
|
return {
|
|
kind: 1,
|
|
ref,
|
|
context,
|
|
reason: `The file ${destSf.fileName} is outside of the configured 'rootDir'.`
|
|
};
|
|
}
|
|
const originPath = this.logicalFs.logicalPathOfSf(context);
|
|
if (originPath === null) {
|
|
throw new Error(`Debug assert: attempt to import from ${context.fileName} but it's outside the program?`);
|
|
}
|
|
if (destPath === originPath) {
|
|
return null;
|
|
}
|
|
const name = findExportedNameOfNode(ref.node, destSf, this.reflector);
|
|
if (name === null) {
|
|
return {
|
|
kind: 1,
|
|
ref,
|
|
context,
|
|
reason: `The symbol is not exported from ${destSf.fileName}.`
|
|
};
|
|
}
|
|
const moduleName = LogicalProjectPath.relativePathBetween(originPath, destPath);
|
|
return {
|
|
kind: 0,
|
|
expression: new ExternalExpr({ moduleName, name }),
|
|
importedFile: destSf
|
|
};
|
|
}
|
|
};
|
|
var RelativePathStrategy = class {
|
|
constructor(reflector) {
|
|
this.reflector = reflector;
|
|
}
|
|
emit(ref, context) {
|
|
const destSf = getSourceFile(ref.node);
|
|
const relativePath = relative(dirname(absoluteFromSourceFile(context)), absoluteFromSourceFile(destSf));
|
|
const moduleName = toRelativeImport(stripExtension(relativePath));
|
|
const name = findExportedNameOfNode(ref.node, destSf, this.reflector);
|
|
if (name === null) {
|
|
return {
|
|
kind: 1,
|
|
ref,
|
|
context,
|
|
reason: `The symbol is not exported from ${destSf.fileName}.`
|
|
};
|
|
}
|
|
return {
|
|
kind: 0,
|
|
expression: new ExternalExpr({ moduleName, name }),
|
|
importedFile: destSf
|
|
};
|
|
}
|
|
};
|
|
var UnifiedModulesStrategy = class {
|
|
constructor(reflector, unifiedModulesHost) {
|
|
this.reflector = reflector;
|
|
this.unifiedModulesHost = unifiedModulesHost;
|
|
}
|
|
emit(ref, context) {
|
|
const destSf = getSourceFile(ref.node);
|
|
const name = findExportedNameOfNode(ref.node, destSf, this.reflector);
|
|
if (name === null) {
|
|
return null;
|
|
}
|
|
const moduleName = this.unifiedModulesHost.fileNameToModuleName(destSf.fileName, context.fileName);
|
|
return {
|
|
kind: 0,
|
|
expression: new ExternalExpr({ moduleName, name }),
|
|
importedFile: destSf
|
|
};
|
|
}
|
|
};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
|
|
var CHARS_TO_ESCAPE = /[^a-zA-Z0-9/_]/g;
|
|
var UnifiedModulesAliasingHost = class {
|
|
constructor(unifiedModulesHost) {
|
|
this.unifiedModulesHost = unifiedModulesHost;
|
|
this.aliasExportsInDts = false;
|
|
}
|
|
maybeAliasSymbolAs(ref, context, ngModuleName, isReExport) {
|
|
if (!isReExport) {
|
|
return null;
|
|
}
|
|
return this.aliasName(ref.node, context);
|
|
}
|
|
getAliasIn(decl, via, isReExport) {
|
|
if (!isReExport) {
|
|
return null;
|
|
}
|
|
const moduleName = this.unifiedModulesHost.fileNameToModuleName(via.fileName, via.fileName);
|
|
return new ExternalExpr2({ moduleName, name: this.aliasName(decl, via) });
|
|
}
|
|
aliasName(decl, context) {
|
|
const declModule = this.unifiedModulesHost.fileNameToModuleName(decl.getSourceFile().fileName, context.fileName);
|
|
const replaced = declModule.replace(CHARS_TO_ESCAPE, "_").replace(/\//g, "$");
|
|
return "\u0275ng$" + replaced + "$$" + decl.name.text;
|
|
}
|
|
};
|
|
var PrivateExportAliasingHost = class {
|
|
constructor(host) {
|
|
this.host = host;
|
|
this.aliasExportsInDts = true;
|
|
}
|
|
maybeAliasSymbolAs(ref, context, ngModuleName) {
|
|
if (ref.hasOwningModuleGuess) {
|
|
return null;
|
|
}
|
|
const exports = this.host.getExportsOfModule(context);
|
|
if (exports === null) {
|
|
throw new Error(`Could not determine the exports of: ${context.fileName}`);
|
|
}
|
|
let found = false;
|
|
exports.forEach((value) => {
|
|
if (value.node === ref.node) {
|
|
found = true;
|
|
}
|
|
});
|
|
if (found) {
|
|
return null;
|
|
}
|
|
return `\u0275ngExport\u0275${ngModuleName}\u0275${ref.node.name.text}`;
|
|
}
|
|
getAliasIn() {
|
|
return null;
|
|
}
|
|
};
|
|
var AliasStrategy = class {
|
|
emit(ref, context, importMode) {
|
|
if (importMode & ImportFlags.NoAliasing || ref.alias === null) {
|
|
return null;
|
|
}
|
|
return {
|
|
kind: 0,
|
|
expression: ref.alias,
|
|
importedFile: "unknown"
|
|
};
|
|
}
|
|
};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/path.mjs
|
|
function relativePathBetween(from, to) {
|
|
const relativePath = stripExtension(relative(dirname(resolve(from)), resolve(to)));
|
|
return relativePath !== "" ? toRelativeImport(relativePath) : null;
|
|
}
|
|
function normalizeSeparators(path) {
|
|
return path.replace(/\\/g, "/");
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/core.mjs
|
|
var NoopImportRewriter = class {
|
|
shouldImportSymbol(symbol, specifier) {
|
|
return true;
|
|
}
|
|
rewriteSymbol(symbol, specifier) {
|
|
return symbol;
|
|
}
|
|
rewriteSpecifier(specifier, inContextOfFile) {
|
|
return specifier;
|
|
}
|
|
};
|
|
var CORE_SUPPORTED_SYMBOLS = /* @__PURE__ */ new Map([
|
|
["\u0275\u0275defineInjectable", "\u0275\u0275defineInjectable"],
|
|
["\u0275\u0275defineInjector", "\u0275\u0275defineInjector"],
|
|
["\u0275\u0275defineNgModule", "\u0275\u0275defineNgModule"],
|
|
["\u0275\u0275setNgModuleScope", "\u0275\u0275setNgModuleScope"],
|
|
["\u0275\u0275inject", "\u0275\u0275inject"],
|
|
["\u0275\u0275FactoryDeclaration", "\u0275\u0275FactoryDeclaration"],
|
|
["\u0275setClassMetadata", "setClassMetadata"],
|
|
["\u0275setClassMetadataAsync", "setClassMetadataAsync"],
|
|
["\u0275\u0275InjectableDeclaration", "\u0275\u0275InjectableDeclaration"],
|
|
["\u0275\u0275InjectorDeclaration", "\u0275\u0275InjectorDeclaration"],
|
|
["\u0275\u0275NgModuleDeclaration", "\u0275\u0275NgModuleDeclaration"],
|
|
["\u0275NgModuleFactory", "NgModuleFactory"],
|
|
["\u0275noSideEffects", "\u0275noSideEffects"]
|
|
]);
|
|
var CORE_MODULE = "@angular/core";
|
|
var R3SymbolsImportRewriter = class {
|
|
constructor(r3SymbolsPath) {
|
|
this.r3SymbolsPath = r3SymbolsPath;
|
|
}
|
|
shouldImportSymbol(symbol, specifier) {
|
|
return true;
|
|
}
|
|
rewriteSymbol(symbol, specifier) {
|
|
if (specifier !== CORE_MODULE) {
|
|
return symbol;
|
|
}
|
|
return validateAndRewriteCoreSymbol(symbol);
|
|
}
|
|
rewriteSpecifier(specifier, inContextOfFile) {
|
|
if (specifier !== CORE_MODULE) {
|
|
return specifier;
|
|
}
|
|
const relativePathToR3Symbols = relativePathBetween(inContextOfFile, this.r3SymbolsPath);
|
|
if (relativePathToR3Symbols === null) {
|
|
throw new Error(`Failed to rewrite import inside ${CORE_MODULE}: ${inContextOfFile} -> ${this.r3SymbolsPath}`);
|
|
}
|
|
return relativePathToR3Symbols;
|
|
}
|
|
};
|
|
function validateAndRewriteCoreSymbol(name) {
|
|
if (!CORE_SUPPORTED_SYMBOLS.has(name)) {
|
|
throw new Error(`Importing unexpected symbol ${name} while compiling ${CORE_MODULE}`);
|
|
}
|
|
return CORE_SUPPORTED_SYMBOLS.get(name);
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/patch_alias_reference_resolution.mjs
|
|
import ts8 from "typescript";
|
|
var patchedReferencedAliasesSymbol = Symbol("patchedReferencedAliases");
|
|
function loadIsReferencedAliasDeclarationPatch(context) {
|
|
if (!isTransformationContextWithEmitResolver(context)) {
|
|
throwIncompatibleTransformationContextError();
|
|
}
|
|
const emitResolver = context.getEmitResolver();
|
|
const existingReferencedAliases = emitResolver[patchedReferencedAliasesSymbol];
|
|
if (existingReferencedAliases !== void 0) {
|
|
return existingReferencedAliases;
|
|
}
|
|
const originalIsReferencedAliasDeclaration = emitResolver.isReferencedAliasDeclaration;
|
|
if (originalIsReferencedAliasDeclaration === void 0) {
|
|
throwIncompatibleTransformationContextError();
|
|
}
|
|
const referencedAliases = /* @__PURE__ */ new Set();
|
|
emitResolver.isReferencedAliasDeclaration = function(node, ...args) {
|
|
if (isAliasImportDeclaration(node) && referencedAliases.has(node)) {
|
|
return true;
|
|
}
|
|
return originalIsReferencedAliasDeclaration.call(emitResolver, node, ...args);
|
|
};
|
|
return emitResolver[patchedReferencedAliasesSymbol] = referencedAliases;
|
|
}
|
|
function isAliasImportDeclaration(node) {
|
|
return ts8.isImportSpecifier(node) || ts8.isNamespaceImport(node) || ts8.isImportClause(node);
|
|
}
|
|
function isTransformationContextWithEmitResolver(context) {
|
|
return context.getEmitResolver !== void 0;
|
|
}
|
|
function throwIncompatibleTransformationContextError() {
|
|
throw Error("Angular compiler is incompatible with this version of the TypeScript compiler.\n\nIf you recently updated TypeScript and this issue surfaces now, consider downgrading.\n\nPlease report an issue on the Angular repositories when this issue surfaces and you are using a supposedly compatible TypeScript version.");
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/default.mjs
|
|
var DefaultImportDeclaration = Symbol("DefaultImportDeclaration");
|
|
function attachDefaultImportDeclaration(expr, importDecl) {
|
|
expr[DefaultImportDeclaration] = importDecl;
|
|
}
|
|
function getDefaultImportDeclaration(expr) {
|
|
var _a;
|
|
return (_a = expr[DefaultImportDeclaration]) != null ? _a : null;
|
|
}
|
|
var DefaultImportTracker = class {
|
|
constructor() {
|
|
this.sourceFileToUsedImports = /* @__PURE__ */ new Map();
|
|
}
|
|
recordUsedImport(importDecl) {
|
|
if (importDecl.importClause) {
|
|
const sf = getSourceFile(importDecl);
|
|
if (!this.sourceFileToUsedImports.has(sf.fileName)) {
|
|
this.sourceFileToUsedImports.set(sf.fileName, /* @__PURE__ */ new Set());
|
|
}
|
|
this.sourceFileToUsedImports.get(sf.fileName).add(importDecl.importClause);
|
|
}
|
|
}
|
|
importPreservingTransformer() {
|
|
return (context) => {
|
|
let clausesToPreserve = null;
|
|
return (sourceFile) => {
|
|
const clausesForFile = this.sourceFileToUsedImports.get(sourceFile.fileName);
|
|
if (clausesForFile !== void 0) {
|
|
for (const clause of clausesForFile) {
|
|
if (clausesToPreserve === null) {
|
|
clausesToPreserve = loadIsReferencedAliasDeclarationPatch(context);
|
|
}
|
|
clausesToPreserve.add(clause);
|
|
}
|
|
}
|
|
return sourceFile;
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/deferred_symbol_tracker.mjs
|
|
import ts9 from "typescript";
|
|
var AssumeEager = "AssumeEager";
|
|
var DeferredSymbolTracker = class {
|
|
constructor(typeChecker, onlyExplicitDeferDependencyImports) {
|
|
this.typeChecker = typeChecker;
|
|
this.onlyExplicitDeferDependencyImports = onlyExplicitDeferDependencyImports;
|
|
this.imports = /* @__PURE__ */ new Map();
|
|
this.explicitlyDeferredImports = /* @__PURE__ */ new Map();
|
|
}
|
|
extractImportedSymbols(importDecl) {
|
|
const symbolMap = /* @__PURE__ */ new Map();
|
|
if (importDecl.importClause === void 0) {
|
|
throw new Error(`Provided import declaration doesn't have any symbols.`);
|
|
}
|
|
if (importDecl.importClause.isTypeOnly) {
|
|
return symbolMap;
|
|
}
|
|
if (importDecl.importClause.namedBindings !== void 0) {
|
|
const bindings = importDecl.importClause.namedBindings;
|
|
if (ts9.isNamedImports(bindings)) {
|
|
for (const element of bindings.elements) {
|
|
if (!element.isTypeOnly) {
|
|
symbolMap.set(element.name.text, AssumeEager);
|
|
}
|
|
}
|
|
} else {
|
|
symbolMap.set(bindings.name.text, AssumeEager);
|
|
}
|
|
} else if (importDecl.importClause.name !== void 0) {
|
|
symbolMap.set(importDecl.importClause.name.text, AssumeEager);
|
|
} else {
|
|
throw new Error("Unrecognized import structure.");
|
|
}
|
|
return symbolMap;
|
|
}
|
|
getNonRemovableDeferredImports(sourceFile, classDecl) {
|
|
var _a;
|
|
const affectedImports = [];
|
|
const importDecls = (_a = this.explicitlyDeferredImports.get(classDecl)) != null ? _a : [];
|
|
for (const importDecl of importDecls) {
|
|
if (importDecl.getSourceFile() === sourceFile && !this.canDefer(importDecl)) {
|
|
affectedImports.push(importDecl);
|
|
}
|
|
}
|
|
return affectedImports;
|
|
}
|
|
markAsDeferrableCandidate(identifier, importDecl, componentClassDecl, isExplicitlyDeferred) {
|
|
if (this.onlyExplicitDeferDependencyImports && !isExplicitlyDeferred) {
|
|
return;
|
|
}
|
|
if (isExplicitlyDeferred) {
|
|
if (this.explicitlyDeferredImports.has(componentClassDecl)) {
|
|
this.explicitlyDeferredImports.get(componentClassDecl).push(importDecl);
|
|
} else {
|
|
this.explicitlyDeferredImports.set(componentClassDecl, [importDecl]);
|
|
}
|
|
}
|
|
let symbolMap = this.imports.get(importDecl);
|
|
if (!symbolMap) {
|
|
symbolMap = this.extractImportedSymbols(importDecl);
|
|
this.imports.set(importDecl, symbolMap);
|
|
}
|
|
if (!symbolMap.has(identifier.text)) {
|
|
throw new Error(`The '${identifier.text}' identifier doesn't belong to the provided import declaration.`);
|
|
}
|
|
if (symbolMap.get(identifier.text) === AssumeEager) {
|
|
symbolMap.set(identifier.text, this.lookupIdentifiersInSourceFile(identifier.text, importDecl));
|
|
}
|
|
const identifiers = symbolMap.get(identifier.text);
|
|
identifiers.delete(identifier);
|
|
}
|
|
canDefer(importDecl) {
|
|
if (!this.imports.has(importDecl)) {
|
|
return false;
|
|
}
|
|
const symbolsMap = this.imports.get(importDecl);
|
|
for (const [symbol, refs] of symbolsMap) {
|
|
if (refs === AssumeEager || refs.size > 0) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
getDeferrableImportDecls() {
|
|
const deferrableDecls = /* @__PURE__ */ new Set();
|
|
for (const [importDecl] of this.imports) {
|
|
if (this.canDefer(importDecl)) {
|
|
deferrableDecls.add(importDecl);
|
|
}
|
|
}
|
|
return deferrableDecls;
|
|
}
|
|
lookupIdentifiersInSourceFile(name, importDecl) {
|
|
const results = /* @__PURE__ */ new Set();
|
|
const visit = (node) => {
|
|
if (node === importDecl) {
|
|
return;
|
|
}
|
|
if (ts9.isIdentifier(node) && node.text === name) {
|
|
const sym = this.typeChecker.getSymbolAtLocation(node);
|
|
if (sym === void 0) {
|
|
return;
|
|
}
|
|
if (sym.declarations === void 0 || sym.declarations.length === 0) {
|
|
return;
|
|
}
|
|
const importClause = sym.declarations[0];
|
|
const decl = getContainingImportDeclaration(importClause);
|
|
if (decl !== importDecl) {
|
|
return;
|
|
}
|
|
results.add(node);
|
|
}
|
|
ts9.forEachChild(node, visit);
|
|
};
|
|
visit(importDecl.getSourceFile());
|
|
return results;
|
|
}
|
|
};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/resolver.mjs
|
|
var ModuleResolver = class {
|
|
constructor(program, compilerOptions, host, moduleResolutionCache) {
|
|
this.program = program;
|
|
this.compilerOptions = compilerOptions;
|
|
this.host = host;
|
|
this.moduleResolutionCache = moduleResolutionCache;
|
|
}
|
|
resolveModule(moduleName, containingFile) {
|
|
const resolved = resolveModuleName(moduleName, containingFile, this.compilerOptions, this.host, this.moduleResolutionCache);
|
|
if (resolved === void 0) {
|
|
return null;
|
|
}
|
|
return getSourceFileOrNull(this.program, absoluteFrom(resolved.resolvedFileName));
|
|
}
|
|
};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/import_manager.mjs
|
|
import ts10 from "typescript";
|
|
var ImportManager = class {
|
|
constructor(rewriter = new NoopImportRewriter(), prefix = "i", factory = ts10.factory) {
|
|
this.rewriter = rewriter;
|
|
this.prefix = prefix;
|
|
this.factory = factory;
|
|
this.specifierToIdentifier = /* @__PURE__ */ new Map();
|
|
this.nextIndex = 0;
|
|
}
|
|
generateNamespaceImport(moduleName) {
|
|
if (!this.specifierToIdentifier.has(moduleName)) {
|
|
this.specifierToIdentifier.set(moduleName, this.factory.createIdentifier(`${this.prefix}${this.nextIndex++}`));
|
|
}
|
|
return this.specifierToIdentifier.get(moduleName);
|
|
}
|
|
generateNamedImport(moduleName, originalSymbol) {
|
|
const symbol = this.rewriter.rewriteSymbol(originalSymbol, moduleName);
|
|
if (!this.rewriter.shouldImportSymbol(symbol, moduleName)) {
|
|
return { moduleImport: null, symbol };
|
|
}
|
|
const moduleImport = this.generateNamespaceImport(moduleName);
|
|
return { moduleImport, symbol };
|
|
}
|
|
getAllImports(contextPath) {
|
|
const imports = [];
|
|
for (const [originalSpecifier, qualifier] of this.specifierToIdentifier) {
|
|
const specifier = this.rewriter.rewriteSpecifier(originalSpecifier, contextPath);
|
|
imports.push({
|
|
specifier,
|
|
qualifier
|
|
});
|
|
}
|
|
return imports;
|
|
}
|
|
};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/context.mjs
|
|
var Context = class {
|
|
constructor(isStatement) {
|
|
this.isStatement = isStatement;
|
|
}
|
|
get withExpressionMode() {
|
|
return this.isStatement ? new Context(false) : this;
|
|
}
|
|
get withStatementMode() {
|
|
return !this.isStatement ? new Context(true) : this;
|
|
}
|
|
};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/translator.mjs
|
|
import * as o from "@angular/compiler";
|
|
var UNARY_OPERATORS = /* @__PURE__ */ new Map([
|
|
[o.UnaryOperator.Minus, "-"],
|
|
[o.UnaryOperator.Plus, "+"]
|
|
]);
|
|
var BINARY_OPERATORS = /* @__PURE__ */ 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, "??"]
|
|
]);
|
|
var ExpressionTranslatorVisitor = class {
|
|
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) {
|
|
var _a;
|
|
const varType = this.downlevelVariableDeclarations ? "var" : stmt.hasModifier(o.StmtModifier.Final) ? "const" : "let";
|
|
return this.attachComments(this.factory.createVariableDeclaration(stmt.name, (_a = stmt.value) == null ? void 0 : _a.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);
|
|
}
|
|
visitTaggedTemplateExpr(ast, context) {
|
|
return this.setSourceMapRange(this.createTaggedTemplateExpression(ast.tag.visitExpression(this, context), {
|
|
elements: ast.template.elements.map((e) => {
|
|
var _a;
|
|
return createTemplateElement({
|
|
cooked: e.text,
|
|
raw: e.rawText,
|
|
range: (_a = e.sourceSpan) != null ? _a : ast.sourceSpan
|
|
});
|
|
}),
|
|
expressions: ast.template.expressions.map((e) => e.visitExpression(this, context))
|
|
}), 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);
|
|
}
|
|
visitLocalizedString(ast, context) {
|
|
const elements = [createTemplateElement(ast.serializeI18nHead())];
|
|
const expressions = [];
|
|
for (let i = 0; i < ast.expressions.length; i++) {
|
|
const placeholder = this.setSourceMapRange(ast.expressions[i].visitExpression(this, context), ast.getPlaceholderSourceSpan(i));
|
|
expressions.push(placeholder);
|
|
elements.push(createTemplateElement(ast.serializeI18nTemplatePart(i + 1)));
|
|
}
|
|
const localizeTag = this.factory.createIdentifier("$localize");
|
|
return this.setSourceMapRange(this.createTaggedTemplateExpression(localizeTag, { elements, expressions }), ast.sourceSpan);
|
|
}
|
|
createTaggedTemplateExpression(tag, template) {
|
|
return this.downlevelTaggedTemplates ? this.createES5TaggedTemplateFunctionCall(tag, template) : this.factory.createTaggedTemplate(tag, template);
|
|
}
|
|
createES5TaggedTemplateFunctionCall(tagHandler, { elements, expressions }) {
|
|
const { moduleImport, symbol } = this.imports.generateNamedImport("tslib", "__makeTemplateObject");
|
|
const __makeTemplateObjectHelper = moduleImport === null ? this.factory.createIdentifier(symbol) : this.factory.createPropertyAccess(moduleImport, symbol);
|
|
const cooked = [];
|
|
const raw = [];
|
|
for (const element of elements) {
|
|
cooked.push(this.factory.setSourceMapRange(this.factory.createLiteral(element.cooked), element.range));
|
|
raw.push(this.factory.setSourceMapRange(this.factory.createLiteral(element.raw), element.range));
|
|
}
|
|
const templateHelperCall = this.factory.createCallExpression(
|
|
__makeTemplateObjectHelper,
|
|
[this.factory.createArrayLiteral(cooked), this.factory.createArrayLiteral(raw)],
|
|
false
|
|
);
|
|
return this.factory.createCallExpression(
|
|
tagHandler,
|
|
[templateHelperCall, ...expressions],
|
|
false
|
|
);
|
|
}
|
|
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 (ast.value.moduleName !== null) {
|
|
const { moduleImport, symbol } = this.imports.generateNamedImport(ast.value.moduleName, ast.value.name);
|
|
if (moduleImport === null) {
|
|
return this.factory.createIdentifier(symbol);
|
|
} else {
|
|
return this.factory.createPropertyAccess(moduleImport, symbol);
|
|
}
|
|
} else {
|
|
return this.factory.createIdentifier(ast.value.name);
|
|
}
|
|
}
|
|
visitConditionalExpr(ast, context) {
|
|
let cond = ast.condition.visitExpression(this, context);
|
|
if (ast.condition instanceof o.ConditionalExpr) {
|
|
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) {
|
|
var _a;
|
|
return this.factory.createFunctionExpression((_a = ast.name) != null ? _a : 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 !== void 0);
|
|
}
|
|
setSourceMapRange(ast, span) {
|
|
return this.factory.setSourceMapRange(ast, createRange(span));
|
|
}
|
|
attachComments(statement, leadingComments) {
|
|
if (leadingComments !== void 0) {
|
|
this.factory.attachComments(statement, leadingComments);
|
|
}
|
|
return statement;
|
|
}
|
|
};
|
|
function createTemplateElement({ cooked, raw, range }) {
|
|
return { cooked, raw, range: createRange(range) };
|
|
}
|
|
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 }
|
|
};
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_emitter.mjs
|
|
import ts11 from "typescript";
|
|
var INELIGIBLE = {};
|
|
function canEmitType(type, canEmit) {
|
|
return canEmitTypeWorker(type);
|
|
function canEmitTypeWorker(type2) {
|
|
return visitNode(type2) !== INELIGIBLE;
|
|
}
|
|
function visitNode(node) {
|
|
if (ts11.isImportTypeNode(node)) {
|
|
return INELIGIBLE;
|
|
}
|
|
if (ts11.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {
|
|
return INELIGIBLE;
|
|
} else {
|
|
return ts11.forEachChild(node, visitNode);
|
|
}
|
|
}
|
|
function canEmitTypeReference(type2) {
|
|
if (!canEmit(type2)) {
|
|
return false;
|
|
}
|
|
return type2.typeArguments === void 0 || type2.typeArguments.every(canEmitTypeWorker);
|
|
}
|
|
}
|
|
var TypeEmitter = class {
|
|
constructor(translator) {
|
|
this.translator = translator;
|
|
}
|
|
emitType(type) {
|
|
const typeReferenceTransformer = (context) => {
|
|
const visitNode = (node) => {
|
|
if (ts11.isImportTypeNode(node)) {
|
|
throw new Error("Unable to emit import type");
|
|
}
|
|
if (ts11.isTypeReferenceNode(node)) {
|
|
return this.emitTypeReference(node);
|
|
} else if (ts11.isLiteralExpression(node)) {
|
|
let clone;
|
|
if (ts11.isStringLiteral(node)) {
|
|
clone = ts11.factory.createStringLiteral(node.text);
|
|
} else if (ts11.isNumericLiteral(node)) {
|
|
clone = ts11.factory.createNumericLiteral(node.text);
|
|
} else if (ts11.isBigIntLiteral(node)) {
|
|
clone = ts11.factory.createBigIntLiteral(node.text);
|
|
} else if (ts11.isNoSubstitutionTemplateLiteral(node)) {
|
|
clone = ts11.factory.createNoSubstitutionTemplateLiteral(node.text, node.rawText);
|
|
} else if (ts11.isRegularExpressionLiteral(node)) {
|
|
clone = ts11.factory.createRegularExpressionLiteral(node.text);
|
|
} else {
|
|
throw new Error(`Unsupported literal kind ${ts11.SyntaxKind[node.kind]}`);
|
|
}
|
|
ts11.setTextRange(clone, { pos: -1, end: -1 });
|
|
return clone;
|
|
} else {
|
|
return ts11.visitEachChild(node, visitNode, context);
|
|
}
|
|
};
|
|
return (node) => ts11.visitNode(node, visitNode, ts11.isTypeNode);
|
|
};
|
|
return ts11.transform(type, [typeReferenceTransformer]).transformed[0];
|
|
}
|
|
emitTypeReference(type) {
|
|
const translatedType = this.translator(type);
|
|
if (translatedType === null) {
|
|
throw new Error("Unable to emit an unresolved reference");
|
|
}
|
|
let typeArguments = void 0;
|
|
if (type.typeArguments !== void 0) {
|
|
typeArguments = ts11.factory.createNodeArray(type.typeArguments.map((typeArg) => this.emitType(typeArg)));
|
|
}
|
|
return ts11.factory.updateTypeReferenceNode(type, translatedType.typeName, typeArguments);
|
|
}
|
|
};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
|
|
import * as o2 from "@angular/compiler";
|
|
import ts13 from "typescript";
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/ts_util.mjs
|
|
import ts12 from "typescript";
|
|
function tsNumericExpression(value) {
|
|
if (value < 0) {
|
|
const operand = ts12.factory.createNumericLiteral(Math.abs(value));
|
|
return ts12.factory.createPrefixUnaryExpression(ts12.SyntaxKind.MinusToken, operand);
|
|
}
|
|
return ts12.factory.createNumericLiteral(value);
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
|
|
function translateType(type, contextFile, reflector, refEmitter, imports) {
|
|
return type.visitType(new TypeTranslatorVisitor(imports, contextFile, reflector, refEmitter), new Context(false));
|
|
}
|
|
var TypeTranslatorVisitor = class {
|
|
constructor(imports, contextFile, reflector, refEmitter) {
|
|
this.imports = imports;
|
|
this.contextFile = contextFile;
|
|
this.reflector = reflector;
|
|
this.refEmitter = refEmitter;
|
|
}
|
|
visitBuiltinType(type, context) {
|
|
switch (type.name) {
|
|
case o2.BuiltinTypeName.Bool:
|
|
return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.BooleanKeyword);
|
|
case o2.BuiltinTypeName.Dynamic:
|
|
return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.AnyKeyword);
|
|
case o2.BuiltinTypeName.Int:
|
|
case o2.BuiltinTypeName.Number:
|
|
return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.NumberKeyword);
|
|
case o2.BuiltinTypeName.String:
|
|
return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.StringKeyword);
|
|
case o2.BuiltinTypeName.None:
|
|
return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.NeverKeyword);
|
|
default:
|
|
throw new Error(`Unsupported builtin type: ${o2.BuiltinTypeName[type.name]}`);
|
|
}
|
|
}
|
|
visitExpressionType(type, context) {
|
|
const typeNode = this.translateExpression(type.value, context);
|
|
if (type.typeParams === null) {
|
|
return typeNode;
|
|
}
|
|
if (!ts13.isTypeReferenceNode(typeNode)) {
|
|
throw new Error("An ExpressionType with type arguments must translate into a TypeReferenceNode");
|
|
} else if (typeNode.typeArguments !== void 0) {
|
|
throw new Error(`An ExpressionType with type arguments cannot have multiple levels of type arguments`);
|
|
}
|
|
const typeArgs = type.typeParams.map((param) => this.translateType(param, context));
|
|
return ts13.factory.createTypeReferenceNode(typeNode.typeName, typeArgs);
|
|
}
|
|
visitArrayType(type, context) {
|
|
return ts13.factory.createArrayTypeNode(this.translateType(type.of, context));
|
|
}
|
|
visitMapType(type, context) {
|
|
const parameter = ts13.factory.createParameterDeclaration(void 0, void 0, "key", void 0, ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.StringKeyword));
|
|
const typeArgs = type.valueType !== null ? this.translateType(type.valueType, context) : ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.UnknownKeyword);
|
|
const indexSignature = ts13.factory.createIndexSignature(void 0, [parameter], typeArgs);
|
|
return ts13.factory.createTypeLiteralNode([indexSignature]);
|
|
}
|
|
visitTransplantedType(ast, context) {
|
|
const node = ast.type instanceof Reference ? ast.type.node : ast.type;
|
|
if (!ts13.isTypeNode(node)) {
|
|
throw new Error(`A TransplantedType must wrap a TypeNode`);
|
|
}
|
|
const viaModule = ast.type instanceof Reference ? ast.type.bestGuessOwningModule : null;
|
|
const emitter = new TypeEmitter((typeRef) => this.translateTypeReference(typeRef, context, viaModule));
|
|
return emitter.emitType(node);
|
|
}
|
|
visitReadVarExpr(ast, context) {
|
|
if (ast.name === null) {
|
|
throw new Error(`ReadVarExpr with no variable name in type`);
|
|
}
|
|
return ts13.factory.createTypeQueryNode(ts13.factory.createIdentifier(ast.name));
|
|
}
|
|
visitWriteVarExpr(expr, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitWriteKeyExpr(expr, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitWritePropExpr(expr, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitInvokeFunctionExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitTaggedTemplateExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitInstantiateExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitLiteralExpr(ast, context) {
|
|
if (ast.value === null) {
|
|
return ts13.factory.createLiteralTypeNode(ts13.factory.createNull());
|
|
} else if (ast.value === void 0) {
|
|
return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.UndefinedKeyword);
|
|
} else if (typeof ast.value === "boolean") {
|
|
return ts13.factory.createLiteralTypeNode(ast.value ? ts13.factory.createTrue() : ts13.factory.createFalse());
|
|
} else if (typeof ast.value === "number") {
|
|
return ts13.factory.createLiteralTypeNode(tsNumericExpression(ast.value));
|
|
} else {
|
|
return ts13.factory.createLiteralTypeNode(ts13.factory.createStringLiteral(ast.value));
|
|
}
|
|
}
|
|
visitLocalizedString(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitExternalExpr(ast, context) {
|
|
if (ast.value.moduleName === null || ast.value.name === null) {
|
|
throw new Error(`Import unknown module or symbol`);
|
|
}
|
|
const { moduleImport, symbol } = this.imports.generateNamedImport(ast.value.moduleName, ast.value.name);
|
|
const symbolIdentifier = ts13.factory.createIdentifier(symbol);
|
|
const typeName = moduleImport ? ts13.factory.createQualifiedName(moduleImport, symbolIdentifier) : symbolIdentifier;
|
|
const typeArguments = ast.typeParams !== null ? ast.typeParams.map((type) => this.translateType(type, context)) : void 0;
|
|
return ts13.factory.createTypeReferenceNode(typeName, typeArguments);
|
|
}
|
|
visitConditionalExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitDynamicImportExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitNotExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitFunctionExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitArrowFunctionExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitUnaryOperatorExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitBinaryOperatorExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitReadPropExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitReadKeyExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitLiteralArrayExpr(ast, context) {
|
|
const values = ast.entries.map((expr) => this.translateExpression(expr, context));
|
|
return ts13.factory.createTupleTypeNode(values);
|
|
}
|
|
visitLiteralMapExpr(ast, context) {
|
|
const entries = ast.entries.map((entry) => {
|
|
const { key, quoted } = entry;
|
|
const type = this.translateExpression(entry.value, context);
|
|
return ts13.factory.createPropertySignature(
|
|
void 0,
|
|
quoted ? ts13.factory.createStringLiteral(key) : key,
|
|
void 0,
|
|
type
|
|
);
|
|
});
|
|
return ts13.factory.createTypeLiteralNode(entries);
|
|
}
|
|
visitCommaExpr(ast, context) {
|
|
throw new Error("Method not implemented.");
|
|
}
|
|
visitWrappedNodeExpr(ast, context) {
|
|
const node = ast.node;
|
|
if (ts13.isEntityName(node)) {
|
|
return ts13.factory.createTypeReferenceNode(node, void 0);
|
|
} else if (ts13.isTypeNode(node)) {
|
|
return node;
|
|
} else if (ts13.isLiteralExpression(node)) {
|
|
return ts13.factory.createLiteralTypeNode(node);
|
|
} else {
|
|
throw new Error(`Unsupported WrappedNodeExpr in TypeTranslatorVisitor: ${ts13.SyntaxKind[node.kind]}`);
|
|
}
|
|
}
|
|
visitTypeofExpr(ast, context) {
|
|
const typeNode = this.translateExpression(ast.expr, context);
|
|
if (!ts13.isTypeReferenceNode(typeNode)) {
|
|
throw new Error(`The target of a typeof expression must be a type reference, but it was
|
|
${ts13.SyntaxKind[typeNode.kind]}`);
|
|
}
|
|
return ts13.factory.createTypeQueryNode(typeNode.typeName);
|
|
}
|
|
translateType(type, context) {
|
|
const typeNode = type.visitType(this, context);
|
|
if (!ts13.isTypeNode(typeNode)) {
|
|
throw new Error(`A Type must translate to a TypeNode, but was ${ts13.SyntaxKind[typeNode.kind]}`);
|
|
}
|
|
return typeNode;
|
|
}
|
|
translateExpression(expr, context) {
|
|
const typeNode = expr.visitExpression(this, context);
|
|
if (!ts13.isTypeNode(typeNode)) {
|
|
throw new Error(`An Expression must translate to a TypeNode, but was ${ts13.SyntaxKind[typeNode.kind]}`);
|
|
}
|
|
return typeNode;
|
|
}
|
|
translateTypeReference(type, context, viaModule) {
|
|
const target = ts13.isIdentifier(type.typeName) ? type.typeName : type.typeName.right;
|
|
const declaration = this.reflector.getDeclarationOfIdentifier(target);
|
|
if (declaration === null) {
|
|
throw new Error(`Unable to statically determine the declaration file of type node ${target.text}`);
|
|
}
|
|
let owningModule = viaModule;
|
|
if (typeof declaration.viaModule === "string") {
|
|
owningModule = {
|
|
specifier: declaration.viaModule,
|
|
resolutionContext: type.getSourceFile().fileName
|
|
};
|
|
}
|
|
const reference = new Reference(declaration.node, declaration.viaModule === AmbientImport ? AmbientImport : owningModule);
|
|
const emittedType = this.refEmitter.emit(reference, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowAmbientReferences);
|
|
assertSuccessfulReferenceEmit(emittedType, target, "type");
|
|
const typeNode = this.translateExpression(emittedType.expression, context);
|
|
if (!ts13.isTypeReferenceNode(typeNode)) {
|
|
throw new Error(`Expected TypeReferenceNode for emitted reference, got ${ts13.SyntaxKind[typeNode.kind]}.`);
|
|
}
|
|
return typeNode;
|
|
}
|
|
};
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.mjs
|
|
import ts14 from "typescript";
|
|
var PureAnnotation;
|
|
(function(PureAnnotation2) {
|
|
PureAnnotation2["CLOSURE"] = "* @pureOrBreakMyCode ";
|
|
PureAnnotation2["TERSER"] = "@__PURE__";
|
|
})(PureAnnotation || (PureAnnotation = {}));
|
|
var UNARY_OPERATORS2 = {
|
|
"+": ts14.SyntaxKind.PlusToken,
|
|
"-": ts14.SyntaxKind.MinusToken,
|
|
"!": ts14.SyntaxKind.ExclamationToken
|
|
};
|
|
var BINARY_OPERATORS2 = {
|
|
"&&": ts14.SyntaxKind.AmpersandAmpersandToken,
|
|
">": ts14.SyntaxKind.GreaterThanToken,
|
|
">=": ts14.SyntaxKind.GreaterThanEqualsToken,
|
|
"&": ts14.SyntaxKind.AmpersandToken,
|
|
"|": ts14.SyntaxKind.BarToken,
|
|
"/": ts14.SyntaxKind.SlashToken,
|
|
"==": ts14.SyntaxKind.EqualsEqualsToken,
|
|
"===": ts14.SyntaxKind.EqualsEqualsEqualsToken,
|
|
"<": ts14.SyntaxKind.LessThanToken,
|
|
"<=": ts14.SyntaxKind.LessThanEqualsToken,
|
|
"-": ts14.SyntaxKind.MinusToken,
|
|
"%": ts14.SyntaxKind.PercentToken,
|
|
"*": ts14.SyntaxKind.AsteriskToken,
|
|
"!=": ts14.SyntaxKind.ExclamationEqualsToken,
|
|
"!==": ts14.SyntaxKind.ExclamationEqualsEqualsToken,
|
|
"||": ts14.SyntaxKind.BarBarToken,
|
|
"+": ts14.SyntaxKind.PlusToken,
|
|
"??": ts14.SyntaxKind.QuestionQuestionToken
|
|
};
|
|
var VAR_TYPES = {
|
|
"const": ts14.NodeFlags.Const,
|
|
"let": ts14.NodeFlags.Let,
|
|
"var": ts14.NodeFlags.None
|
|
};
|
|
var TypeScriptAstFactory = class {
|
|
constructor(annotateForClosureCompiler) {
|
|
this.annotateForClosureCompiler = annotateForClosureCompiler;
|
|
this.externalSourceFiles = /* @__PURE__ */ new Map();
|
|
this.attachComments = attachComments;
|
|
this.createArrayLiteral = ts14.factory.createArrayLiteralExpression;
|
|
this.createElementAccess = ts14.factory.createElementAccessExpression;
|
|
this.createExpressionStatement = ts14.factory.createExpressionStatement;
|
|
this.createIdentifier = ts14.factory.createIdentifier;
|
|
this.createParenthesizedExpression = ts14.factory.createParenthesizedExpression;
|
|
this.createPropertyAccess = ts14.factory.createPropertyAccessExpression;
|
|
this.createThrowStatement = ts14.factory.createThrowStatement;
|
|
this.createTypeOfExpression = ts14.factory.createTypeOfExpression;
|
|
}
|
|
createAssignment(target, value) {
|
|
return ts14.factory.createBinaryExpression(target, ts14.SyntaxKind.EqualsToken, value);
|
|
}
|
|
createBinaryExpression(leftOperand, operator, rightOperand) {
|
|
return ts14.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS2[operator], rightOperand);
|
|
}
|
|
createBlock(body) {
|
|
return ts14.factory.createBlock(body);
|
|
}
|
|
createCallExpression(callee, args, pure) {
|
|
const call = ts14.factory.createCallExpression(callee, void 0, args);
|
|
if (pure) {
|
|
ts14.addSyntheticLeadingComment(
|
|
call,
|
|
ts14.SyntaxKind.MultiLineCommentTrivia,
|
|
this.annotateForClosureCompiler ? PureAnnotation.CLOSURE : PureAnnotation.TERSER,
|
|
false
|
|
);
|
|
}
|
|
return call;
|
|
}
|
|
createConditional(condition, whenTrue, whenFalse) {
|
|
return ts14.factory.createConditionalExpression(condition, void 0, whenTrue, void 0, whenFalse);
|
|
}
|
|
createDynamicImport(url) {
|
|
return ts14.factory.createCallExpression(
|
|
ts14.factory.createToken(ts14.SyntaxKind.ImportKeyword),
|
|
void 0,
|
|
[ts14.factory.createStringLiteral(url)]
|
|
);
|
|
}
|
|
createFunctionDeclaration(functionName, parameters, body) {
|
|
if (!ts14.isBlock(body)) {
|
|
throw new Error(`Invalid syntax, expected a block, but got ${ts14.SyntaxKind[body.kind]}.`);
|
|
}
|
|
return ts14.factory.createFunctionDeclaration(void 0, void 0, functionName, void 0, parameters.map((param) => ts14.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
|
|
}
|
|
createFunctionExpression(functionName, parameters, body) {
|
|
if (!ts14.isBlock(body)) {
|
|
throw new Error(`Invalid syntax, expected a block, but got ${ts14.SyntaxKind[body.kind]}.`);
|
|
}
|
|
return ts14.factory.createFunctionExpression(void 0, void 0, functionName != null ? functionName : void 0, void 0, parameters.map((param) => ts14.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
|
|
}
|
|
createArrowFunctionExpression(parameters, body) {
|
|
if (ts14.isStatement(body) && !ts14.isBlock(body)) {
|
|
throw new Error(`Invalid syntax, expected a block, but got ${ts14.SyntaxKind[body.kind]}.`);
|
|
}
|
|
return ts14.factory.createArrowFunction(void 0, void 0, parameters.map((param) => ts14.factory.createParameterDeclaration(void 0, void 0, param)), void 0, void 0, body);
|
|
}
|
|
createIfStatement(condition, thenStatement, elseStatement) {
|
|
return ts14.factory.createIfStatement(condition, thenStatement, elseStatement != null ? elseStatement : void 0);
|
|
}
|
|
createLiteral(value) {
|
|
if (value === void 0) {
|
|
return ts14.factory.createIdentifier("undefined");
|
|
} else if (value === null) {
|
|
return ts14.factory.createNull();
|
|
} else if (typeof value === "boolean") {
|
|
return value ? ts14.factory.createTrue() : ts14.factory.createFalse();
|
|
} else if (typeof value === "number") {
|
|
return tsNumericExpression(value);
|
|
} else {
|
|
return ts14.factory.createStringLiteral(value);
|
|
}
|
|
}
|
|
createNewExpression(expression, args) {
|
|
return ts14.factory.createNewExpression(expression, void 0, args);
|
|
}
|
|
createObjectLiteral(properties) {
|
|
return ts14.factory.createObjectLiteralExpression(properties.map((prop) => ts14.factory.createPropertyAssignment(prop.quoted ? ts14.factory.createStringLiteral(prop.propertyName) : ts14.factory.createIdentifier(prop.propertyName), prop.value)));
|
|
}
|
|
createReturnStatement(expression) {
|
|
return ts14.factory.createReturnStatement(expression != null ? expression : void 0);
|
|
}
|
|
createTaggedTemplate(tag, template) {
|
|
let templateLiteral;
|
|
const length = template.elements.length;
|
|
const head = template.elements[0];
|
|
if (length === 1) {
|
|
templateLiteral = ts14.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
|
|
} else {
|
|
const spans = [];
|
|
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(ts14.factory.createTemplateSpan(template.expressions[i - 1], middle));
|
|
}
|
|
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(ts14.factory.createTemplateSpan(resolvedExpression, templateTail));
|
|
templateLiteral = ts14.factory.createTemplateExpression(ts14.factory.createTemplateHead(head.cooked, head.raw), spans);
|
|
}
|
|
if (head.range !== null) {
|
|
this.setSourceMapRange(templateLiteral, head.range);
|
|
}
|
|
return ts14.factory.createTaggedTemplateExpression(tag, void 0, templateLiteral);
|
|
}
|
|
createUnaryExpression(operator, operand) {
|
|
return ts14.factory.createPrefixUnaryExpression(UNARY_OPERATORS2[operator], operand);
|
|
}
|
|
createVariableDeclaration(variableName, initializer, type) {
|
|
return ts14.factory.createVariableStatement(void 0, ts14.factory.createVariableDeclarationList([ts14.factory.createVariableDeclaration(variableName, void 0, void 0, initializer != null ? initializer : void 0)], VAR_TYPES[type]));
|
|
}
|
|
setSourceMapRange(node, sourceMapRange) {
|
|
if (sourceMapRange === null) {
|
|
return node;
|
|
}
|
|
const url = sourceMapRange.url;
|
|
if (!this.externalSourceFiles.has(url)) {
|
|
this.externalSourceFiles.set(url, ts14.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
|
|
}
|
|
const source = this.externalSourceFiles.get(url);
|
|
ts14.setSourceMapRange(node, { pos: sourceMapRange.start.offset, end: sourceMapRange.end.offset, source });
|
|
return node;
|
|
}
|
|
};
|
|
function createTemplateMiddle(cooked, raw) {
|
|
const node = ts14.factory.createTemplateHead(cooked, raw);
|
|
node.kind = ts14.SyntaxKind.TemplateMiddle;
|
|
return node;
|
|
}
|
|
function createTemplateTail(cooked, raw) {
|
|
const node = ts14.factory.createTemplateHead(cooked, raw);
|
|
node.kind = ts14.SyntaxKind.TemplateTail;
|
|
return node;
|
|
}
|
|
function attachComments(statement, leadingComments) {
|
|
for (const comment of leadingComments) {
|
|
const commentKind = comment.multiline ? ts14.SyntaxKind.MultiLineCommentTrivia : ts14.SyntaxKind.SingleLineCommentTrivia;
|
|
if (comment.multiline) {
|
|
ts14.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
|
|
} else {
|
|
for (const line of comment.toString().split("\n")) {
|
|
ts14.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/typescript_translator.mjs
|
|
function translateExpression(expression, imports, options = {}) {
|
|
return expression.visitExpression(new ExpressionTranslatorVisitor(new TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, options), new Context(false));
|
|
}
|
|
function translateStatement(statement, imports, options = {}) {
|
|
return statement.visitStatement(new ExpressionTranslatorVisitor(new TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, options), new Context(true));
|
|
}
|
|
|
|
export {
|
|
ErrorCode,
|
|
COMPILER_ERRORS_WITH_GUIDES,
|
|
replaceTsWithNgInErrors,
|
|
ngErrorCode,
|
|
FatalDiagnosticError,
|
|
makeDiagnostic,
|
|
makeDiagnosticChain,
|
|
makeRelatedInformation,
|
|
addDiagnosticChain,
|
|
isFatalDiagnosticError,
|
|
ERROR_DETAILS_PAGE_BASE_URL,
|
|
ExtendedTemplateDiagnosticName,
|
|
isSymbolWithValueDeclaration,
|
|
isDtsPath,
|
|
isNonDeclarationTsPath,
|
|
isFromDtsFile,
|
|
nodeNameForError,
|
|
getSourceFile,
|
|
getSourceFileOrNull,
|
|
getTokenAtPosition,
|
|
identifierOfNode,
|
|
isDeclaration,
|
|
getRootDirs,
|
|
nodeDebugInfo,
|
|
isAssignment,
|
|
toUnredirectedSourceFile,
|
|
ImportFlags,
|
|
assertSuccessfulReferenceEmit,
|
|
ReferenceEmitter,
|
|
LocalIdentifierStrategy,
|
|
AbsoluteModuleStrategy,
|
|
LogicalProjectStrategy,
|
|
RelativePathStrategy,
|
|
UnifiedModulesStrategy,
|
|
UnifiedModulesAliasingHost,
|
|
PrivateExportAliasingHost,
|
|
AliasStrategy,
|
|
relativePathBetween,
|
|
normalizeSeparators,
|
|
NoopImportRewriter,
|
|
R3SymbolsImportRewriter,
|
|
loadIsReferencedAliasDeclarationPatch,
|
|
isAliasImportDeclaration,
|
|
attachDefaultImportDeclaration,
|
|
getDefaultImportDeclaration,
|
|
DefaultImportTracker,
|
|
ClassMemberKind,
|
|
AmbientImport,
|
|
typeNodeToValueExpr,
|
|
isNamedClassDeclaration,
|
|
TypeScriptReflectionHost,
|
|
reflectTypeEntityToDeclaration,
|
|
filterToMembersWithDecorator,
|
|
reflectObjectLiteral,
|
|
DeferredSymbolTracker,
|
|
Reference,
|
|
ModuleResolver,
|
|
Context,
|
|
ImportManager,
|
|
ExpressionTranslatorVisitor,
|
|
canEmitType,
|
|
TypeEmitter,
|
|
translateType,
|
|
translateExpression,
|
|
translateStatement
|
|
};
|
|
/*!
|
|
* @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
|
|
*/
|
|
/**
|
|
* @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
|
|
*/
|
|
//# sourceMappingURL=chunk-O2GHHXCL.js.map
|