470 lines
14 KiB
JavaScript
470 lines
14 KiB
JavaScript
"use strict";
|
|
|
|
var _utils = require("./utils");
|
|
|
|
var _core = require("./core");
|
|
|
|
var _is = require("../validators/is");
|
|
|
|
const defineType = (0, _utils.defineAliasedType)("TypeScript");
|
|
const bool = (0, _utils.assertValueType)("boolean");
|
|
const tSFunctionTypeAnnotationCommon = {
|
|
returnType: {
|
|
validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
|
|
optional: true
|
|
},
|
|
typeParameters: {
|
|
validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
|
|
optional: true
|
|
}
|
|
};
|
|
defineType("TSParameterProperty", {
|
|
aliases: ["LVal"],
|
|
visitor: ["parameter"],
|
|
fields: {
|
|
accessibility: {
|
|
validate: (0, _utils.assertOneOf)("public", "private", "protected"),
|
|
optional: true
|
|
},
|
|
readonly: {
|
|
validate: (0, _utils.assertValueType)("boolean"),
|
|
optional: true
|
|
},
|
|
parameter: {
|
|
validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
|
|
},
|
|
override: {
|
|
validate: (0, _utils.assertValueType)("boolean"),
|
|
optional: true
|
|
},
|
|
decorators: {
|
|
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
|
|
optional: true
|
|
}
|
|
}
|
|
});
|
|
defineType("TSDeclareFunction", {
|
|
aliases: ["Statement", "Declaration"],
|
|
visitor: ["id", "typeParameters", "params", "returnType"],
|
|
fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
|
|
});
|
|
defineType("TSDeclareMethod", {
|
|
visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
|
|
fields: Object.assign({}, _core.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
|
|
});
|
|
defineType("TSQualifiedName", {
|
|
aliases: ["TSEntityName"],
|
|
visitor: ["left", "right"],
|
|
fields: {
|
|
left: (0, _utils.validateType)("TSEntityName"),
|
|
right: (0, _utils.validateType)("Identifier")
|
|
}
|
|
});
|
|
const signatureDeclarationCommon = {
|
|
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
|
|
["parameters"]: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
|
|
["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation")
|
|
};
|
|
const callConstructSignatureDeclaration = {
|
|
aliases: ["TSTypeElement"],
|
|
visitor: ["typeParameters", "parameters", "typeAnnotation"],
|
|
fields: signatureDeclarationCommon
|
|
};
|
|
defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
|
|
defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
|
|
const namedTypeElementCommon = {
|
|
key: (0, _utils.validateType)("Expression"),
|
|
computed: (0, _utils.validate)(bool),
|
|
optional: (0, _utils.validateOptional)(bool)
|
|
};
|
|
defineType("TSPropertySignature", {
|
|
aliases: ["TSTypeElement"],
|
|
visitor: ["key", "typeAnnotation", "initializer"],
|
|
fields: Object.assign({}, namedTypeElementCommon, {
|
|
readonly: (0, _utils.validateOptional)(bool),
|
|
typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
|
|
initializer: (0, _utils.validateOptionalType)("Expression"),
|
|
kind: {
|
|
validate: (0, _utils.assertOneOf)("get", "set")
|
|
}
|
|
})
|
|
});
|
|
defineType("TSMethodSignature", {
|
|
aliases: ["TSTypeElement"],
|
|
visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
|
|
fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon, {
|
|
kind: {
|
|
validate: (0, _utils.assertOneOf)("method", "get", "set")
|
|
}
|
|
})
|
|
});
|
|
defineType("TSIndexSignature", {
|
|
aliases: ["TSTypeElement"],
|
|
visitor: ["parameters", "typeAnnotation"],
|
|
fields: {
|
|
readonly: (0, _utils.validateOptional)(bool),
|
|
static: (0, _utils.validateOptional)(bool),
|
|
parameters: (0, _utils.validateArrayOfType)("Identifier"),
|
|
typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
|
|
}
|
|
});
|
|
const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
|
|
|
|
for (const type of tsKeywordTypes) {
|
|
defineType(type, {
|
|
aliases: ["TSType", "TSBaseType"],
|
|
visitor: [],
|
|
fields: {}
|
|
});
|
|
}
|
|
|
|
defineType("TSThisType", {
|
|
aliases: ["TSType", "TSBaseType"],
|
|
visitor: [],
|
|
fields: {}
|
|
});
|
|
const fnOrCtrBase = {
|
|
aliases: ["TSType"],
|
|
visitor: ["typeParameters", "parameters", "typeAnnotation"]
|
|
};
|
|
defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, {
|
|
fields: signatureDeclarationCommon
|
|
}));
|
|
defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, {
|
|
fields: Object.assign({}, signatureDeclarationCommon, {
|
|
abstract: (0, _utils.validateOptional)(bool)
|
|
})
|
|
}));
|
|
defineType("TSTypeReference", {
|
|
aliases: ["TSType"],
|
|
visitor: ["typeName", "typeParameters"],
|
|
fields: {
|
|
typeName: (0, _utils.validateType)("TSEntityName"),
|
|
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
|
|
}
|
|
});
|
|
defineType("TSTypePredicate", {
|
|
aliases: ["TSType"],
|
|
visitor: ["parameterName", "typeAnnotation"],
|
|
builder: ["parameterName", "typeAnnotation", "asserts"],
|
|
fields: {
|
|
parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
|
|
typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
|
|
asserts: (0, _utils.validateOptional)(bool)
|
|
}
|
|
});
|
|
defineType("TSTypeQuery", {
|
|
aliases: ["TSType"],
|
|
visitor: ["exprName"],
|
|
fields: {
|
|
exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"])
|
|
}
|
|
});
|
|
defineType("TSTypeLiteral", {
|
|
aliases: ["TSType"],
|
|
visitor: ["members"],
|
|
fields: {
|
|
members: (0, _utils.validateArrayOfType)("TSTypeElement")
|
|
}
|
|
});
|
|
defineType("TSArrayType", {
|
|
aliases: ["TSType"],
|
|
visitor: ["elementType"],
|
|
fields: {
|
|
elementType: (0, _utils.validateType)("TSType")
|
|
}
|
|
});
|
|
defineType("TSTupleType", {
|
|
aliases: ["TSType"],
|
|
visitor: ["elementTypes"],
|
|
fields: {
|
|
elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
|
|
}
|
|
});
|
|
defineType("TSOptionalType", {
|
|
aliases: ["TSType"],
|
|
visitor: ["typeAnnotation"],
|
|
fields: {
|
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
|
}
|
|
});
|
|
defineType("TSRestType", {
|
|
aliases: ["TSType"],
|
|
visitor: ["typeAnnotation"],
|
|
fields: {
|
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
|
}
|
|
});
|
|
defineType("TSNamedTupleMember", {
|
|
visitor: ["label", "elementType"],
|
|
builder: ["label", "elementType", "optional"],
|
|
fields: {
|
|
label: (0, _utils.validateType)("Identifier"),
|
|
optional: {
|
|
validate: bool,
|
|
default: false
|
|
},
|
|
elementType: (0, _utils.validateType)("TSType")
|
|
}
|
|
});
|
|
const unionOrIntersection = {
|
|
aliases: ["TSType"],
|
|
visitor: ["types"],
|
|
fields: {
|
|
types: (0, _utils.validateArrayOfType)("TSType")
|
|
}
|
|
};
|
|
defineType("TSUnionType", unionOrIntersection);
|
|
defineType("TSIntersectionType", unionOrIntersection);
|
|
defineType("TSConditionalType", {
|
|
aliases: ["TSType"],
|
|
visitor: ["checkType", "extendsType", "trueType", "falseType"],
|
|
fields: {
|
|
checkType: (0, _utils.validateType)("TSType"),
|
|
extendsType: (0, _utils.validateType)("TSType"),
|
|
trueType: (0, _utils.validateType)("TSType"),
|
|
falseType: (0, _utils.validateType)("TSType")
|
|
}
|
|
});
|
|
defineType("TSInferType", {
|
|
aliases: ["TSType"],
|
|
visitor: ["typeParameter"],
|
|
fields: {
|
|
typeParameter: (0, _utils.validateType)("TSTypeParameter")
|
|
}
|
|
});
|
|
defineType("TSParenthesizedType", {
|
|
aliases: ["TSType"],
|
|
visitor: ["typeAnnotation"],
|
|
fields: {
|
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
|
}
|
|
});
|
|
defineType("TSTypeOperator", {
|
|
aliases: ["TSType"],
|
|
visitor: ["typeAnnotation"],
|
|
fields: {
|
|
operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
|
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
|
}
|
|
});
|
|
defineType("TSIndexedAccessType", {
|
|
aliases: ["TSType"],
|
|
visitor: ["objectType", "indexType"],
|
|
fields: {
|
|
objectType: (0, _utils.validateType)("TSType"),
|
|
indexType: (0, _utils.validateType)("TSType")
|
|
}
|
|
});
|
|
defineType("TSMappedType", {
|
|
aliases: ["TSType"],
|
|
visitor: ["typeParameter", "typeAnnotation", "nameType"],
|
|
fields: {
|
|
readonly: (0, _utils.validateOptional)(bool),
|
|
typeParameter: (0, _utils.validateType)("TSTypeParameter"),
|
|
optional: (0, _utils.validateOptional)(bool),
|
|
typeAnnotation: (0, _utils.validateOptionalType)("TSType"),
|
|
nameType: (0, _utils.validateOptionalType)("TSType")
|
|
}
|
|
});
|
|
defineType("TSLiteralType", {
|
|
aliases: ["TSType", "TSBaseType"],
|
|
visitor: ["literal"],
|
|
fields: {
|
|
literal: {
|
|
validate: function () {
|
|
const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral");
|
|
const unaryOperator = (0, _utils.assertOneOf)("-");
|
|
const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral");
|
|
|
|
function validator(parent, key, node) {
|
|
if ((0, _is.default)("UnaryExpression", node)) {
|
|
unaryOperator(node, "operator", node.operator);
|
|
unaryExpression(node, "argument", node.argument);
|
|
} else {
|
|
literal(parent, key, node);
|
|
}
|
|
}
|
|
|
|
validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "UnaryExpression"];
|
|
return validator;
|
|
}()
|
|
}
|
|
}
|
|
});
|
|
defineType("TSExpressionWithTypeArguments", {
|
|
aliases: ["TSType"],
|
|
visitor: ["expression", "typeParameters"],
|
|
fields: {
|
|
expression: (0, _utils.validateType)("TSEntityName"),
|
|
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
|
|
}
|
|
});
|
|
defineType("TSInterfaceDeclaration", {
|
|
aliases: ["Statement", "Declaration"],
|
|
visitor: ["id", "typeParameters", "extends", "body"],
|
|
fields: {
|
|
declare: (0, _utils.validateOptional)(bool),
|
|
id: (0, _utils.validateType)("Identifier"),
|
|
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
|
|
extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
|
|
body: (0, _utils.validateType)("TSInterfaceBody")
|
|
}
|
|
});
|
|
defineType("TSInterfaceBody", {
|
|
visitor: ["body"],
|
|
fields: {
|
|
body: (0, _utils.validateArrayOfType)("TSTypeElement")
|
|
}
|
|
});
|
|
defineType("TSTypeAliasDeclaration", {
|
|
aliases: ["Statement", "Declaration"],
|
|
visitor: ["id", "typeParameters", "typeAnnotation"],
|
|
fields: {
|
|
declare: (0, _utils.validateOptional)(bool),
|
|
id: (0, _utils.validateType)("Identifier"),
|
|
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
|
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
|
}
|
|
});
|
|
defineType("TSAsExpression", {
|
|
aliases: ["Expression"],
|
|
visitor: ["expression", "typeAnnotation"],
|
|
fields: {
|
|
expression: (0, _utils.validateType)("Expression"),
|
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
|
}
|
|
});
|
|
defineType("TSTypeAssertion", {
|
|
aliases: ["Expression"],
|
|
visitor: ["typeAnnotation", "expression"],
|
|
fields: {
|
|
typeAnnotation: (0, _utils.validateType)("TSType"),
|
|
expression: (0, _utils.validateType)("Expression")
|
|
}
|
|
});
|
|
defineType("TSEnumDeclaration", {
|
|
aliases: ["Statement", "Declaration"],
|
|
visitor: ["id", "members"],
|
|
fields: {
|
|
declare: (0, _utils.validateOptional)(bool),
|
|
const: (0, _utils.validateOptional)(bool),
|
|
id: (0, _utils.validateType)("Identifier"),
|
|
members: (0, _utils.validateArrayOfType)("TSEnumMember"),
|
|
initializer: (0, _utils.validateOptionalType)("Expression")
|
|
}
|
|
});
|
|
defineType("TSEnumMember", {
|
|
visitor: ["id", "initializer"],
|
|
fields: {
|
|
id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
|
|
initializer: (0, _utils.validateOptionalType)("Expression")
|
|
}
|
|
});
|
|
defineType("TSModuleDeclaration", {
|
|
aliases: ["Statement", "Declaration"],
|
|
visitor: ["id", "body"],
|
|
fields: {
|
|
declare: (0, _utils.validateOptional)(bool),
|
|
global: (0, _utils.validateOptional)(bool),
|
|
id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
|
|
body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
|
|
}
|
|
});
|
|
defineType("TSModuleBlock", {
|
|
aliases: ["Scopable", "Block", "BlockParent"],
|
|
visitor: ["body"],
|
|
fields: {
|
|
body: (0, _utils.validateArrayOfType)("Statement")
|
|
}
|
|
});
|
|
defineType("TSImportType", {
|
|
aliases: ["TSType"],
|
|
visitor: ["argument", "qualifier", "typeParameters"],
|
|
fields: {
|
|
argument: (0, _utils.validateType)("StringLiteral"),
|
|
qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
|
|
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
|
|
}
|
|
});
|
|
defineType("TSImportEqualsDeclaration", {
|
|
aliases: ["Statement"],
|
|
visitor: ["id", "moduleReference"],
|
|
fields: {
|
|
isExport: (0, _utils.validate)(bool),
|
|
id: (0, _utils.validateType)("Identifier"),
|
|
moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]),
|
|
importKind: {
|
|
validate: (0, _utils.assertOneOf)("type", "value"),
|
|
optional: true
|
|
}
|
|
}
|
|
});
|
|
defineType("TSExternalModuleReference", {
|
|
visitor: ["expression"],
|
|
fields: {
|
|
expression: (0, _utils.validateType)("StringLiteral")
|
|
}
|
|
});
|
|
defineType("TSNonNullExpression", {
|
|
aliases: ["Expression"],
|
|
visitor: ["expression"],
|
|
fields: {
|
|
expression: (0, _utils.validateType)("Expression")
|
|
}
|
|
});
|
|
defineType("TSExportAssignment", {
|
|
aliases: ["Statement"],
|
|
visitor: ["expression"],
|
|
fields: {
|
|
expression: (0, _utils.validateType)("Expression")
|
|
}
|
|
});
|
|
defineType("TSNamespaceExportDeclaration", {
|
|
aliases: ["Statement"],
|
|
visitor: ["id"],
|
|
fields: {
|
|
id: (0, _utils.validateType)("Identifier")
|
|
}
|
|
});
|
|
defineType("TSTypeAnnotation", {
|
|
visitor: ["typeAnnotation"],
|
|
fields: {
|
|
typeAnnotation: {
|
|
validate: (0, _utils.assertNodeType)("TSType")
|
|
}
|
|
}
|
|
});
|
|
defineType("TSTypeParameterInstantiation", {
|
|
visitor: ["params"],
|
|
fields: {
|
|
params: {
|
|
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
|
|
}
|
|
}
|
|
});
|
|
defineType("TSTypeParameterDeclaration", {
|
|
visitor: ["params"],
|
|
fields: {
|
|
params: {
|
|
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
|
|
}
|
|
}
|
|
});
|
|
defineType("TSTypeParameter", {
|
|
builder: ["constraint", "default", "name"],
|
|
visitor: ["constraint", "default"],
|
|
fields: {
|
|
name: {
|
|
validate: (0, _utils.assertValueType)("string")
|
|
},
|
|
constraint: {
|
|
validate: (0, _utils.assertNodeType)("TSType"),
|
|
optional: true
|
|
},
|
|
default: {
|
|
validate: (0, _utils.assertNodeType)("TSType"),
|
|
optional: true
|
|
}
|
|
}
|
|
}); |