Add a polyfill for flatMap and flatten (#21)

* Add a polyfill for flatMap and flatten

* Update links to point to tc39 repo

* Add new dependencies, .eslintrc

* Reformat polyfill, remove outdated comments, use es-abstract

* (d.ts) fix compiler errors, add better / working overloads

* Correct peer dependency version

* Update flattenIntoArray algorithm

Author: Diogo Franco

.eslintrc

@@ -0,0 +1,9 @@
+{
+  "extends": "airbnb-base",
+  "parserOptions": {
+    "sourceType": "script"
+  },
+  "rules": {
+    "no-use-before-define": ["error", { "functions": false }]
+  }
+}

package.json

@@ -2,11 +2,16 @@
   "name": "proposal-flatmap",
   "version": "1.0.0",
   "description": "",
-  "main": "ecmarkup.js",
+  "main": "polyfill.js",
   "dependencies": {
-    "ecmarkup": "^3.11.5"
+    "es-abstract": "^1.7.0"
+  },
+  "devDependencies": {
+    "ecmarkup": "^3.11.5",
+    "eslint": "^3.19.0",
+    "eslint-config-airbnb-base": "^11.2.0",
+    "eslint-plugin-import": "^2.7.0"
   },
-  "devDependencies": {},
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "ecmarkup proposal.html index.html --verbose --toc",

polyfill.d.ts

@@ -0,0 +1,29 @@
+interface ReadonlyArray<T> {
+  flatMap<U, This = undefined> (callback: (this: This, value: T, index: number, array: T[]) => U|U[], thisArg?: This): U[]
+
+  // adding more overloads would be a combinatorial explosion
+  flatten<U>(this:
+    ReadonlyArray<U[][]> |
+    ReadonlyArray<ReadonlyArray<U[]>> |
+    ReadonlyArray<ReadonlyArray<U>[]> |
+    ReadonlyArray<ReadonlyArray<ReadonlyArray<U>>>,
+    depth: 2): U[];
+  flatten<U>(this: ReadonlyArray<U[]> | ReadonlyArray<ReadonlyArray<U>>, depth?: 1): U[];
+  flatten<U>(this: ReadonlyArray<U>, depth: 0): U[];
+  flatten<U>(depth: number): U[];
+}
+
+
+interface Array<T> {
+  flatMap<U, This = undefined> (callback: (this: This, value: T, index: number, array: T[]) => U|U[], thisArg?: This): U[]
+
+  flatten<U>(this: U[][][][][][][][], depth: 7): U[];
+  flatten<U>(this: U[][][][][][][], depth: 6): U[];
+  flatten<U>(this: U[][][][][][], depth: 5): U[];
+  flatten<U>(this: U[][][][][], depth: 4): U[];
+  flatten<U>(this: U[][][][], depth: 3): U[];
+  flatten<U>(this: U[][][], depth: 2): U[];
+  flatten<U>(this: U[][], depth?: 1): U[];
+  flatten<U>(this: U[], depth: 0): U[];
+  flatten<U>(depth?: number): U[];
+}

polyfill.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const ES = require('es-abstract');
+
+if (typeof Symbol !== 'function' || !Symbol.isConcatSpreadable) {
+  throw new Error('Symbol.isConcatSpreadable missing from the environment');
+}
+
+if (typeof Array.prototype.flatMap !== 'function') {
+  // eslint-disable-next-line no-extend-native
+  Object.defineProperty(Array.prototype, 'flatMap', {
+    configurable: true,
+    writable: true,
+    // https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap
+    value: function flatMap(callback, thisArg = undefined) {
+      const O = ES.ToObject(this);
+      // Could ES.IsCallable check callback, but it's better to let it throw a runtime error
+      const sourceLen = ES.ToLength(O.length);
+      const A = new (ES.SpeciesConstructor(O, Array))(0);
+      flattenIntoArray(A, O, sourceLen, 0, 1, callback, thisArg);
+      return A;
+    },
+  });
+}
+
+if (typeof Array.prototype.flatten !== 'function') {
+  // eslint-disable-next-line no-extend-native
+  Object.defineProperty(Array.prototype, 'flatten', {
+    configurable: true,
+    writable: true,
+    // https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatten
+    value: function flatten(depthArg = 1) {
+      const O = ES.ToObject(this);
+      const sourceLen = ES.ToLength(O.length);
+      const A = new (ES.SpeciesConstructor(O, Array))(0);
+      const depth = ES.ToInteger(depthArg);
+      flattenIntoArray(A, O, sourceLen, 0, depth);
+      return A;
+    },
+  });
+}
+
+// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray
+/**
+ * @param {any[]} target
+ * @param {any[]} source
+ * @param {number} startLen
+ * @param {number} start
+ * @param {number} depth
+ * @param {Function=} mapper
+ * @param {any=} thisArg
+ */
+function flattenIntoArray(target, source, sourceLen, start, depth, mapper, thisArg) {
+  let targetIndex = start;
+  let sourceIndex = 0;
+
+  while (sourceIndex < sourceLen) {
+    const P = ES.ToString(sourceIndex);
+    if (P in source) {
+      let element = source[P];
+      if (mapper) {
+        element = mapper.call(thisArg, element, sourceIndex, target);
+      }
+      let spreadable;
+      // https://tc39.github.io/ecma262/#sec-isconcatspreadable
+      if (typeof element !== 'object') {
+        spreadable = false;
+      } else {
+        spreadable = element[Symbol.isConcatSpreadable];
+        if (typeof spreadable !== 'undefined') {
+          spreadable = !!spreadable;
+        } else {
+          spreadable = Array.isArray(element);
+        }
+      }
+
+      if (spreadable && depth > 0) {
+        const elementLen = ES.ToLength(element.length);
+        const nextIndex = flattenIntoArray(target, element, elementLen, targetIndex, depth - 1);
+        targetIndex = nextIndex - 1;
+      } else {
+        if (targetIndex !== ES.ToLength(targetIndex)) {
+          throw TypeError();
+        }
+        // eslint-disable-next-line no-param-reassign
+        target[targetIndex] = element;
+      }
+    }
+    targetIndex += 1;
+    sourceIndex += 1;
+  }
+  return targetIndex;
+}