From 26105034da4fcce7ac883c899d781f016559310d Mon Sep 17 00:00:00 2001 From: ruki Date: Thu, 8 Nov 2018 00:38:48 +0800 Subject: switch to vuepress --- .../README.md | 75 +++++++++++++++++++ .../lib/index.js | 87 ++++++++++++++++++++++ .../package.json | 12 +++ 3 files changed, 174 insertions(+) create mode 100644 node_modules/@babel/helper-member-expression-to-functions/README.md create mode 100644 node_modules/@babel/helper-member-expression-to-functions/lib/index.js create mode 100644 node_modules/@babel/helper-member-expression-to-functions/package.json (limited to 'node_modules/@babel/helper-member-expression-to-functions') diff --git a/node_modules/@babel/helper-member-expression-to-functions/README.md b/node_modules/@babel/helper-member-expression-to-functions/README.md new file mode 100644 index 00000000..31dd4c3c --- /dev/null +++ b/node_modules/@babel/helper-member-expression-to-functions/README.md @@ -0,0 +1,75 @@ +# @babel/helper-member-expression-to-functions + +Helper function to replace certain member expressions with function calls + +## Usage + +> Designed for internal Babel use. + +Traverses the `path` using the supplied `visitor` and an augmented `state`. + +```js +const visitor = { + MemberExpression(memberPath, state) { + + if (someCondition(memberPath)) { + + // The handle method is supplied by memberExpressionToFunctions. + // It should be called whenever a MemberExpression should be + // converted into the proper function calls. + state.handle(memberPath); + + } + + }, +}; + +// The helper requires three special methods on state: `get`, `set`, and +// `call`. +// Optionally, a special `memoize` method may be defined, which gets +// called if the member is in a self-referential update expression. +// Everything else will be passed through as normal. +const state = { + get(memberPath) { + // Return some AST that will get the member + return t.callExpression( + this.file.addHelper('superGet'), + [t.thisExpression(), memberPath.node.property] + ); + }, + + set(memberPath, value) { + // Return some AST that will set the member + return t.callExpression( + this.file.addHelper('superSet'), + [t.thisExpression(), memberPath.node.property, value] + ); + }, + + call(memberPath, args) { + // Return some AST that will call the member with the proper context + // and args + return t.callExpression( + t.memberExpression(this.get(memberPath), t.identifier("apply")), + [t.thisExpression(), t.arrayExpression(args)] + ); + }, + + memoize(memberPath) { + const { node } = memberPath; + if (node.computed) { + MEMOIZED.set(node, ...); + } + }, + + // The handle method is provided by memberExpressionToFunctions. + // handle(memberPath) { ... } + + // Other state stuff is left untouched. + someState: new Set(), +}; + +// Replace all the special MemberExpressions in rootPath, as determined +// by our visitor, using the state methods. +memberExpressionToFunctions(rootPath, visitor, state); +``` diff --git a/node_modules/@babel/helper-member-expression-to-functions/lib/index.js b/node_modules/@babel/helper-member-expression-to-functions/lib/index.js new file mode 100644 index 00000000..938dc918 --- /dev/null +++ b/node_modules/@babel/helper-member-expression-to-functions/lib/index.js @@ -0,0 +1,87 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = memberExpressionToFunctions; + +function t() { + const data = _interopRequireWildcard(require("@babel/types")); + + t = function t() { + return data; + }; + + return data; +} + +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; } } + +const handle = { + handle(member) { + const node = member.node, + parent = member.parent, + parentPath = member.parentPath; + + if (parentPath.isUpdateExpression({ + argument: node + })) { + const operator = parent.operator, + prefix = parent.prefix; + + if (this.memoize) { + this.memoize(member); + } + + const value = t().binaryExpression(operator[0], t().unaryExpression("+", this.get(member)), t().numericLiteral(1)); + + if (prefix) { + parentPath.replaceWith(this.set(member, value)); + } else { + const scope = member.scope; + const ref = scope.generateUidIdentifierBasedOnNode(node); + scope.push({ + id: ref + }); + value.left = t().assignmentExpression("=", t().cloneNode(ref), value.left); + parentPath.replaceWith(t().sequenceExpression([this.set(member, value), t().cloneNode(ref)])); + } + + return; + } + + if (parentPath.isAssignmentExpression({ + left: node + })) { + const operator = parent.operator, + right = parent.right; + let value = right; + + if (operator !== "=") { + if (this.memoize) { + this.memoize(member); + } + + value = t().binaryExpression(operator.slice(0, -1), this.get(member), value); + } + + parentPath.replaceWith(this.set(member, value)); + return; + } + + if (parentPath.isCallExpression({ + callee: node + })) { + const args = parent.arguments; + parentPath.replaceWith(this.call(member, args)); + return; + } + + member.replaceWith(this.get(member)); + } + +}; + +function memberExpressionToFunctions(path, visitor, state) { + path.traverse(visitor, Object.assign({}, state, handle)); +} \ No newline at end of file diff --git a/node_modules/@babel/helper-member-expression-to-functions/package.json b/node_modules/@babel/helper-member-expression-to-functions/package.json new file mode 100644 index 00000000..ce778d9f --- /dev/null +++ b/node_modules/@babel/helper-member-expression-to-functions/package.json @@ -0,0 +1,12 @@ +{ + "name": "@babel/helper-member-expression-to-functions", + "version": "7.0.0-beta.47", + "description": "Helper function to replace certain member expressions with function calls", + "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-member-expression-to-functions", + "license": "MIT", + "main": "lib/index.js", + "author": "Justin Ridgewell ", + "dependencies": { + "@babel/types": "7.0.0-beta.47" + } +} -- cgit v1.2.3