add "String.cooked" proposal

https://github.com/bathos/proposal-string-cooked

Author: zloirock

packages/core-js-compat/src/data.mjs

@@ -1688,6 +1688,8 @@ export const data = {
   // TODO: Remove from `core-js@4`
   'esnext.string.at': {
   },
+  'esnext.string.cooked': {
+  },
   'esnext.string.code-points': {
   },
   // TODO: Remove from `core-js@4`

packages/core-js-compat/src/modules-by-versions.mjs

@@ -111,4 +111,7 @@ export default {
     'esnext.array.from-async',
     'esnext.typed-array.from-async',
   ],
+  3.19: [
+    'esnext.string.cooked',
+  ],
 };

packages/core-js/features/string/cooked.js

@@ -0,0 +1,4 @@
+require('../../modules/esnext.string.cooked');
+var path = require('../../internals/path');
+
+module.exports = path.String.cooked;

packages/core-js/features/string/index.js

@@ -1,5 +1,7 @@
 var parent = require('../../stable/string');
+// TODO: remove from `core-js@4`
 require('../../modules/esnext.string.at');
+require('../../modules/esnext.string.cooked');
 // TODO: disabled by default because of the conflict with another proposal
 // require('../../modules/esnext.string.at-alternative');
 require('../../modules/esnext.string.code-points');

packages/core-js/modules/esnext.string.cooked.js

@@ -0,0 +1,27 @@
+var $ = require('../internals/export');
+var toIndexedObject = require('../internals/to-indexed-object');
+var toString = require('../internals/to-string');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
+
+var ArrayPrototype = Array.prototype;
+var push = ArrayPrototype.push;
+var join = ArrayPrototype.join;
+
+// `String.cooked` method
+// https://github.com/bathos/proposal-string-cooked
+$({ target: 'String', stat: true }, {
+  cooked: function cooked(template /* , ...substitutions */) {
+    var cookedTemplate = toIndexedObject(template);
+    var literalSegments = lengthOfArrayLike(cookedTemplate);
+    var argumentsLength = arguments.length;
+    var elements = [];
+    var i = 0;
+    while (literalSegments > i) {
+      var nextVal = cookedTemplate[i++];
+      if (nextVal === undefined) throw TypeError('Incorrect template');
+      push.call(elements, toString(nextVal));
+      if (i === literalSegments) return join.call(elements, '');
+      if (i < argumentsLength) push.call(elements, toString(arguments[i]));
+    }
+  }
+});

packages/core-js/proposals/string-cooked.js

@@ -0,0 +1,2 @@
+// https://github.com/bathos/proposal-string-cooked
+require('../modules/esnext.string.cooked');

packages/core-js/stage/0.js

@@ -1,5 +1,6 @@
 require('../proposals/efficient-64-bit-arithmetic');
 require('../proposals/string-at');
+require('../proposals/string-cooked');
 require('../proposals/url');
 var parent = require('./1');
 

tests/commonjs.mjs

@@ -676,6 +676,7 @@ for (PATH of ['core-js-pure', 'core-js']) {
     ok(load(NS, 'set/some')(new Set([1, 2, 3]), it => typeof it == 'number'));
     ok(load(NS, 'set/symmetric-difference')(new Set([1, 2, 3]), [3, 4, 5]).size === 4);
     ok(load(NS, 'set/union')(new Set([1, 2, 3]), [3, 4, 5]).size === 5);
+    ok(load(NS, 'string/cooked')`a${ 1 }b` === 'a1b');
     ok('next' in load(NS, 'string/code-points')('a'));
     ok('next' in load(NS, 'string/virtual/code-points').call('a'));
     ok(load(NS, 'symbol/async-dispose'));
@@ -770,6 +771,7 @@ for (PATH of ['core-js-pure', 'core-js']) {
   load('proposals/seeded-random');
   load('proposals/set-methods');
   load('proposals/string-at');
+  load('proposals/string-cooked');
   load('proposals/string-code-points');
   load('proposals/string-match-all');
   load('proposals/string-replace-all');

tests/compat/tests.js

@@ -1469,6 +1469,9 @@ GLOBAL.tests = {
   'esnext.string.code-points': function () {
     return String.prototype.codePoints;
   },
+  'esnext.string.cooked': function () {
+    return String.cooked;
+  },
   'esnext.symbol.async-dispose': function () {
     return Symbol.dispose;
   },

tests/pure/esnext.string.cooked.js

@@ -0,0 +1,19 @@
+import Symbol from 'core-js-pure/es/symbol';
+import cooked from 'core-js-pure/features/string/cooked';
+
+QUnit.test('String.cooked', assert => {
+  assert.isFunction(cooked);
+  assert.arity(cooked, 1);
+  assert.name(cooked, 'cooked');
+  assert.strictEqual(cooked(['Hi\\n', '!'], 'Bob'), 'Hi\\nBob!', 'template is an array');
+  assert.strictEqual(cooked('test', 0, 1, 2), 't0e1s2t', 'template is a string');
+  assert.strictEqual(cooked('test', 0), 't0est', 'lacks substituting');
+
+  if (typeof Symbol == 'function' && !Symbol.sham) {
+    assert.throws(() => cooked([Symbol()]), TypeError, 'throws on symbol #1');
+    assert.throws(() => cooked('test', Symbol()), TypeError, 'throws on symbol #2');
+  }
+
+  assert.throws(() => cooked([undefined]), TypeError);
+  assert.throws(() => cooked(null), TypeError);
+});

tests/tests/esnext.string.cooked.js

@@ -0,0 +1,19 @@
+QUnit.test('String.cooked', assert => {
+  const { cooked } = String;
+  assert.isFunction(cooked);
+  assert.arity(cooked, 1);
+  assert.name(cooked, 'cooked');
+  assert.looksNative(cooked);
+  assert.nonEnumerable(String, 'cooked');
+  assert.strictEqual(cooked(['Hi\\n', '!'], 'Bob'), 'Hi\\nBob!', 'template is an array');
+  assert.strictEqual(cooked('test', 0, 1, 2), 't0e1s2t', 'template is a string');
+  assert.strictEqual(cooked('test', 0), 't0est', 'lacks substituting');
+
+  if (typeof Symbol == 'function' && !Symbol.sham) {
+    assert.throws(() => cooked([Symbol()]), TypeError, 'throws on symbol #1');
+    assert.throws(() => cooked('test', Symbol()), TypeError, 'throws on symbol #2');
+  }
+
+  assert.throws(() => cooked([undefined]), TypeError);
+  assert.throws(() => cooked(null), TypeError);
+});