From 4a3524311882d0a68f8cc36b9332a42ad7c889a2 Mon Sep 17 00:00:00 2001 From: Peeyush Kushwaha Date: Tue, 25 Jul 2017 20:16:52 +0530 Subject: [PATCH] Non string computed keys in object-rest-spread (#5757) --- .../misc/regression-4855/expected.js | 7 +- packages/babel-helpers/src/helpers.js | 36 +++++- .../src/index.js | 116 +++++++++++++----- .../object-rest/impure-computed-exec/exec.js | 21 ++++ .../impure-computed-exec/options.json | 3 + .../object-rest/impure-computed/actual.js | 21 ++++ .../object-rest/impure-computed/expected.js | 51 ++++++++ .../non-string-computed-exec/exec.js | 54 ++++++++ .../non-string-computed-exec/options.json | 3 + .../object-rest/non-string-computed/actual.js | 54 ++++++++ .../non-string-computed/expected.js | 52 ++++++++ .../fixtures/object-rest/symbol-exec/exec.js | 20 +++ .../object-rest/symbol-exec/options.json | 6 + .../fixtures/object-rest/symbol/actual.js | 8 ++ .../fixtures/object-rest/symbol/expected.js | 22 ++++ .../variable-destructuring/expected.js | 6 +- .../fixtures/regression/T7178/expected.js | 11 +- .../fixtures/regression/T7178/options.json | 3 +- .../parameter-destructure-rest/expected.js | 6 +- .../parameter-destructure-rest/options.json | 2 +- .../expected.js | 7 +- .../options.json | 2 +- 22 files changed, 450 insertions(+), 61 deletions(-) create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/exec.js create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/options.json create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed/actual.js create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed/expected.js create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/exec.js create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/options.json create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed/actual.js create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed/expected.js create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol-exec/exec.js create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol-exec/options.json create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol/actual.js create mode 100644 packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol/expected.js diff --git a/packages/babel-core/test/fixtures/transformation/misc/regression-4855/expected.js b/packages/babel-core/test/fixtures/transformation/misc/regression-4855/expected.js index 01617b80fe..3480bbd797 100644 --- a/packages/babel-core/test/fixtures/transformation/misc/regression-4855/expected.js +++ b/packages/babel-core/test/fixtures/transformation/misc/regression-4855/expected.js @@ -1,7 +1,8 @@ "use strict"; var _values = values; -value = _values[fieldName]; -rest = babelHelpers.objectWithoutProperties(_values, [fieldName]); +var _fieldName = fieldName; +value = _values[_fieldName]; +rest = babelHelpers.objectWithoutProperties(_values, [_fieldName].map(babelHelpers.toPropertyKey)); _values; -var error = void 0; +var error = void 0; \ No newline at end of file diff --git a/packages/babel-helpers/src/helpers.js b/packages/babel-helpers/src/helpers.js index 8ff523b252..f7ad50c838 100644 --- a/packages/babel-helpers/src/helpers.js +++ b/packages/babel-helpers/src/helpers.js @@ -432,13 +432,29 @@ helpers.objectDestructuringEmpty = template(` `); helpers.objectWithoutProperties = template(` - (function (obj, keys) { + (function (source, excluded) { + if (source == null) return {}; + var target = {}; - for (var i in obj) { - if (keys.indexOf(i) >= 0) continue; - if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; - target[i] = obj[i]; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; } + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + return target; }) `); @@ -594,3 +610,13 @@ helpers.toConsumableArray = template(` } }); `); + +helpers.toPropertyKey = template(` + (function (key) { + if (typeof key === "symbol") { + return key; + } else { + return String(key); + } + }); +`); diff --git a/packages/babel-plugin-transform-object-rest-spread/src/index.js b/packages/babel-plugin-transform-object-rest-spread/src/index.js index 16a78e1dd3..71f2029593 100644 --- a/packages/babel-plugin-transform-object-rest-spread/src/index.js +++ b/packages/babel-plugin-transform-object-rest-spread/src/index.js @@ -21,23 +21,74 @@ export default function({ types: t }) { return false; } - function createObjectSpread(file, props, objRef) { - const restElement = props.pop(); - + // returns an array of all keys of an object, and a status flag indicating if all extracted keys + // were converted to stringLiterals or not + // e.g. extracts {keys: ["a", "b", "3", ++x], allLiteral: false } + // from ast of {a: "foo", b, 3: "bar", [++x]: "baz"} + function extractNormalizedKeys(path) { + const props = path.node.properties; const keys = []; + let allLiteral = true; + for (const prop of props) { - let key = prop.key; - if (t.isIdentifier(key) && !prop.computed) { - key = t.stringLiteral(prop.key.name); + if (t.isIdentifier(prop.key) && !prop.computed) { + // since a key {a: 3} is equivalent to {"a": 3}, use the latter + keys.push(t.stringLiteral(prop.key.name)); + } else if (t.isLiteral(prop.key)) { + keys.push(t.stringLiteral(String(prop.key.value))); + } else { + keys.push(prop.key); + allLiteral = false; } - keys.push(key); + } + + return { keys, allLiteral }; + } + + // replaces impure computed keys with new identifiers + // and returns variable declarators of these new identifiers + function replaceImpureComputedKeys(path) { + const impureComputedPropertyDeclarators = []; + for (const propPath of path.get("properties")) { + const key = propPath.get("key"); + if (propPath.node.computed && !key.isPure()) { + const identifier = path.scope.generateUidIdentifierBasedOnNode( + key.node, + ); + const declarator = t.variableDeclarator(identifier, key.node); + impureComputedPropertyDeclarators.push(declarator); + key.replaceWith(identifier); + } + } + return impureComputedPropertyDeclarators; + } + + //expects path to an object pattern + function createObjectSpread(path, file, objRef) { + const last = path.get("properties").pop(); // note: popping does not mean removal from path + const restElement = t.clone(last.node); + last.remove(); // remove restElement + + const impureComputedPropertyDeclarators = replaceImpureComputedKeys(path); + const { keys, allLiteral } = extractNormalizedKeys(path); + + let keyExpression; + if (!allLiteral) { + // map to toPropertyKey to handle the possible non-string values + keyExpression = t.callExpression( + t.memberExpression(t.arrayExpression(keys), t.identifier("map")), + [file.addHelper("toPropertyKey")], + ); + } else { + keyExpression = t.arrayExpression(keys); } return [ + impureComputedPropertyDeclarators, restElement.argument, t.callExpression(file.addHelper("objectWithoutProperties"), [ objRef, - t.arrayExpression(keys), + keyExpression, ]), ]; } @@ -138,11 +189,16 @@ export default function({ types: t }) { }); } - const [argument, callExpression] = createObjectSpread( - file, - path.parentPath.node.properties, - ref, + const objectPatternPath = path.findParent(path => + path.isObjectPattern(), ); + const [ + impureComputedPropertyDeclarators, + argument, + callExpression, + ] = createObjectSpread(objectPatternPath, file, ref); + + insertionPath.insertBefore(impureComputedPropertyDeclarators); insertionPath.insertAfter( t.variableDeclarator(argument, callExpression), @@ -196,29 +252,29 @@ export default function({ types: t }) { if (leftPath.isObjectPattern() && hasRestElement(leftPath)) { const nodes = []; - let ref; - if ( - path.isCompletionRecord() || - path.parentPath.isExpressionStatement() - ) { - ref = path.scope.generateUidIdentifierBasedOnNode( - path.node.right, - "ref", - ); + const ref = path.scope.generateUidIdentifierBasedOnNode( + path.node.right, + "ref", + ); + nodes.push( + t.variableDeclaration("var", [ + t.variableDeclarator(ref, path.node.right), + ]), + ); + + const [ + impureComputedPropertyDeclarators, + argument, + callExpression, + ] = createObjectSpread(leftPath, file, ref); + + if (impureComputedPropertyDeclarators.length > 0) { nodes.push( - t.variableDeclaration("var", [ - t.variableDeclarator(ref, path.node.right), - ]), + t.variableDeclaration("var", impureComputedPropertyDeclarators), ); } - const [argument, callExpression] = createObjectSpread( - file, - path.node.left.properties, - ref, - ); - const nodeWithoutSpread = t.clone(path.node); nodeWithoutSpread.right = ref; nodes.push(t.expressionStatement(nodeWithoutSpread)); diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/exec.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/exec.js new file mode 100644 index 0000000000..c67476cdee --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/exec.js @@ -0,0 +1,21 @@ +var key, x, y, z; +// impure +key = 1; +var { [key++]: y, ...x } = { 1: 1, a: 1 }; +assert.deepEqual({ a: 1 }, x); +assert.equal(key, 2); +assert.equal(1, y); + +// takes care of the order + +key = 1; +var { [++key]: y, [++key]: z, ...rest} = {2: 2, 3: 3}; +assert.equal(y, 2); +assert.equal(z, 3); + +// pure, computed property should remain as-is +key = 2; +({ [key]: y, z, ...x } = {2: "two", z: "zee"}); +assert.equal(y, "two"); +assert.deepEqual(x, {}); +assert.equal(z, "zee"); diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/options.json b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/options.json new file mode 100644 index 0000000000..7d8c3c204c --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed-exec/options.json @@ -0,0 +1,3 @@ +{ + "minNodeVersion": "6.0.0" +} diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed/actual.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed/actual.js new file mode 100644 index 0000000000..c67476cdee --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed/actual.js @@ -0,0 +1,21 @@ +var key, x, y, z; +// impure +key = 1; +var { [key++]: y, ...x } = { 1: 1, a: 1 }; +assert.deepEqual({ a: 1 }, x); +assert.equal(key, 2); +assert.equal(1, y); + +// takes care of the order + +key = 1; +var { [++key]: y, [++key]: z, ...rest} = {2: 2, 3: 3}; +assert.equal(y, 2); +assert.equal(z, 3); + +// pure, computed property should remain as-is +key = 2; +({ [key]: y, z, ...x } = {2: "two", z: "zee"}); +assert.equal(y, "two"); +assert.deepEqual(x, {}); +assert.equal(z, "zee"); diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed/expected.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed/expected.js new file mode 100644 index 0000000000..39b9ac8041 --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/impure-computed/expected.js @@ -0,0 +1,51 @@ +var key, x, y, z; // impure + +key = 1; + +var _$a = { + 1: 1, + a: 1 +}, + _ref = key++, + { + [_ref]: y +} = _$a, + x = babelHelpers.objectWithoutProperties(_$a, [_ref].map(babelHelpers.toPropertyKey)); + +assert.deepEqual({ + a: 1 +}, x); +assert.equal(key, 2); +assert.equal(1, y); // takes care of the order + +key = 1; + +var _$ = { + 2: 2, + 3: 3 +}, + _ref2 = ++key, + _ref3 = ++key, + { + [_ref2]: y, + [_ref3]: z +} = _$, + rest = babelHelpers.objectWithoutProperties(_$, [_ref2, _ref3].map(babelHelpers.toPropertyKey)); + +assert.equal(y, 2); +assert.equal(z, 3); // pure, computed property should remain as-is + +key = 2; +var _$z = { + 2: "two", + z: "zee" +}; +({ + [key]: y, + z +} = _$z); +x = babelHelpers.objectWithoutProperties(_$z, [key, "z"].map(babelHelpers.toPropertyKey)); +_$z; +assert.equal(y, "two"); +assert.deepEqual(x, {}); +assert.equal(z, "zee"); \ No newline at end of file diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/exec.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/exec.js new file mode 100644 index 0000000000..f328f10843 --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/exec.js @@ -0,0 +1,54 @@ +const a = { + "3": "three", + "foo": "bar" +} + +const { + [3]: omit, + ...rest +} = a; + +assert.deepEqual(rest, {"foo": "bar"}); +assert.equal(omit, "three"); + +const [k1, k2, k3, k4, k5] = [null, undefined, true, false, {toString() { return "warrior"; }}]; +const c = { + [k1]: "1", + [k2]: "2", + [k3]: "3", + [k4]: "4", + [k5]: "5" +}; + +const { + [k1]: v1, + [k2]: v2, + [k3]: v3, + [k4]: v4, + [k5]: v5, + ...vrest +} = c; + +assert.equal(v1, "1"); +assert.equal(v2, "2"); +assert.equal(v3, "3"); +assert.equal(v4, "4"); +assert.equal(v5, "5"); +assert.deepEqual(vrest, {}); + +// shouldn't convert symbols to strings +const sx = Symbol(); +const sy = Symbol(); + +const d = { + [sx]: "sx", + [sy]: "sy" +} + +const { + [sx]: dx, + [sy]: dy +} = d; + +assert.equal(dx, "sx"); +assert.equal(dy, "sy"); diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/options.json b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/options.json new file mode 100644 index 0000000000..7d8c3c204c --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed-exec/options.json @@ -0,0 +1,3 @@ +{ + "minNodeVersion": "6.0.0" +} diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed/actual.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed/actual.js new file mode 100644 index 0000000000..f328f10843 --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed/actual.js @@ -0,0 +1,54 @@ +const a = { + "3": "three", + "foo": "bar" +} + +const { + [3]: omit, + ...rest +} = a; + +assert.deepEqual(rest, {"foo": "bar"}); +assert.equal(omit, "three"); + +const [k1, k2, k3, k4, k5] = [null, undefined, true, false, {toString() { return "warrior"; }}]; +const c = { + [k1]: "1", + [k2]: "2", + [k3]: "3", + [k4]: "4", + [k5]: "5" +}; + +const { + [k1]: v1, + [k2]: v2, + [k3]: v3, + [k4]: v4, + [k5]: v5, + ...vrest +} = c; + +assert.equal(v1, "1"); +assert.equal(v2, "2"); +assert.equal(v3, "3"); +assert.equal(v4, "4"); +assert.equal(v5, "5"); +assert.deepEqual(vrest, {}); + +// shouldn't convert symbols to strings +const sx = Symbol(); +const sy = Symbol(); + +const d = { + [sx]: "sx", + [sy]: "sy" +} + +const { + [sx]: dx, + [sy]: dy +} = d; + +assert.equal(dx, "sx"); +assert.equal(dy, "sy"); diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed/expected.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed/expected.js new file mode 100644 index 0000000000..2d39e0d4c4 --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/non-string-computed/expected.js @@ -0,0 +1,52 @@ +const a = { + "3": "three", + "foo": "bar" +}; +const { + [3]: omit +} = a, + rest = babelHelpers.objectWithoutProperties(a, ["3"]); +assert.deepEqual(rest, { + "foo": "bar" +}); +assert.equal(omit, "three"); +const [k1, k2, k3, k4, k5] = [null, undefined, true, false, { + toString() { + return "warrior"; + } + +}]; +const c = { + [k1]: "1", + [k2]: "2", + [k3]: "3", + [k4]: "4", + [k5]: "5" +}; +const { + [k1]: v1, + [k2]: v2, + [k3]: v3, + [k4]: v4, + [k5]: v5 +} = c, + vrest = babelHelpers.objectWithoutProperties(c, [k1, k2, k3, k4, k5].map(babelHelpers.toPropertyKey)); +assert.equal(v1, "1"); +assert.equal(v2, "2"); +assert.equal(v3, "3"); +assert.equal(v4, "4"); +assert.equal(v5, "5"); +assert.deepEqual(vrest, {}); // shouldn't convert symbols to strings + +const sx = Symbol(); +const sy = Symbol(); +const d = { + [sx]: "sx", + [sy]: "sy" +}; +const { + [sx]: dx, + [sy]: dy +} = d; +assert.equal(dx, "sx"); +assert.equal(dy, "sy"); \ No newline at end of file diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol-exec/exec.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol-exec/exec.js new file mode 100644 index 0000000000..8fb6f1baf2 --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol-exec/exec.js @@ -0,0 +1,20 @@ +const sym = Symbol("test"); +const sym2 = Symbol("not enumerable"); + +const src = { a: "string" }; +Object.defineProperty(src, "b", { value: "not enumerable" }) +Object.defineProperty(src, sym, { enumerable: true, value: "symbol" }); +Object.defineProperty(src, sym2, { value: "not enumerable" }); + +const {...rest} = src; + +assert.strictEqual(rest[sym], "symbol"); +assert.strictEqual(rest.a, "string"); +assert.deepEqual(Object.getOwnPropertyNames(rest), ["a"]); +assert.deepEqual(Object.getOwnPropertySymbols(rest), [sym]); + +const { [sym]: dst, ...noSym } = src; + +assert.strictEqual(dst, "symbol"); +assert.strictEqual(noSym.a, "string"); +assert.deepEqual(Object.getOwnPropertySymbols(noSym), []); diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol-exec/options.json b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol-exec/options.json new file mode 100644 index 0000000000..d06cffe703 --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol-exec/options.json @@ -0,0 +1,6 @@ +{ + "parserOpts": { + "allowReturnOutsideFunction": true + }, + "plugins": [ "transform-es2015-destructuring" ] +} diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol/actual.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol/actual.js new file mode 100644 index 0000000000..498e7abe05 --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol/actual.js @@ -0,0 +1,8 @@ +let { + [Symbol.for("foo")]: foo, + ...rest +} = {}; + +({ [Symbol.for("foo")]: foo, ...rest } = {}); + +if ({ [Symbol.for("foo")]: foo, ...rest } = {}) {} diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol/expected.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol/expected.js new file mode 100644 index 0000000000..5bd3bdec49 --- /dev/null +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/symbol/expected.js @@ -0,0 +1,22 @@ +var _ref3, _Symbol$for3; + +let _ref = {}, + _Symbol$for = Symbol.for("foo"), + { + [_Symbol$for]: foo +} = _ref, + rest = babelHelpers.objectWithoutProperties(_ref, [_Symbol$for].map(babelHelpers.toPropertyKey)); + +var _ref2 = {}; + +var _Symbol$for2 = Symbol.for("foo"); + +({ + [_Symbol$for2]: foo +} = _ref2); +rest = babelHelpers.objectWithoutProperties(_ref2, [_Symbol$for2].map(babelHelpers.toPropertyKey)); +_ref2; + +if (_ref3 = {}, _Symbol$for3 = Symbol.for("foo"), ({ + [_Symbol$for3]: foo +} = _ref3), rest = babelHelpers.objectWithoutProperties(_ref3, [_Symbol$for3].map(babelHelpers.toPropertyKey)), _ref3) {} \ No newline at end of file diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/variable-destructuring/expected.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/variable-destructuring/expected.js index d49aedef19..211de3a015 100644 --- a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/variable-destructuring/expected.js +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/object-rest/variable-destructuring/expected.js @@ -13,7 +13,7 @@ x1++; var { [a]: b } = z, - c = babelHelpers.objectWithoutProperties(z, [a]); + c = babelHelpers.objectWithoutProperties(z, [a].map(babelHelpers.toPropertyKey)); var { x1 } = z, @@ -35,7 +35,7 @@ let { [d]: f } } = complex, - asdf = babelHelpers.objectWithoutProperties(complex.x, ["a", d]), + asdf = babelHelpers.objectWithoutProperties(complex.x, ["a", d].map(babelHelpers.toPropertyKey)), d = babelHelpers.objectWithoutProperties(complex.y, []), g = babelHelpers.objectWithoutProperties(complex, ["x"]); let {} = z, @@ -49,4 +49,4 @@ var { x = 5 } = babelHelpers.objectWithoutProperties({ x: 1 -}, []); \ No newline at end of file +}, []); diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/regression/T7178/expected.js b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/regression/T7178/expected.js index d2cc0c9bc0..4b7c0e1076 100644 --- a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/regression/T7178/expected.js +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/regression/T7178/expected.js @@ -2,16 +2,11 @@ var _props = require("props"); -var _props2 = _interopRequireDefault(_props); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } +var _props2 = babelHelpers.interopRequireDefault(_props); console.log(_props2.default); (function () { - const props = _objectWithoutProperties(this.props, []); - + const props = babelHelpers.objectWithoutProperties(this.props, []); console.log(props); -})(); +})(); \ No newline at end of file diff --git a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/regression/T7178/options.json b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/regression/T7178/options.json index b765fa3a8f..ffde777a25 100644 --- a/packages/babel-plugin-transform-object-rest-spread/test/fixtures/regression/T7178/options.json +++ b/packages/babel-plugin-transform-object-rest-spread/test/fixtures/regression/T7178/options.json @@ -2,6 +2,7 @@ "plugins": [ "transform-es2015-modules-commonjs", "transform-es2015-destructuring", - "transform-object-rest-spread" + "transform-object-rest-spread", + "external-helpers" ] } diff --git a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-rest/expected.js b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-rest/expected.js index 01bec851b2..55274ade47 100644 --- a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-rest/expected.js +++ b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-rest/expected.js @@ -1,13 +1,11 @@ -function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } - function render(_ref) { let text = _ref.text, className = _ref.className, id = _ref.id, - props = _objectWithoutProperties(_ref, ["text", "className", "id"]); + props = babelHelpers.objectWithoutProperties(_ref, ["text", "className", "id"]); var _ref2 = ; // intentionally ignoring props return () => _ref2; -} +} \ No newline at end of file diff --git a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-rest/options.json b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-rest/options.json index 100ca290b8..a27408ed99 100644 --- a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-rest/options.json +++ b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-rest/options.json @@ -2,5 +2,5 @@ "plugins": ["transform-es2015-destructuring", "transform-es2015-parameters", "transform-es2015-spread", "syntax-object-rest-spread", - "transform-react-constant-elements", "syntax-jsx"] + "transform-react-constant-elements", "syntax-jsx", "external-helpers"] } diff --git a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-spread-deopt/expected.js b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-spread-deopt/expected.js index eb1d933b93..4f741ea43b 100644 --- a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-spread-deopt/expected.js +++ b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-spread-deopt/expected.js @@ -1,10 +1,7 @@ -function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } - function render(_ref) { let text = _ref.text, className = _ref.className, id = _ref.id, - props = _objectWithoutProperties(_ref, ["text", "className", "id"]); - + props = babelHelpers.objectWithoutProperties(_ref, ["text", "className", "id"]); return () => ; -} +} \ No newline at end of file diff --git a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-spread-deopt/options.json b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-spread-deopt/options.json index 100ca290b8..a27408ed99 100644 --- a/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-spread-deopt/options.json +++ b/packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/parameter-destructure-spread-deopt/options.json @@ -2,5 +2,5 @@ "plugins": ["transform-es2015-destructuring", "transform-es2015-parameters", "transform-es2015-spread", "syntax-object-rest-spread", - "transform-react-constant-elements", "syntax-jsx"] + "transform-react-constant-elements", "syntax-jsx", "external-helpers"] }