@skyscanner/backpack-web 7.0.0-alpha.1 → 7.0.0-alpha.2

package/bpk-component-barchart/d3-array/src/least.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = least;
+
+var _ascending = _interopRequireDefault(require("./ascending.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function least(values, compare = _ascending.default) {
+  let min;
+  let defined = false;
+
+  if (compare.length === 1) {
+    let minValue;
+
+    for (const element of values) {
+      const value = compare(element);
+
+      if (defined ? (0, _ascending.default)(value, minValue) < 0 : (0, _ascending.default)(value, value) === 0) {
+        min = element;
+        minValue = value;
+        defined = true;
+      }
+    }
+  } else {
+    for (const value of values) {
+      if (defined ? compare(value, min) < 0 : compare(value, value) === 0) {
+        min = value;
+        defined = true;
+      }
+    }
+  }
+
+  return min;
+}

package/bpk-component-barchart/d3-array/src/leastIndex.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = leastIndex;
+
+var _ascending = _interopRequireDefault(require("./ascending.js"));
+
+var _minIndex = _interopRequireDefault(require("./minIndex.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function leastIndex(values, compare = _ascending.default) {
+  if (compare.length === 1) return (0, _minIndex.default)(values, compare);
+  let minValue;
+  let min = -1;
+  let index = -1;
+
+  for (const value of values) {
+    ++index;
+
+    if (min < 0 ? compare(value, value) === 0 : compare(value, minValue) < 0) {
+      minValue = value;
+      min = index;
+    }
+  }
+
+  return min;
+}

package/bpk-component-barchart/d3-array/src/map.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = map;
+
+function map(values, mapper) {
+  if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable");
+  if (typeof mapper !== "function") throw new TypeError("mapper is not a function");
+  return Array.from(values, (value, index) => mapper(value, index, values));
+}

package/bpk-component-barchart/d3-array/src/max.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = max;
+
+function max(values, valueof) {
+  let max;
+
+  if (valueof === undefined) {
+    for (const value of values) {
+      if (value != null && (max < value || max === undefined && value >= value)) {
+        max = value;
+      }
+    }
+  } else {
+    let index = -1;
+
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (max < value || max === undefined && value >= value)) {
+        max = value;
+      }
+    }
+  }
+
+  return max;
+}

package/bpk-component-barchart/d3-array/src/maxIndex.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = maxIndex;
+
+function maxIndex(values, valueof) {
+  let max;
+  let maxIndex = -1;
+  let index = -1;
+
+  if (valueof === undefined) {
+    for (const value of values) {
+      ++index;
+
+      if (value != null && (max < value || max === undefined && value >= value)) {
+        max = value, maxIndex = index;
+      }
+    }
+  } else {
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (max < value || max === undefined && value >= value)) {
+        max = value, maxIndex = index;
+      }
+    }
+  }
+
+  return maxIndex;
+}

package/bpk-component-barchart/d3-array/src/mean.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = mean;
+
+function mean(values, valueof) {
+  let count = 0;
+  let sum = 0;
+
+  if (valueof === undefined) {
+    for (let value of values) {
+      if (value != null && (value = +value) >= value) {
+        ++count, sum += value;
+      }
+    }
+  } else {
+    let index = -1;
+
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
+        ++count, sum += value;
+      }
+    }
+  }
+
+  if (count) return sum / count;
+}

package/bpk-component-barchart/d3-array/src/median.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = median;
+
+var _quantile = _interopRequireDefault(require("./quantile.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function median(values, valueof) {
+  return (0, _quantile.default)(values, 0.5, valueof);
+}

package/bpk-component-barchart/d3-array/src/merge.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = merge;
+
+function* flatten(arrays) {
+  for (const array of arrays) {
+    yield* array;
+  }
+}
+
+function merge(arrays) {
+  return Array.from(flatten(arrays));
+}

package/bpk-component-barchart/d3-array/src/min.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = min;
+
+function min(values, valueof) {
+  let min;
+
+  if (valueof === undefined) {
+    for (const value of values) {
+      if (value != null && (min > value || min === undefined && value >= value)) {
+        min = value;
+      }
+    }
+  } else {
+    let index = -1;
+
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (min > value || min === undefined && value >= value)) {
+        min = value;
+      }
+    }
+  }
+
+  return min;
+}

package/bpk-component-barchart/d3-array/src/minIndex.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = minIndex;
+
+function minIndex(values, valueof) {
+  let min;
+  let minIndex = -1;
+  let index = -1;
+
+  if (valueof === undefined) {
+    for (const value of values) {
+      ++index;
+
+      if (value != null && (min > value || min === undefined && value >= value)) {
+        min = value, minIndex = index;
+      }
+    }
+  } else {
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (min > value || min === undefined && value >= value)) {
+        min = value, minIndex = index;
+      }
+    }
+  }
+
+  return minIndex;
+}

package/bpk-component-barchart/d3-array/src/mode.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = mode;
+
+var _internmap = require("internmap");
+
+function mode(values, valueof) {
+  const counts = new _internmap.InternMap();
+
+  if (valueof === undefined) {
+    for (let value of values) {
+      if (value != null && value >= value) {
+        counts.set(value, (counts.get(value) || 0) + 1);
+      }
+    }
+  } else {
+    let index = -1;
+
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && value >= value) {
+        counts.set(value, (counts.get(value) || 0) + 1);
+      }
+    }
+  }
+
+  let modeValue;
+  let modeCount = 0;
+
+  for (const [value, count] of counts) {
+    if (count > modeCount) {
+      modeCount = count;
+      modeValue = value;
+    }
+  }
+
+  return modeValue;
+}

package/bpk-component-barchart/d3-array/src/nice.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = nice;
+
+var _ticks = require("./ticks.js");
+
+function nice(start, stop, count) {
+  let prestep;
+
+  while (true) {
+    const step = (0, _ticks.tickIncrement)(start, stop, count);
+
+    if (step === prestep || step === 0 || !isFinite(step)) {
+      return [start, stop];
+    } else if (step > 0) {
+      start = Math.floor(start / step) * step;
+      stop = Math.ceil(stop / step) * step;
+    } else if (step < 0) {
+      start = Math.ceil(start * step) / step;
+      stop = Math.floor(stop * step) / step;
+    }
+
+    prestep = step;
+  }
+}

package/bpk-component-barchart/d3-array/src/number.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = number;
+exports.numbers = numbers;
+
+function number(x) {
+  return x === null ? NaN : +x;
+}
+
+function* numbers(values, valueof) {
+  if (valueof === undefined) {
+    for (let value of values) {
+      if (value != null && (value = +value) >= value) {
+        yield value;
+      }
+    }
+  } else {
+    let index = -1;
+
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
+        yield value;
+      }
+    }
+  }
+}

package/bpk-component-barchart/d3-array/src/pairs.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = pairs;
+exports.pair = pair;
+
+function pairs(values, pairof = pair) {
+  const pairs = [];
+  let previous;
+  let first = false;
+
+  for (const value of values) {
+    if (first) pairs.push(pairof(previous, value));
+    previous = value;
+    first = true;
+  }
+
+  return pairs;
+}
+
+function pair(a, b) {
+  return [a, b];
+}

package/bpk-component-barchart/d3-array/src/permute.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = permute;
+
+function permute(source, keys) {
+  return Array.from(keys, key => source[key]);
+}

package/bpk-component-barchart/d3-array/src/quantile.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = quantile;
+exports.quantileSorted = quantileSorted;
+
+var _max = _interopRequireDefault(require("./max.js"));
+
+var _min = _interopRequireDefault(require("./min.js"));
+
+var _quickselect = _interopRequireDefault(require("./quickselect.js"));
+
+var _number = _interopRequireWildcard(require("./number.js"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function quantile(values, p, valueof) {
+  values = Float64Array.from((0, _number.numbers)(values, valueof));
+  if (!(n = values.length)) return;
+  if ((p = +p) <= 0 || n < 2) return (0, _min.default)(values);
+  if (p >= 1) return (0, _max.default)(values);
+  var n,
+      i = (n - 1) * p,
+      i0 = Math.floor(i),
+      value0 = (0, _max.default)((0, _quickselect.default)(values, i0).subarray(0, i0 + 1)),
+      value1 = (0, _min.default)(values.subarray(i0 + 1));
+  return value0 + (value1 - value0) * (i - i0);
+}
+
+function quantileSorted(values, p, valueof = _number.default) {
+  if (!(n = values.length)) return;
+  if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
+  if (p >= 1) return +valueof(values[n - 1], n - 1, values);
+  var n,
+      i = (n - 1) * p,
+      i0 = Math.floor(i),
+      value0 = +valueof(values[i0], i0, values),
+      value1 = +valueof(values[i0 + 1], i0 + 1, values);
+  return value0 + (value1 - value0) * (i - i0);
+}

package/bpk-component-barchart/d3-array/src/quickselect.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = quickselect;
+
+var _sort = require("./sort.js");
+
+// Based on https://github.com/mourner/quickselect
+// ISC license, Copyright 2018 Vladimir Agafonkin.
+function quickselect(array, k, left = 0, right = array.length - 1, compare) {
+  compare = compare === undefined ? _sort.ascendingDefined : (0, _sort.compareDefined)(compare);
+
+  while (right > left) {
+    if (right - left > 600) {
+      const n = right - left + 1;
+      const m = k - left + 1;
+      const z = Math.log(n);
+      const s = 0.5 * Math.exp(2 * z / 3);
+      const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+      const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
+      const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
+      quickselect(array, k, newLeft, newRight, compare);
+    }
+
+    const t = array[k];
+    let i = left;
+    let j = right;
+    swap(array, left, k);
+    if (compare(array[right], t) > 0) swap(array, left, right);
+
+    while (i < j) {
+      swap(array, i, j), ++i, --j;
+
+      while (compare(array[i], t) < 0) ++i;
+
+      while (compare(array[j], t) > 0) --j;
+    }
+
+    if (compare(array[left], t) === 0) swap(array, left, j);else ++j, swap(array, j, right);
+    if (j <= k) left = j + 1;
+    if (k <= j) right = j - 1;
+  }
+
+  return array;
+}
+
+function swap(array, i, j) {
+  const t = array[i];
+  array[i] = array[j];
+  array[j] = t;
+}

package/bpk-component-barchart/d3-array/src/range.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = range;
+
+function range(start, stop, step) {
+  start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
+  var i = -1,
+      n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
+      range = new Array(n);
+
+  while (++i < n) {
+    range[i] = start + i * step;
+  }
+
+  return range;
+}

package/bpk-component-barchart/d3-array/src/rank.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rank;
+
+var _ascending = _interopRequireDefault(require("./ascending.js"));
+
+var _sort = require("./sort.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function rank(values, valueof = _ascending.default) {
+  if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable");
+  let V = Array.from(values);
+  const R = new Float64Array(V.length);
+  if (valueof.length !== 2) V = V.map(valueof), valueof = _ascending.default;
+
+  const compareIndex = (i, j) => valueof(V[i], V[j]);
+
+  let k, r;
+  Uint32Array.from(V, (_, i) => i).sort(valueof === _ascending.default ? (i, j) => (0, _sort.ascendingDefined)(V[i], V[j]) : (0, _sort.compareDefined)(compareIndex)).forEach((j, i) => {
+    const c = compareIndex(j, k === undefined ? j : k);
+
+    if (c >= 0) {
+      if (k === undefined || c > 0) k = j, r = i;
+      R[j] = r;
+    } else {
+      R[j] = NaN;
+    }
+  });
+  return R;
+}

package/bpk-component-barchart/d3-array/src/reduce.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = reduce;
+
+function reduce(values, reducer, value) {
+  if (typeof reducer !== "function") throw new TypeError("reducer is not a function");
+  const iterator = values[Symbol.iterator]();
+  let done,
+      next,
+      index = -1;
+
+  if (arguments.length < 3) {
+    ({
+      done,
+      value
+    } = iterator.next());
+    if (done) return;
+    ++index;
+  }
+
+  while (({
+    done,
+    value: next
+  } = iterator.next()), !done) {
+    value = reducer(value, next, ++index, values);
+  }
+
+  return value;
+}

package/bpk-component-barchart/d3-array/src/reverse.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = reverse;
+
+function reverse(values) {
+  if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable");
+  return Array.from(values).reverse();
+}

package/bpk-component-barchart/d3-array/src/scan.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = scan;
+
+var _leastIndex = _interopRequireDefault(require("./leastIndex.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function scan(values, compare) {
+  const index = (0, _leastIndex.default)(values, compare);
+  return index < 0 ? undefined : index;
+}

package/bpk-component-barchart/d3-array/src/shuffle.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.shuffler = shuffler;
+
+var _default = shuffler(Math.random);
+
+exports.default = _default;
+
+function shuffler(random) {
+  return function shuffle(array, i0 = 0, i1 = array.length) {
+    let m = i1 - (i0 = +i0);
+
+    while (m) {
+      const i = random() * m-- | 0,
+            t = array[m + i0];
+      array[m + i0] = array[i + i0];
+      array[i + i0] = t;
+    }
+
+    return array;
+  };
+}

package/bpk-component-barchart/d3-array/src/some.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = some;
+
+function some(values, test) {
+  if (typeof test !== "function") throw new TypeError("test is not a function");
+  let index = -1;
+
+  for (const value of values) {
+    if (test(value, ++index, values)) {
+      return true;
+    }
+  }
+
+  return false;
+}