401 lines
No EOL
13 KiB
JavaScript
401 lines
No EOL
13 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = void 0;
|
|
|
|
var _utils = _interopRequireWildcard(require("./utils"));
|
|
|
|
var _core = require("./core");
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; 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: {
|
|
validate: (0, _utils.assertValueType)("boolean"),
|
|
optional: true
|
|
},
|
|
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")))
|
|
}
|
|
}
|
|
});
|
|
(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")
|
|
}
|
|
}
|
|
}); |