"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
value: true
|
});
|
exports.TSTypeAnnotation = TSTypeAnnotation;
|
exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation;
|
exports.TSTypeParameter = TSTypeParameter;
|
exports.TSParameterProperty = TSParameterProperty;
|
exports.TSDeclareFunction = TSDeclareFunction;
|
exports.TSDeclareMethod = TSDeclareMethod;
|
exports.TSQualifiedName = TSQualifiedName;
|
exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
|
exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
|
exports.TSPropertySignature = TSPropertySignature;
|
exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName;
|
exports.TSMethodSignature = TSMethodSignature;
|
exports.TSIndexSignature = TSIndexSignature;
|
exports.TSAnyKeyword = TSAnyKeyword;
|
exports.TSBigIntKeyword = TSBigIntKeyword;
|
exports.TSUnknownKeyword = TSUnknownKeyword;
|
exports.TSNumberKeyword = TSNumberKeyword;
|
exports.TSObjectKeyword = TSObjectKeyword;
|
exports.TSBooleanKeyword = TSBooleanKeyword;
|
exports.TSStringKeyword = TSStringKeyword;
|
exports.TSSymbolKeyword = TSSymbolKeyword;
|
exports.TSVoidKeyword = TSVoidKeyword;
|
exports.TSUndefinedKeyword = TSUndefinedKeyword;
|
exports.TSNullKeyword = TSNullKeyword;
|
exports.TSNeverKeyword = TSNeverKeyword;
|
exports.TSIntrinsicKeyword = TSIntrinsicKeyword;
|
exports.TSThisType = TSThisType;
|
exports.TSFunctionType = TSFunctionType;
|
exports.TSConstructorType = TSConstructorType;
|
exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType;
|
exports.TSTypeReference = TSTypeReference;
|
exports.TSTypePredicate = TSTypePredicate;
|
exports.TSTypeQuery = TSTypeQuery;
|
exports.TSTypeLiteral = TSTypeLiteral;
|
exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody;
|
exports.tsPrintBraced = tsPrintBraced;
|
exports.TSArrayType = TSArrayType;
|
exports.TSTupleType = TSTupleType;
|
exports.TSOptionalType = TSOptionalType;
|
exports.TSRestType = TSRestType;
|
exports.TSNamedTupleMember = TSNamedTupleMember;
|
exports.TSUnionType = TSUnionType;
|
exports.TSIntersectionType = TSIntersectionType;
|
exports.tsPrintUnionOrIntersectionType = tsPrintUnionOrIntersectionType;
|
exports.TSConditionalType = TSConditionalType;
|
exports.TSInferType = TSInferType;
|
exports.TSParenthesizedType = TSParenthesizedType;
|
exports.TSTypeOperator = TSTypeOperator;
|
exports.TSIndexedAccessType = TSIndexedAccessType;
|
exports.TSMappedType = TSMappedType;
|
exports.TSLiteralType = TSLiteralType;
|
exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
|
exports.TSInterfaceDeclaration = TSInterfaceDeclaration;
|
exports.TSInterfaceBody = TSInterfaceBody;
|
exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration;
|
exports.TSAsExpression = TSAsExpression;
|
exports.TSTypeAssertion = TSTypeAssertion;
|
exports.TSEnumDeclaration = TSEnumDeclaration;
|
exports.TSEnumMember = TSEnumMember;
|
exports.TSModuleDeclaration = TSModuleDeclaration;
|
exports.TSModuleBlock = TSModuleBlock;
|
exports.TSImportType = TSImportType;
|
exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration;
|
exports.TSExternalModuleReference = TSExternalModuleReference;
|
exports.TSNonNullExpression = TSNonNullExpression;
|
exports.TSExportAssignment = TSExportAssignment;
|
exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration;
|
exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase;
|
exports.tsPrintClassMemberModifiers = tsPrintClassMemberModifiers;
|
|
function TSTypeAnnotation(node) {
|
this.token(":");
|
this.space();
|
if (node.optional) this.token("?");
|
this.print(node.typeAnnotation, node);
|
}
|
|
function TSTypeParameterInstantiation(node) {
|
this.token("<");
|
this.printList(node.params, node, {});
|
this.token(">");
|
}
|
|
function TSTypeParameter(node) {
|
this.word(node.name);
|
|
if (node.constraint) {
|
this.space();
|
this.word("extends");
|
this.space();
|
this.print(node.constraint, node);
|
}
|
|
if (node.default) {
|
this.space();
|
this.token("=");
|
this.space();
|
this.print(node.default, node);
|
}
|
}
|
|
function TSParameterProperty(node) {
|
if (node.accessibility) {
|
this.word(node.accessibility);
|
this.space();
|
}
|
|
if (node.readonly) {
|
this.word("readonly");
|
this.space();
|
}
|
|
this._param(node.parameter);
|
}
|
|
function TSDeclareFunction(node) {
|
if (node.declare) {
|
this.word("declare");
|
this.space();
|
}
|
|
this._functionHead(node);
|
|
this.token(";");
|
}
|
|
function TSDeclareMethod(node) {
|
this._classMethodHead(node);
|
|
this.token(";");
|
}
|
|
function TSQualifiedName(node) {
|
this.print(node.left, node);
|
this.token(".");
|
this.print(node.right, node);
|
}
|
|
function TSCallSignatureDeclaration(node) {
|
this.tsPrintSignatureDeclarationBase(node);
|
this.token(";");
|
}
|
|
function TSConstructSignatureDeclaration(node) {
|
this.word("new");
|
this.space();
|
this.tsPrintSignatureDeclarationBase(node);
|
this.token(";");
|
}
|
|
function TSPropertySignature(node) {
|
const {
|
readonly,
|
initializer
|
} = node;
|
|
if (readonly) {
|
this.word("readonly");
|
this.space();
|
}
|
|
this.tsPrintPropertyOrMethodName(node);
|
this.print(node.typeAnnotation, node);
|
|
if (initializer) {
|
this.space();
|
this.token("=");
|
this.space();
|
this.print(initializer, node);
|
}
|
|
this.token(";");
|
}
|
|
function tsPrintPropertyOrMethodName(node) {
|
if (node.computed) {
|
this.token("[");
|
}
|
|
this.print(node.key, node);
|
|
if (node.computed) {
|
this.token("]");
|
}
|
|
if (node.optional) {
|
this.token("?");
|
}
|
}
|
|
function TSMethodSignature(node) {
|
const {
|
kind
|
} = node;
|
|
if (kind === "set" || kind === "get") {
|
this.word(kind);
|
this.space();
|
}
|
|
this.tsPrintPropertyOrMethodName(node);
|
this.tsPrintSignatureDeclarationBase(node);
|
this.token(";");
|
}
|
|
function TSIndexSignature(node) {
|
const {
|
readonly,
|
static: isStatic
|
} = node;
|
|
if (isStatic) {
|
this.word("static");
|
this.space();
|
}
|
|
if (readonly) {
|
this.word("readonly");
|
this.space();
|
}
|
|
this.token("[");
|
|
this._parameters(node.parameters, node);
|
|
this.token("]");
|
this.print(node.typeAnnotation, node);
|
this.token(";");
|
}
|
|
function TSAnyKeyword() {
|
this.word("any");
|
}
|
|
function TSBigIntKeyword() {
|
this.word("bigint");
|
}
|
|
function TSUnknownKeyword() {
|
this.word("unknown");
|
}
|
|
function TSNumberKeyword() {
|
this.word("number");
|
}
|
|
function TSObjectKeyword() {
|
this.word("object");
|
}
|
|
function TSBooleanKeyword() {
|
this.word("boolean");
|
}
|
|
function TSStringKeyword() {
|
this.word("string");
|
}
|
|
function TSSymbolKeyword() {
|
this.word("symbol");
|
}
|
|
function TSVoidKeyword() {
|
this.word("void");
|
}
|
|
function TSUndefinedKeyword() {
|
this.word("undefined");
|
}
|
|
function TSNullKeyword() {
|
this.word("null");
|
}
|
|
function TSNeverKeyword() {
|
this.word("never");
|
}
|
|
function TSIntrinsicKeyword() {
|
this.word("intrinsic");
|
}
|
|
function TSThisType() {
|
this.word("this");
|
}
|
|
function TSFunctionType(node) {
|
this.tsPrintFunctionOrConstructorType(node);
|
}
|
|
function TSConstructorType(node) {
|
if (node.abstract) {
|
this.word("abstract");
|
this.space();
|
}
|
|
this.word("new");
|
this.space();
|
this.tsPrintFunctionOrConstructorType(node);
|
}
|
|
function tsPrintFunctionOrConstructorType(node) {
|
const {
|
typeParameters,
|
parameters
|
} = node;
|
this.print(typeParameters, node);
|
this.token("(");
|
|
this._parameters(parameters, node);
|
|
this.token(")");
|
this.space();
|
this.token("=>");
|
this.space();
|
this.print(node.typeAnnotation.typeAnnotation, node);
|
}
|
|
function TSTypeReference(node) {
|
this.print(node.typeName, node);
|
this.print(node.typeParameters, node);
|
}
|
|
function TSTypePredicate(node) {
|
if (node.asserts) {
|
this.word("asserts");
|
this.space();
|
}
|
|
this.print(node.parameterName);
|
|
if (node.typeAnnotation) {
|
this.space();
|
this.word("is");
|
this.space();
|
this.print(node.typeAnnotation.typeAnnotation);
|
}
|
}
|
|
function TSTypeQuery(node) {
|
this.word("typeof");
|
this.space();
|
this.print(node.exprName);
|
}
|
|
function TSTypeLiteral(node) {
|
this.tsPrintTypeLiteralOrInterfaceBody(node.members, node);
|
}
|
|
function tsPrintTypeLiteralOrInterfaceBody(members, node) {
|
this.tsPrintBraced(members, node);
|
}
|
|
function tsPrintBraced(members, node) {
|
this.token("{");
|
|
if (members.length) {
|
this.indent();
|
this.newline();
|
|
for (const member of members) {
|
this.print(member, node);
|
this.newline();
|
}
|
|
this.dedent();
|
this.rightBrace();
|
} else {
|
this.token("}");
|
}
|
}
|
|
function TSArrayType(node) {
|
this.print(node.elementType, node);
|
this.token("[]");
|
}
|
|
function TSTupleType(node) {
|
this.token("[");
|
this.printList(node.elementTypes, node);
|
this.token("]");
|
}
|
|
function TSOptionalType(node) {
|
this.print(node.typeAnnotation, node);
|
this.token("?");
|
}
|
|
function TSRestType(node) {
|
this.token("...");
|
this.print(node.typeAnnotation, node);
|
}
|
|
function TSNamedTupleMember(node) {
|
this.print(node.label, node);
|
if (node.optional) this.token("?");
|
this.token(":");
|
this.space();
|
this.print(node.elementType, node);
|
}
|
|
function TSUnionType(node) {
|
this.tsPrintUnionOrIntersectionType(node, "|");
|
}
|
|
function TSIntersectionType(node) {
|
this.tsPrintUnionOrIntersectionType(node, "&");
|
}
|
|
function tsPrintUnionOrIntersectionType(node, sep) {
|
this.printJoin(node.types, node, {
|
separator() {
|
this.space();
|
this.token(sep);
|
this.space();
|
}
|
|
});
|
}
|
|
function TSConditionalType(node) {
|
this.print(node.checkType);
|
this.space();
|
this.word("extends");
|
this.space();
|
this.print(node.extendsType);
|
this.space();
|
this.token("?");
|
this.space();
|
this.print(node.trueType);
|
this.space();
|
this.token(":");
|
this.space();
|
this.print(node.falseType);
|
}
|
|
function TSInferType(node) {
|
this.token("infer");
|
this.space();
|
this.print(node.typeParameter);
|
}
|
|
function TSParenthesizedType(node) {
|
this.token("(");
|
this.print(node.typeAnnotation, node);
|
this.token(")");
|
}
|
|
function TSTypeOperator(node) {
|
this.word(node.operator);
|
this.space();
|
this.print(node.typeAnnotation, node);
|
}
|
|
function TSIndexedAccessType(node) {
|
this.print(node.objectType, node);
|
this.token("[");
|
this.print(node.indexType, node);
|
this.token("]");
|
}
|
|
function TSMappedType(node) {
|
const {
|
nameType,
|
optional,
|
readonly,
|
typeParameter
|
} = node;
|
this.token("{");
|
this.space();
|
|
if (readonly) {
|
tokenIfPlusMinus(this, readonly);
|
this.word("readonly");
|
this.space();
|
}
|
|
this.token("[");
|
this.word(typeParameter.name);
|
this.space();
|
this.word("in");
|
this.space();
|
this.print(typeParameter.constraint, typeParameter);
|
|
if (nameType) {
|
this.space();
|
this.word("as");
|
this.space();
|
this.print(nameType, node);
|
}
|
|
this.token("]");
|
|
if (optional) {
|
tokenIfPlusMinus(this, optional);
|
this.token("?");
|
}
|
|
this.token(":");
|
this.space();
|
this.print(node.typeAnnotation, node);
|
this.space();
|
this.token("}");
|
}
|
|
function tokenIfPlusMinus(self, tok) {
|
if (tok !== true) {
|
self.token(tok);
|
}
|
}
|
|
function TSLiteralType(node) {
|
this.print(node.literal, node);
|
}
|
|
function TSExpressionWithTypeArguments(node) {
|
this.print(node.expression, node);
|
this.print(node.typeParameters, node);
|
}
|
|
function TSInterfaceDeclaration(node) {
|
const {
|
declare,
|
id,
|
typeParameters,
|
extends: extendz,
|
body
|
} = node;
|
|
if (declare) {
|
this.word("declare");
|
this.space();
|
}
|
|
this.word("interface");
|
this.space();
|
this.print(id, node);
|
this.print(typeParameters, node);
|
|
if (extendz != null && extendz.length) {
|
this.space();
|
this.word("extends");
|
this.space();
|
this.printList(extendz, node);
|
}
|
|
this.space();
|
this.print(body, node);
|
}
|
|
function TSInterfaceBody(node) {
|
this.tsPrintTypeLiteralOrInterfaceBody(node.body, node);
|
}
|
|
function TSTypeAliasDeclaration(node) {
|
const {
|
declare,
|
id,
|
typeParameters,
|
typeAnnotation
|
} = node;
|
|
if (declare) {
|
this.word("declare");
|
this.space();
|
}
|
|
this.word("type");
|
this.space();
|
this.print(id, node);
|
this.print(typeParameters, node);
|
this.space();
|
this.token("=");
|
this.space();
|
this.print(typeAnnotation, node);
|
this.token(";");
|
}
|
|
function TSAsExpression(node) {
|
const {
|
expression,
|
typeAnnotation
|
} = node;
|
this.print(expression, node);
|
this.space();
|
this.word("as");
|
this.space();
|
this.print(typeAnnotation, node);
|
}
|
|
function TSTypeAssertion(node) {
|
const {
|
typeAnnotation,
|
expression
|
} = node;
|
this.token("<");
|
this.print(typeAnnotation, node);
|
this.token(">");
|
this.space();
|
this.print(expression, node);
|
}
|
|
function TSEnumDeclaration(node) {
|
const {
|
declare,
|
const: isConst,
|
id,
|
members
|
} = node;
|
|
if (declare) {
|
this.word("declare");
|
this.space();
|
}
|
|
if (isConst) {
|
this.word("const");
|
this.space();
|
}
|
|
this.word("enum");
|
this.space();
|
this.print(id, node);
|
this.space();
|
this.tsPrintBraced(members, node);
|
}
|
|
function TSEnumMember(node) {
|
const {
|
id,
|
initializer
|
} = node;
|
this.print(id, node);
|
|
if (initializer) {
|
this.space();
|
this.token("=");
|
this.space();
|
this.print(initializer, node);
|
}
|
|
this.token(",");
|
}
|
|
function TSModuleDeclaration(node) {
|
const {
|
declare,
|
id
|
} = node;
|
|
if (declare) {
|
this.word("declare");
|
this.space();
|
}
|
|
if (!node.global) {
|
this.word(id.type === "Identifier" ? "namespace" : "module");
|
this.space();
|
}
|
|
this.print(id, node);
|
|
if (!node.body) {
|
this.token(";");
|
return;
|
}
|
|
let body = node.body;
|
|
while (body.type === "TSModuleDeclaration") {
|
this.token(".");
|
this.print(body.id, body);
|
body = body.body;
|
}
|
|
this.space();
|
this.print(body, node);
|
}
|
|
function TSModuleBlock(node) {
|
this.tsPrintBraced(node.body, node);
|
}
|
|
function TSImportType(node) {
|
const {
|
argument,
|
qualifier,
|
typeParameters
|
} = node;
|
this.word("import");
|
this.token("(");
|
this.print(argument, node);
|
this.token(")");
|
|
if (qualifier) {
|
this.token(".");
|
this.print(qualifier, node);
|
}
|
|
if (typeParameters) {
|
this.print(typeParameters, node);
|
}
|
}
|
|
function TSImportEqualsDeclaration(node) {
|
const {
|
isExport,
|
id,
|
moduleReference
|
} = node;
|
|
if (isExport) {
|
this.word("export");
|
this.space();
|
}
|
|
this.word("import");
|
this.space();
|
this.print(id, node);
|
this.space();
|
this.token("=");
|
this.space();
|
this.print(moduleReference, node);
|
this.token(";");
|
}
|
|
function TSExternalModuleReference(node) {
|
this.token("require(");
|
this.print(node.expression, node);
|
this.token(")");
|
}
|
|
function TSNonNullExpression(node) {
|
this.print(node.expression, node);
|
this.token("!");
|
}
|
|
function TSExportAssignment(node) {
|
this.word("export");
|
this.space();
|
this.token("=");
|
this.space();
|
this.print(node.expression, node);
|
this.token(";");
|
}
|
|
function TSNamespaceExportDeclaration(node) {
|
this.word("export");
|
this.space();
|
this.word("as");
|
this.space();
|
this.word("namespace");
|
this.space();
|
this.print(node.id, node);
|
}
|
|
function tsPrintSignatureDeclarationBase(node) {
|
const {
|
typeParameters,
|
parameters
|
} = node;
|
this.print(typeParameters, node);
|
this.token("(");
|
|
this._parameters(parameters, node);
|
|
this.token(")");
|
this.print(node.typeAnnotation, node);
|
}
|
|
function tsPrintClassMemberModifiers(node, isField) {
|
if (isField && node.declare) {
|
this.word("declare");
|
this.space();
|
}
|
|
if (node.accessibility) {
|
this.word(node.accessibility);
|
this.space();
|
}
|
|
if (node.static) {
|
this.word("static");
|
this.space();
|
}
|
|
if (node.override) {
|
this.word("override");
|
this.space();
|
}
|
|
if (node.abstract) {
|
this.word("abstract");
|
this.space();
|
}
|
|
if (isField && node.readonly) {
|
this.word("readonly");
|
this.space();
|
}
|
}
|
