"use strict";
|
|
var _utils = require("./utils");
|
|
var _core = require("./core");
|
|
var _is = require("../validators/is");
|
|
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
|
}
|
};
|
(0, _utils.default)("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
|
}
|
}
|
});
|
(0, _utils.default)("TSDeclareFunction", {
|
aliases: ["Statement", "Declaration"],
|
visitor: ["id", "typeParameters", "params", "returnType"],
|
fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
|
});
|
(0, _utils.default)("TSDeclareMethod", {
|
visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
|
fields: Object.assign({}, _core.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
|
});
|
(0, _utils.default)("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
|
};
|
(0, _utils.default)("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
|
(0, _utils.default)("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
|
const namedTypeElementCommon = {
|
key: (0, _utils.validateType)("Expression"),
|
computed: (0, _utils.validate)(bool),
|
optional: (0, _utils.validateOptional)(bool)
|
};
|
(0, _utils.default)("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")
|
}
|
})
|
});
|
(0, _utils.default)("TSMethodSignature", {
|
aliases: ["TSTypeElement"],
|
visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
|
fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon, {
|
kind: {
|
validate: (0, _utils.assertOneOf)("method", "get", "set")
|
}
|
})
|
});
|
(0, _utils.default)("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) {
|
(0, _utils.default)(type, {
|
aliases: ["TSType", "TSBaseType"],
|
visitor: [],
|
fields: {}
|
});
|
}
|
|
(0, _utils.default)("TSThisType", {
|
aliases: ["TSType", "TSBaseType"],
|
visitor: [],
|
fields: {}
|
});
|
const fnOrCtrBase = {
|
aliases: ["TSType"],
|
visitor: ["typeParameters", "parameters", "typeAnnotation"]
|
};
|
(0, _utils.default)("TSFunctionType", Object.assign({}, fnOrCtrBase, {
|
fields: signatureDeclarationCommon
|
}));
|
(0, _utils.default)("TSConstructorType", Object.assign({}, fnOrCtrBase, {
|
fields: Object.assign({}, signatureDeclarationCommon, {
|
abstract: (0, _utils.validateOptional)(bool)
|
})
|
}));
|
(0, _utils.default)("TSTypeReference", {
|
aliases: ["TSType"],
|
visitor: ["typeName", "typeParameters"],
|
fields: {
|
typeName: (0, _utils.validateType)("TSEntityName"),
|
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
|
}
|
});
|
(0, _utils.default)("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)
|
}
|
});
|
(0, _utils.default)("TSTypeQuery", {
|
aliases: ["TSType"],
|
visitor: ["exprName"],
|
fields: {
|
exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"])
|
}
|
});
|
(0, _utils.default)("TSTypeLiteral", {
|
aliases: ["TSType"],
|
visitor: ["members"],
|
fields: {
|
members: (0, _utils.validateArrayOfType)("TSTypeElement")
|
}
|
});
|
(0, _utils.default)("TSArrayType", {
|
aliases: ["TSType"],
|
visitor: ["elementType"],
|
fields: {
|
elementType: (0, _utils.validateType)("TSType")
|
}
|
});
|
(0, _utils.default)("TSTupleType", {
|
aliases: ["TSType"],
|
visitor: ["elementTypes"],
|
fields: {
|
elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
|
}
|
});
|
(0, _utils.default)("TSOptionalType", {
|
aliases: ["TSType"],
|
visitor: ["typeAnnotation"],
|
fields: {
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
}
|
});
|
(0, _utils.default)("TSRestType", {
|
aliases: ["TSType"],
|
visitor: ["typeAnnotation"],
|
fields: {
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
}
|
});
|
(0, _utils.default)("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")
|
}
|
};
|
(0, _utils.default)("TSUnionType", unionOrIntersection);
|
(0, _utils.default)("TSIntersectionType", unionOrIntersection);
|
(0, _utils.default)("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")
|
}
|
});
|
(0, _utils.default)("TSInferType", {
|
aliases: ["TSType"],
|
visitor: ["typeParameter"],
|
fields: {
|
typeParameter: (0, _utils.validateType)("TSTypeParameter")
|
}
|
});
|
(0, _utils.default)("TSParenthesizedType", {
|
aliases: ["TSType"],
|
visitor: ["typeAnnotation"],
|
fields: {
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
}
|
});
|
(0, _utils.default)("TSTypeOperator", {
|
aliases: ["TSType"],
|
visitor: ["typeAnnotation"],
|
fields: {
|
operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
}
|
});
|
(0, _utils.default)("TSIndexedAccessType", {
|
aliases: ["TSType"],
|
visitor: ["objectType", "indexType"],
|
fields: {
|
objectType: (0, _utils.validateType)("TSType"),
|
indexType: (0, _utils.validateType)("TSType")
|
}
|
});
|
(0, _utils.default)("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")
|
}
|
});
|
(0, _utils.default)("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;
|
}()
|
}
|
}
|
});
|
(0, _utils.default)("TSExpressionWithTypeArguments", {
|
aliases: ["TSType"],
|
visitor: ["expression", "typeParameters"],
|
fields: {
|
expression: (0, _utils.validateType)("TSEntityName"),
|
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
|
}
|
});
|
(0, _utils.default)("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")
|
}
|
});
|
(0, _utils.default)("TSInterfaceBody", {
|
visitor: ["body"],
|
fields: {
|
body: (0, _utils.validateArrayOfType)("TSTypeElement")
|
}
|
});
|
(0, _utils.default)("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")
|
}
|
});
|
(0, _utils.default)("TSAsExpression", {
|
aliases: ["Expression"],
|
visitor: ["expression", "typeAnnotation"],
|
fields: {
|
expression: (0, _utils.validateType)("Expression"),
|
typeAnnotation: (0, _utils.validateType)("TSType")
|
}
|
});
|
(0, _utils.default)("TSTypeAssertion", {
|
aliases: ["Expression"],
|
visitor: ["typeAnnotation", "expression"],
|
fields: {
|
typeAnnotation: (0, _utils.validateType)("TSType"),
|
expression: (0, _utils.validateType)("Expression")
|
}
|
});
|
(0, _utils.default)("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")
|
}
|
});
|
(0, _utils.default)("TSEnumMember", {
|
visitor: ["id", "initializer"],
|
fields: {
|
id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
|
initializer: (0, _utils.validateOptionalType)("Expression")
|
}
|
});
|
(0, _utils.default)("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"])
|
}
|
});
|
(0, _utils.default)("TSModuleBlock", {
|
aliases: ["Scopable", "Block", "BlockParent"],
|
visitor: ["body"],
|
fields: {
|
body: (0, _utils.validateArrayOfType)("Statement")
|
}
|
});
|
(0, _utils.default)("TSImportType", {
|
aliases: ["TSType"],
|
visitor: ["argument", "qualifier", "typeParameters"],
|
fields: {
|
argument: (0, _utils.validateType)("StringLiteral"),
|
qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
|
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
|
}
|
});
|
(0, _utils.default)("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
|
}
|
}
|
});
|
(0, _utils.default)("TSExternalModuleReference", {
|
visitor: ["expression"],
|
fields: {
|
expression: (0, _utils.validateType)("StringLiteral")
|
}
|
});
|
(0, _utils.default)("TSNonNullExpression", {
|
aliases: ["Expression"],
|
visitor: ["expression"],
|
fields: {
|
expression: (0, _utils.validateType)("Expression")
|
}
|
});
|
(0, _utils.default)("TSExportAssignment", {
|
aliases: ["Statement"],
|
visitor: ["expression"],
|
fields: {
|
expression: (0, _utils.validateType)("Expression")
|
}
|
});
|
(0, _utils.default)("TSNamespaceExportDeclaration", {
|
aliases: ["Statement"],
|
visitor: ["id"],
|
fields: {
|
id: (0, _utils.validateType)("Identifier")
|
}
|
});
|
(0, _utils.default)("TSTypeAnnotation", {
|
visitor: ["typeAnnotation"],
|
fields: {
|
typeAnnotation: {
|
validate: (0, _utils.assertNodeType)("TSType")
|
}
|
}
|
});
|
(0, _utils.default)("TSTypeParameterInstantiation", {
|
visitor: ["params"],
|
fields: {
|
params: {
|
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
|
}
|
}
|
});
|
(0, _utils.default)("TSTypeParameterDeclaration", {
|
visitor: ["params"],
|
fields: {
|
params: {
|
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
|
}
|
}
|
});
|
(0, _utils.default)("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
|
}
|
}
|
});
|
