diff options
Diffstat (limited to 'node_modules/babel-plugin-transform-simplify-comparison-operators')
3 files changed, 172 insertions, 0 deletions
diff --git a/node_modules/babel-plugin-transform-simplify-comparison-operators/README.md b/node_modules/babel-plugin-transform-simplify-comparison-operators/README.md new file mode 100644 index 00000000..3cd9f2f9 --- /dev/null +++ b/node_modules/babel-plugin-transform-simplify-comparison-operators/README.md @@ -0,0 +1,49 @@ +# babel-plugin-transform-simplify-comparison-operators + +Convert `===` and `!==` to `==` and `!=` if their types are inferred to be the same. + +## Example + +**In** + +```javascript +typeof foo === "object"; +``` + +**Out** + +```javascript +typeof foo == "object"; +``` + +## Installation + +```sh +npm install babel-plugin-transform-simplify-comparison-operators --save-dev +``` + +## Usage + +### Via `.babelrc` (Recommended) + +**.babelrc** + +```json +{ + "plugins": ["transform-simplify-comparison-operators"] +} +``` + +### Via CLI + +```sh +babel --plugins transform-simplify-comparison-operators script.js +``` + +### Via Node API + +```javascript +require("@babel/core").transform("code", { + plugins: ["transform-simplify-comparison-operators"] +}); +``` diff --git a/node_modules/babel-plugin-transform-simplify-comparison-operators/lib/index.js b/node_modules/babel-plugin-transform-simplify-comparison-operators/lib/index.js new file mode 100644 index 00000000..008b34a2 --- /dev/null +++ b/node_modules/babel-plugin-transform-simplify-comparison-operators/lib/index.js @@ -0,0 +1,109 @@ +"use strict"; + +module.exports = function ({ + types: t +}) { + // custom implementation of getTypeAnnotation that fixes + // the type information that is lost during sequence expression transformation + // https://github.com/babel/minify/issues/323 + function customTypeAnnotation(path) { + if (path.typeAnnotation) { + return path.typeAnnotation; + } // We are not handling the case of literals and other base types + // since they are already handled via getTypeAnnotation + + + const node = path.node; + const binding = path.parentPath.scope.getBinding(node.name); + const types = []; + + if (binding && binding.constantViolations) { + if (binding.identifier.typeAnnotation) { + return binding.identifier.typeAnnotation; + } + + if (binding.constantViolations) { + const violations = binding.constantViolations; + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = violations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + let violation = _step.value; + types.push(violation.getTypeAnnotation()); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return != null) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + } + } + + if (types.length > 0) { + return t.createUnionTypeAnnotation(types); + } + + return types; + } // Based on the type inference in Babel + + + function baseTypeStrictlyMatches(left, right) { + let leftTypes, rightTypes; + + if (t.isIdentifier(left)) { + leftTypes = customTypeAnnotation(left); + } else if (t.isIdentifier(right)) { + rightTypes = customTypeAnnotation(right); + } // Early exit + + + if (t.isAnyTypeAnnotation(leftTypes) || t.isAnyTypeAnnotation(rightTypes)) { + return false; + } + + leftTypes = [].concat(leftTypes, left.getTypeAnnotation()); + rightTypes = [].concat(rightTypes, right.getTypeAnnotation()); + leftTypes = t.createUnionTypeAnnotation(leftTypes); + rightTypes = t.createUnionTypeAnnotation(rightTypes); + + if (!t.isAnyTypeAnnotation(leftTypes) && t.isFlowBaseAnnotation(leftTypes)) { + return leftTypes.type === rightTypes.type; + } + } + + return { + name: "transform-simplify-comparison-operators", + visitor: { + // simplify comparison operations if we're 100% certain + // that each value will always be of the same type + BinaryExpression(path) { + const node = path.node; + const op = node.operator; + + if (op !== "===" && op !== "!==") { + return; + } + + const left = path.get("left"); + const right = path.get("right"); + const strictMatch = baseTypeStrictlyMatches(left, right); + + if (strictMatch) { + node.operator = node.operator.slice(0, -1); + } + } + + } + }; +};
\ No newline at end of file diff --git a/node_modules/babel-plugin-transform-simplify-comparison-operators/package.json b/node_modules/babel-plugin-transform-simplify-comparison-operators/package.json new file mode 100644 index 00000000..70b27434 --- /dev/null +++ b/node_modules/babel-plugin-transform-simplify-comparison-operators/package.json @@ -0,0 +1,14 @@ +{ + "name": "babel-plugin-transform-simplify-comparison-operators", + "version": "6.9.4", + "description": "Convert === and !== to == and != if their types are inferred to be the same.", + "keywords": [ + "babel-plugin" + ], + "homepage": "https://github.com/babel/minify#readme", + "bugs": "https://github.com/babel/minify/issues", + "license": "MIT", + "author": "amasad", + "main": "lib/index.js", + "repository": "https://github.com/babel/minify/tree/master/packages/babel-plugin-transform-simplify-comparison-operators" +} |