433 lines
No EOL
14 KiB
JavaScript
433 lines
No EOL
14 KiB
JavaScript
"use strict";
|
|
|
|
var _utils = _interopRequireWildcard(require("./utils"));
|
|
|
|
var _core = require("./core");
|
|
|
|
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
|
|
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")
|
|
}
|
|
}
|
|
});
|
|
(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")
|
|
})
|
|
});
|
|
(0, _utils.default)("TSMethodSignature", {
|
|
aliases: ["TSTypeElement"],
|
|
visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
|
|
fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon)
|
|
});
|
|
(0, _utils.default)("TSIndexSignature", {
|
|
aliases: ["TSTypeElement"],
|
|
visitor: ["parameters", "typeAnnotation"],
|
|
fields: {
|
|
readonly: (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: (0, _utils.validateType)(["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral"])
|
|
}
|
|
});
|
|
(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"])
|
|
}
|
|
});
|
|
(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
|
|
}
|
|
}
|
|
}); |