@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/utils/table-utils/row-data-container.js

@@ -0,0 +1,242 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RowDataContainer = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _dataRow = require("./data-row");
+
+var _marked = /*#__PURE__*/_regenerator["default"].mark(rowsIterator),
+    _marked2 = /*#__PURE__*/_regenerator["default"].mark(columnIterator);
+
+/**
+ * @param {import('./data-container-interface').DataContainerInterface} dataContainer
+ * @param {import('./data-row').SharedRowOptions} sharedRow
+ */
+function rowsIterator(dataContainer, sharedRow) {
+  var numRows, rowIndex;
+  return _regenerator["default"].wrap(function rowsIterator$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          numRows = dataContainer.numRows();
+          rowIndex = 0;
+
+        case 2:
+          if (!(rowIndex < numRows)) {
+            _context.next = 8;
+            break;
+          }
+
+          _context.next = 5;
+          return dataContainer.row(rowIndex, sharedRow);
+
+        case 5:
+          ++rowIndex;
+          _context.next = 2;
+          break;
+
+        case 8:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _marked);
+}
+/**
+ * @param {import('./data-container-interface').DataContainerInterface} dataContainer
+ * @param {number} columnIndex
+ */
+
+
+function columnIterator(dataContainer, columnIndex) {
+  var numRows, rowIndex;
+  return _regenerator["default"].wrap(function columnIterator$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          numRows = dataContainer.numRows();
+          rowIndex = 0;
+
+        case 2:
+          if (!(rowIndex < numRows)) {
+            _context2.next = 8;
+            break;
+          }
+
+          _context2.next = 5;
+          return dataContainer.valueAt(rowIndex, columnIndex);
+
+        case 5:
+          ++rowIndex;
+          _context2.next = 2;
+          break;
+
+        case 8:
+        case "end":
+          return _context2.stop();
+      }
+    }
+  }, _marked2);
+}
+
+var RowDataContainer = /*#__PURE__*/function () {
+  function RowDataContainer(data) {
+    var _data$rows$;
+
+    (0, _classCallCheck2["default"])(this, RowDataContainer);
+
+    if (!data.rows) {
+      throw Error('RowDataContainer: no rows provided');
+    }
+
+    if (!Array.isArray(data.rows)) {
+      throw Error("RowDataContainer: rows object isn't an array");
+    }
+
+    this._rows = data.rows;
+    this._numColumns = ((_data$rows$ = data.rows[0]) === null || _data$rows$ === void 0 ? void 0 : _data$rows$.length) || 0;
+  }
+
+  (0, _createClass2["default"])(RowDataContainer, [{
+    key: "numRows",
+    value: function numRows() {
+      return this._rows.length;
+    }
+  }, {
+    key: "numColumns",
+    value: function numColumns() {
+      return this._numColumns;
+    }
+  }, {
+    key: "valueAt",
+    value: function valueAt(rowIndex, columnIndex) {
+      if (this._rows[rowIndex] === null) {
+        return null;
+      }
+
+      return this._rows[rowIndex][columnIndex];
+    }
+  }, {
+    key: "row",
+    value: function row(rowIndex, sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+
+      if (tSharedRow) {
+        tSharedRow.setSource(this, rowIndex);
+        return tSharedRow;
+      }
+
+      return new _dataRow.DataRow(this, rowIndex);
+    }
+  }, {
+    key: "rowAsArray",
+    value: function rowAsArray(rowIndex) {
+      return this._rows[rowIndex];
+    }
+  }, {
+    key: "rows",
+    value: function rows(sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+
+      return rowsIterator(this, tSharedRow);
+    }
+  }, {
+    key: "column",
+    value: function column(columnIndex) {
+      return columnIterator(this, columnIndex);
+    }
+  }, {
+    key: "flattenData",
+    value: function flattenData() {
+      return this._rows;
+    }
+  }, {
+    key: "getPlainIndex",
+    value: function getPlainIndex(valid) {
+      return this._rows.map(function (_, i) {
+        return i;
+      });
+    }
+  }, {
+    key: "map",
+    value: function map(func, sharedRow) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+
+      var _options$start = options.start,
+          start = _options$start === void 0 ? 0 : _options$start,
+          _options$end = options.end,
+          end = _options$end === void 0 ? this.numRows() : _options$end;
+      var endRow = Math.min(this.numRows(), end);
+      var out = [];
+
+      for (var rowIndex = start; rowIndex < endRow; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        out.push(func(row, rowIndex));
+      }
+
+      return out;
+    }
+  }, {
+    key: "mapIndex",
+    value: function mapIndex(func) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var _options$start2 = options.start,
+          start = _options$start2 === void 0 ? 0 : _options$start2,
+          _options$end2 = options.end,
+          end = _options$end2 === void 0 ? this.numRows() : _options$end2;
+      var endRow = Math.min(this.numRows(), end);
+      var out = [];
+
+      for (var rowIndex = start; rowIndex < endRow; ++rowIndex) {
+        out.push(func({
+          index: rowIndex
+        }, this));
+      }
+
+      return out;
+    }
+  }, {
+    key: "find",
+    value: function find(func, sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+
+      for (var rowIndex = 0; rowIndex < this._rows.length; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+
+        if (func(row, rowIndex)) {
+          return row;
+        }
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "reduce",
+    value: function reduce(func, initialValue, sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+
+      for (var rowIndex = 0; rowIndex < this._rows.length; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        initialValue = func(initialValue, row, rowIndex);
+      }
+
+      return initialValue;
+    }
+  }]);
+  return RowDataContainer;
+}();
+
+exports.RowDataContainer = RowDataContainer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/utils/table-utils/row-data-container.js"],"names":["rowsIterator","columnIterator","dataContainer","sharedRow","numRows","rowIndex","row","columnIndex","valueAt","RowDataContainer","data","rows","Error","Array","isArray","_rows","_numColumns","length","tSharedRow","DataRow","createSharedRow","setSource","valid","map","_","i","func","options","start","end","endRow","Math","min","out","push","index","undefined","initialValue"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {DataRow} from './data-row';\n\n/**\n * @param {import('./data-container-interface').DataContainerInterface} dataContainer\n * @param {import('./data-row').SharedRowOptions} sharedRow\n */\nfunction* rowsIterator(dataContainer, sharedRow) {\n  const numRows = dataContainer.numRows();\n  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {\n    yield dataContainer.row(rowIndex, sharedRow);\n  }\n}\n\n/**\n * @param {import('./data-container-interface').DataContainerInterface} dataContainer\n * @param {number} columnIndex\n */\nfunction* columnIterator(dataContainer, columnIndex) {\n  const numRows = dataContainer.numRows();\n  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {\n    yield dataContainer.valueAt(rowIndex, columnIndex);\n  }\n}\n\nexport class RowDataContainer {\n  constructor(data) {\n    if (!data.rows) {\n      throw Error('RowDataContainer: no rows provided');\n    }\n\n    if (!Array.isArray(data.rows)) {\n      throw Error(\"RowDataContainer: rows object isn't an array\");\n    }\n\n    this._rows = data.rows;\n    this._numColumns = data.rows[0]?.length || 0;\n  }\n\n  numRows() {\n    return this._rows.length;\n  }\n\n  numColumns() {\n    return this._numColumns;\n  }\n\n  valueAt(rowIndex, columnIndex) {\n    if (this._rows[rowIndex] === null) {\n      return null;\n    }\n    return this._rows[rowIndex][columnIndex];\n  }\n\n  row(rowIndex, sharedRow) {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n    if (tSharedRow) {\n      tSharedRow.setSource(this, rowIndex);\n      return tSharedRow;\n    }\n\n    return new DataRow(this, rowIndex);\n  }\n\n  rowAsArray(rowIndex) {\n    return this._rows[rowIndex];\n  }\n\n  rows(sharedRow) {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n    return rowsIterator(this, tSharedRow);\n  }\n\n  column(columnIndex) {\n    return columnIterator(this, columnIndex);\n  }\n\n  flattenData() {\n    return this._rows;\n  }\n\n  getPlainIndex(valid) {\n    return this._rows.map((_, i) => i);\n  }\n\n  map(func, sharedRow, options = {}) {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    const {start = 0, end = this.numRows()} = options;\n    const endRow = Math.min(this.numRows(), end);\n\n    const out = [];\n    for (let rowIndex = start; rowIndex < endRow; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      out.push(func(row, rowIndex));\n    }\n    return out;\n  }\n\n  mapIndex(func, options = {}) {\n    const {start = 0, end = this.numRows()} = options;\n    const endRow = Math.min(this.numRows(), end);\n\n    const out = [];\n    for (let rowIndex = start; rowIndex < endRow; ++rowIndex) {\n      out.push(func({index: rowIndex}, this));\n    }\n    return out;\n  }\n\n  find(func, sharedRow) {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this._rows.length; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      if (func(row, rowIndex)) {\n        return row;\n      }\n    }\n    return undefined;\n  }\n\n  reduce(func, initialValue, sharedRow) {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this._rows.length; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      initialValue = func(initialValue, row, rowIndex);\n    }\n    return initialValue;\n  }\n}\n"]}

package/dist/utils/utils.js

@@ -0,0 +1,234 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateHashId = generateHashId;
+exports.isChrome = isChrome;
+exports.isPlainObject = isPlainObject;
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+exports.camelToTitle = camelToTitle;
+exports.getHTMLMapModeTileUrl = getHTMLMapModeTileUrl;
+exports.toArray = toArray;
+exports.isObject = isObject;
+exports.getError = getError;
+exports.arrayInsert = arrayInsert;
+exports.isTest = isTest;
+exports.set = exports.insertValue = exports.camelize = void 0;
+
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _window = _interopRequireDefault(require("global/window"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/**
+ * Generate a hash string based on number of character
+ * @param {number} count
+ * @returns {string} hash string
+ */
+function generateHashId() {
+  var count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 6;
+  return Math.random().toString(36).substr(count);
+}
+/**
+ * Detect chrome
+ * @returns {boolean} - yes or no
+ */
+
+
+function isChrome() {
+  // Chrome 1+
+  return _window["default"].chrome && _window["default"].chrome.webstore;
+}
+/**
+ * whether is an object
+ * @returns {boolean} - yes or no
+ */
+
+
+function isPlainObject(obj) {
+  return obj === Object(obj) && typeof obj !== 'function' && !Array.isArray(obj);
+}
+/**
+ * Capitalize first letter of a string
+ * @param {string} str
+ * @returns {string}
+ */
+
+
+function capitalizeFirstLetter(str) {
+  return typeof str === 'string' ? str.charAt(0).toUpperCase() + str.slice(1) : str;
+}
+/**
+ * Convert camel style names to title
+ * strokeColor -> Stroke Color
+ * @param {string} str
+ * @returns {string}
+ */
+
+
+function camelToTitle(str) {
+  var breakWord = str.replace(/([A-Z])/g, ' $1');
+  return capitalizeFirstLetter(breakWord);
+}
+/**
+ * Convert names to camel style
+ * Stroke Color -> strokeColor
+ * @param {string} str
+ * @returns {string}
+ */
+
+
+var camelize = function camelize(str) {
+  return str.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function (match, index) {
+    if (Number(match) === 0) return ''; // or if (/\s+/.test(match)) for white spaces
+
+    return index === 0 ? match.toLowerCase() : match.toUpperCase();
+  });
+};
+/**
+ * Returns the img url for a given map export option
+ * @param mode export option
+ * @return {string} url
+ */
+
+
+exports.camelize = camelize;
+
+function getHTMLMapModeTileUrl(mode) {
+  return "https://d1a3f4spazzrp4.cloudfront.net/kepler.gl/documentation/map-".concat(mode.toLowerCase(), "-mode.png");
+}
+/**
+ * Converts non-arrays to arrays.  Leaves arrays alone.  Converts
+ * undefined values to empty arrays ([] instead of [undefined]).
+ * Otherwise, just returns [item] for non-array items.
+ *
+ * @param {*} item
+ * @returns {array} boom! much array. very indexed. so useful.
+ */
+
+
+function toArray(item) {
+  if (Array.isArray(item)) {
+    return item;
+  }
+
+  if (typeof item === 'undefined' || item === null) {
+    return [];
+  }
+
+  return [item];
+}
+/**
+ * immutably insert value to an Array or Object
+ * @param {Array|Object} obj
+ * @param {Number|String} key
+ * @param {*} value
+ * @returns {Array|Object}
+ */
+
+
+var insertValue = function insertValue(obj, key, value) {
+  if (Array.isArray(obj) && typeof key === 'number') {
+    return [].concat((0, _toConsumableArray2["default"])(obj.slice(0, key)), [value], (0, _toConsumableArray2["default"])(obj.slice(key + 1, obj.length)));
+  }
+
+  return _objectSpread(_objectSpread({}, obj), {}, (0, _defineProperty2["default"])({}, key, value));
+};
+/**
+ * check if value is a loose object including a plain object, array, function
+ * @param {*} value
+ */
+
+
+exports.insertValue = insertValue;
+
+function isObject(value) {
+  return value !== null && ((0, _typeof2["default"])(value) === 'object' || typeof value === 'function');
+}
+
+var setPath = function setPath(_ref, value, obj) {
+  var _ref2 = (0, _toArray2["default"])(_ref),
+      key = _ref2[0],
+      next = _ref2.slice(1);
+
+  // is Object allows js object, array and function
+  if (!isObject(obj)) {
+    return obj;
+  }
+
+  if (next.length === 0) {
+    return insertValue(obj, key, value);
+  } // @ts-ignore
+
+
+  return insertValue(obj, key, setPath(next, value, obj.hasOwnProperty(key) ? obj[key] : {}));
+};
+/**
+ * Immutable version of _.set
+ * @param {Array<String|Number>} path
+ * @param {*} value
+ * @param {Object} obj
+ * @returns {Object}
+ */
+// @ts-ignore
+
+
+var set = function set(path, value, obj) {
+  return obj === null ? obj : setPath(path, value, obj);
+};
+/**
+ * Get error information of unknown type
+ * Extracts as much human readable information as possible
+ * Ensure result is an Error object suitable for throw or promise rejection
+ *
+ * @private
+ * @param {*}  err - Unknown error
+ * @return {string} - human readable error msg
+ */
+
+
+exports.set = set;
+
+function getError(err) {
+  if (!err) {
+    return 'Something went wrong';
+  }
+
+  if (typeof err === 'string') {
+    return err;
+  } else if (err instanceof Error) {
+    return err.message;
+  } else if ((0, _typeof2["default"])(err) === 'object') {
+    return err.error ? getError(err.error) : err.err ? getError(err.err) : err.message ? getError(err.message) : JSON.stringify(err);
+  } // @ts-ignore
+
+
+  return null;
+}
+
+function arrayInsert(arr, index, val) {
+  if (!Array.isArray(arr)) {
+    return arr;
+  }
+
+  return [].concat((0, _toConsumableArray2["default"])(arr.slice(0, index)), [val], (0, _toConsumableArray2["default"])(arr.slice(index)));
+}
+
+function isTest() {
+  var _process, _process$env;
+
+  return ((_process = process) === null || _process === void 0 ? void 0 : (_process$env = _process.env) === null || _process$env === void 0 ? void 0 : _process$env.NODE_ENV) === 'test';
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/utils/utils.js"],"names":["generateHashId","count","Math","random","toString","substr","isChrome","window","chrome","webstore","isPlainObject","obj","Object","Array","isArray","capitalizeFirstLetter","str","charAt","toUpperCase","slice","camelToTitle","breakWord","replace","camelize","match","index","Number","toLowerCase","getHTMLMapModeTileUrl","mode","toArray","item","insertValue","key","value","length","isObject","setPath","next","hasOwnProperty","set","path","getError","err","Error","message","error","JSON","stringify","arrayInsert","arr","val","isTest","process","env","NODE_ENV"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport window from 'global/window';\n\n/**\n * Generate a hash string based on number of character\n * @param {number} count\n * @returns {string} hash string\n */\nexport function generateHashId(count = 6) {\n  return Math.random()\n    .toString(36)\n    .substr(count);\n}\n\n/**\n * Detect chrome\n * @returns {boolean} - yes or no\n */\nexport function isChrome() {\n  // Chrome 1+\n  return window.chrome && window.chrome.webstore;\n}\n\n/**\n * whether is an object\n * @returns {boolean} - yes or no\n */\nexport function isPlainObject(obj) {\n  return obj === Object(obj) && typeof obj !== 'function' && !Array.isArray(obj);\n}\n\n/**\n * Capitalize first letter of a string\n * @param {string} str\n * @returns {string}\n */\nexport function capitalizeFirstLetter(str) {\n  return typeof str === 'string' ? str.charAt(0).toUpperCase() + str.slice(1) : str;\n}\n\n/**\n * Convert camel style names to title\n * strokeColor -> Stroke Color\n * @param {string} str\n * @returns {string}\n */\nexport function camelToTitle(str) {\n  const breakWord = str.replace(/([A-Z])/g, ' $1');\n  return capitalizeFirstLetter(breakWord);\n}\n\n/**\n * Convert names to camel style\n * Stroke Color -> strokeColor\n * @param {string} str\n * @returns {string}\n */\nexport const camelize = str => {\n  return str.replace(/(?:^\\w|[A-Z]|\\b\\w|\\s+)/g, (match, index) => {\n    if (Number(match) === 0) return ''; // or if (/\\s+/.test(match)) for white spaces\n    return index === 0 ? match.toLowerCase() : match.toUpperCase();\n  });\n};\n\n/**\n * Returns the img url for a given map export option\n * @param mode export option\n * @return {string} url\n */\nexport function getHTMLMapModeTileUrl(mode) {\n  return `https://d1a3f4spazzrp4.cloudfront.net/kepler.gl/documentation/map-${mode.toLowerCase()}-mode.png`;\n}\n\n/**\n * Converts non-arrays to arrays.  Leaves arrays alone.  Converts\n * undefined values to empty arrays ([] instead of [undefined]).\n * Otherwise, just returns [item] for non-array items.\n *\n * @param {*} item\n * @returns {array} boom! much array. very indexed. so useful.\n */\nexport function toArray(item) {\n  if (Array.isArray(item)) {\n    return item;\n  }\n\n  if (typeof item === 'undefined' || item === null) {\n    return [];\n  }\n\n  return [item];\n}\n\n/**\n * immutably insert value to an Array or Object\n * @param {Array|Object} obj\n * @param {Number|String} key\n * @param {*} value\n * @returns {Array|Object}\n */\nexport const insertValue = (obj, key, value) => {\n  if (Array.isArray(obj) && typeof key === 'number') {\n    return [...obj.slice(0, key), value, ...obj.slice(key + 1, obj.length)];\n  }\n\n  return {...obj, [key]: value};\n};\n\n/**\n * check if value is a loose object including a plain object, array, function\n * @param {*} value\n */\nexport function isObject(value) {\n  return value !== null && (typeof value === 'object' || typeof value === 'function');\n}\n\nconst setPath = ([key, ...next], value, obj) => {\n  // is Object allows js object, array and function\n  if (!isObject(obj)) {\n    return obj;\n  }\n\n  if (next.length === 0) {\n    return insertValue(obj, key, value);\n  }\n\n  // @ts-ignore\n  return insertValue(obj, key, setPath(next, value, obj.hasOwnProperty(key) ? obj[key] : {}));\n};\n\n/**\n * Immutable version of _.set\n * @param {Array<String|Number>} path\n * @param {*} value\n * @param {Object} obj\n * @returns {Object}\n */\n// @ts-ignore\nexport const set = (path, value, obj) => (obj === null ? obj : setPath(path, value, obj));\n\n/**\n * Get error information of unknown type\n * Extracts as much human readable information as possible\n * Ensure result is an Error object suitable for throw or promise rejection\n *\n * @private\n * @param {*}  err - Unknown error\n * @return {string} - human readable error msg\n */\nexport function getError(err) {\n  if (!err) {\n    return 'Something went wrong';\n  }\n\n  if (typeof err === 'string') {\n    return err;\n  } else if (err instanceof Error) {\n    return err.message;\n  } else if (typeof err === 'object') {\n    return err.error\n      ? getError(err.error)\n      : err.err\n      ? getError(err.err)\n      : err.message\n      ? getError(err.message)\n      : JSON.stringify(err);\n  }\n\n  // @ts-ignore\n  return null;\n}\n\nexport function arrayInsert(arr, index, val) {\n  if (!Array.isArray(arr)) {\n    return arr;\n  }\n\n  return [...arr.slice(0, index), val, ...arr.slice(index)];\n}\n\nexport function isTest() {\n  return process?.env?.NODE_ENV === 'test';\n}\n"]}

package/layers.js

@@ -0,0 +1,21 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+module.exports = require('./dist/layers');

package/localization.js

@@ -0,0 +1,21 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+module.exports = require('./dist/localization');

package/middleware.js

@@ -0,0 +1,21 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+module.exports = require('./dist/middleware');