| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = void 0; |
| |
| 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; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { 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; } |
| |
| (0, _utils.default)("AssignmentPattern", { |
| visitor: ["left", "right", "decorators"], |
| builder: ["left", "right"], |
| aliases: ["Pattern", "PatternLike", "LVal"], |
| fields: Object.assign({}, _core.patternLikeCommon, { |
| left: { |
| validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression") |
| }, |
| right: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))) |
| } |
| }) |
| }); |
| (0, _utils.default)("ArrayPattern", { |
| visitor: ["elements", "typeAnnotation"], |
| builder: ["elements"], |
| aliases: ["Pattern", "PatternLike", "LVal"], |
| fields: Object.assign({}, _core.patternLikeCommon, { |
| elements: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("PatternLike"))) |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))) |
| } |
| }) |
| }); |
| (0, _utils.default)("ArrowFunctionExpression", { |
| builder: ["params", "body", "async"], |
| visitor: ["params", "body", "returnType", "typeParameters"], |
| aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"], |
| fields: Object.assign({}, _core.functionCommon, {}, _core.functionTypeAnnotationCommon, { |
| expression: { |
| validate: (0, _utils.assertValueType)("boolean") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("BlockStatement", "Expression") |
| } |
| }) |
| }); |
| (0, _utils.default)("ClassBody", { |
| visitor: ["body"], |
| fields: { |
| body: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "TSDeclareMethod", "TSIndexSignature"))) |
| } |
| } |
| }); |
| const classCommon = { |
| typeParameters: { |
| validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"), |
| optional: true |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("ClassBody") |
| }, |
| superClass: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| superTypeParameters: { |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), |
| optional: true |
| }, |
| implements: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))), |
| optional: true |
| } |
| }; |
| (0, _utils.default)("ClassDeclaration", { |
| builder: ["id", "superClass", "body", "decorators"], |
| visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"], |
| aliases: ["Scopable", "Class", "Statement", "Declaration", "Pureish"], |
| fields: Object.assign({}, classCommon, { |
| declare: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| abstract: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| id: { |
| validate: (0, _utils.assertNodeType)("Identifier"), |
| optional: true |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| } |
| }) |
| }); |
| (0, _utils.default)("ClassExpression", { |
| inherits: "ClassDeclaration", |
| aliases: ["Scopable", "Class", "Expression", "Pureish"], |
| fields: Object.assign({}, classCommon, { |
| id: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("Identifier") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("ClassBody") |
| }, |
| superClass: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| } |
| }) |
| }); |
| (0, _utils.default)("ExportAllDeclaration", { |
| visitor: ["source"], |
| aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], |
| fields: { |
| source: { |
| validate: (0, _utils.assertNodeType)("StringLiteral") |
| } |
| } |
| }); |
| (0, _utils.default)("ExportDefaultDeclaration", { |
| visitor: ["declaration"], |
| aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], |
| fields: { |
| declaration: { |
| validate: (0, _utils.assertNodeType)("FunctionDeclaration", "TSDeclareFunction", "ClassDeclaration", "Expression") |
| } |
| } |
| }); |
| (0, _utils.default)("ExportNamedDeclaration", { |
| visitor: ["declaration", "specifiers", "source"], |
| aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"], |
| fields: { |
| declaration: { |
| validate: (0, _utils.assertNodeType)("Declaration"), |
| optional: true |
| }, |
| specifiers: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier"))) |
| }, |
| source: { |
| validate: (0, _utils.assertNodeType)("StringLiteral"), |
| optional: true |
| }, |
| exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")) |
| } |
| }); |
| (0, _utils.default)("ExportSpecifier", { |
| visitor: ["local", "exported"], |
| aliases: ["ModuleSpecifier"], |
| fields: { |
| local: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| }, |
| exported: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| } |
| } |
| }); |
| (0, _utils.default)("ForOfStatement", { |
| visitor: ["left", "right", "body"], |
| aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"], |
| fields: { |
| left: { |
| validate: (0, _utils.assertNodeType)("VariableDeclaration", "LVal") |
| }, |
| right: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| body: { |
| validate: (0, _utils.assertNodeType)("Statement") |
| }, |
| await: { |
| default: false, |
| validate: (0, _utils.assertValueType)("boolean") |
| } |
| } |
| }); |
| (0, _utils.default)("ImportDeclaration", { |
| visitor: ["specifiers", "source"], |
| aliases: ["Statement", "Declaration", "ModuleDeclaration"], |
| fields: { |
| specifiers: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"))) |
| }, |
| source: { |
| validate: (0, _utils.assertNodeType)("StringLiteral") |
| }, |
| importKind: { |
| validate: (0, _utils.assertOneOf)("type", "typeof", "value"), |
| optional: true |
| } |
| } |
| }); |
| (0, _utils.default)("ImportDefaultSpecifier", { |
| visitor: ["local"], |
| aliases: ["ModuleSpecifier"], |
| fields: { |
| local: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| } |
| } |
| }); |
| (0, _utils.default)("ImportNamespaceSpecifier", { |
| visitor: ["local"], |
| aliases: ["ModuleSpecifier"], |
| fields: { |
| local: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| } |
| } |
| }); |
| (0, _utils.default)("ImportSpecifier", { |
| visitor: ["local", "imported"], |
| aliases: ["ModuleSpecifier"], |
| fields: { |
| local: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| }, |
| imported: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| }, |
| importKind: { |
| validate: (0, _utils.assertOneOf)("type", "typeof"), |
| optional: true |
| } |
| } |
| }); |
| (0, _utils.default)("MetaProperty", { |
| visitor: ["meta", "property"], |
| aliases: ["Expression"], |
| fields: { |
| meta: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| }, |
| property: { |
| validate: (0, _utils.assertNodeType)("Identifier") |
| } |
| } |
| }); |
| const classMethodOrPropertyCommon = { |
| abstract: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| accessibility: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")), |
| optional: true |
| }, |
| static: { |
| default: false, |
| validate: (0, _utils.assertValueType)("boolean") |
| }, |
| computed: { |
| default: false, |
| validate: (0, _utils.assertValueType)("boolean") |
| }, |
| optional: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| optional: true |
| }, |
| key: { |
| validate: (0, _utils.chain)(function () { |
| const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral"); |
| const computed = (0, _utils.assertNodeType)("Expression"); |
| return function (node, key, val) { |
| const validator = node.computed ? computed : normal; |
| validator(node, key, val); |
| }; |
| }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression")) |
| } |
| }; |
| exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon; |
| const classMethodOrDeclareMethodCommon = Object.assign({}, _core.functionCommon, {}, classMethodOrPropertyCommon, { |
| kind: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("get", "set", "method", "constructor")), |
| default: "method" |
| }, |
| access: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")), |
| optional: true |
| }, |
| decorators: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))), |
| optional: true |
| } |
| }); |
| exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon; |
| (0, _utils.default)("ClassMethod", { |
| aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"], |
| builder: ["kind", "key", "params", "body", "computed", "static"], |
| visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"], |
| fields: Object.assign({}, classMethodOrDeclareMethodCommon, {}, _core.functionTypeAnnotationCommon, { |
| body: { |
| validate: (0, _utils.assertNodeType)("BlockStatement") |
| } |
| }) |
| }); |
| (0, _utils.default)("ObjectPattern", { |
| visitor: ["properties", "typeAnnotation", "decorators"], |
| builder: ["properties"], |
| aliases: ["Pattern", "PatternLike", "LVal"], |
| fields: Object.assign({}, _core.patternLikeCommon, { |
| properties: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty"))) |
| } |
| }) |
| }); |
| (0, _utils.default)("SpreadElement", { |
| visitor: ["argument"], |
| aliases: ["UnaryLike"], |
| deprecatedAlias: "SpreadProperty", |
| fields: { |
| argument: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| } |
| }); |
| (0, _utils.default)("Super", { |
| aliases: ["Expression"] |
| }); |
| (0, _utils.default)("TaggedTemplateExpression", { |
| visitor: ["tag", "quasi"], |
| aliases: ["Expression"], |
| fields: { |
| tag: { |
| validate: (0, _utils.assertNodeType)("Expression") |
| }, |
| quasi: { |
| validate: (0, _utils.assertNodeType)("TemplateLiteral") |
| }, |
| typeParameters: { |
| validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"), |
| optional: true |
| } |
| } |
| }); |
| (0, _utils.default)("TemplateElement", { |
| builder: ["value", "tail"], |
| fields: { |
| value: { |
| validate: (0, _utils.assertShape)({ |
| raw: { |
| validate: (0, _utils.assertValueType)("string") |
| }, |
| cooked: { |
| validate: (0, _utils.assertValueType)("string"), |
| optional: true |
| } |
| }) |
| }, |
| tail: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| default: false |
| } |
| } |
| }); |
| (0, _utils.default)("TemplateLiteral", { |
| visitor: ["quasis", "expressions"], |
| aliases: ["Expression", "Literal"], |
| fields: { |
| quasis: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement"))) |
| }, |
| expressions: { |
| validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")), function (node, key, val) { |
| if (node.quasis.length !== val.length + 1) { |
| throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`); |
| } |
| }) |
| } |
| } |
| }); |
| (0, _utils.default)("YieldExpression", { |
| builder: ["argument", "delegate"], |
| visitor: ["argument"], |
| aliases: ["Expression", "Terminatorless"], |
| fields: { |
| delegate: { |
| validate: (0, _utils.assertValueType)("boolean"), |
| default: false |
| }, |
| argument: { |
| optional: true, |
| validate: (0, _utils.assertNodeType)("Expression") |
| } |
| } |
| }); |