@kepler.gl/utils 3.1.0-alpha.1 → 3.1.0-alpha.2

package/dist/indexed-data-container.d.ts

@@ -0,0 +1,34 @@
+import { DataContainerInterface, RangeOptions } from './data-container-interface';
+import { DataRow, SharedRowOptions } from './data-row';
+/**
+ * A data container wrapper around another data container.
+ * You have to pass an array of indices to reference rows in the parent data container.
+ * For example indices [3, 4, 6, 8] means that IndexedDataContainer is going to have
+ * 4 rows and row(2) points to 6th row in the referenced data container.
+ */
+export declare class IndexedDataContainer implements DataContainerInterface {
+    _parentDataContainer: DataContainerInterface;
+    _indices: number[];
+    constructor(parentDataContainer: DataContainerInterface, indices: number[]);
+    numRows(): number;
+    numColumns(): number;
+    /**
+     * Remaps a local index to an index in the parent dataset
+     * @param rowIndex
+     * @returns number
+     */
+    _mappedRowIndex(rowIndex: number): number;
+    valueAt(rowIndex: number, columnIndex: number): any;
+    row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow;
+    rowAsArray(rowIndex: number): any[];
+    rows(sharedRow?: SharedRowOptions): Generator<DataRow, any, unknown>;
+    column(columnIndex: number): Generator<any, any, unknown>;
+    getPlainIndex(): number[];
+    flattenData(): any[][];
+    map<T>(func: (row: DataRow, index: number) => T, sharedRow?: SharedRowOptions, options?: RangeOptions): T[];
+    mapIndex<T>(func: ({ index: number }: {
+        index: any;
+    }, dc: DataContainerInterface) => T, options?: RangeOptions): T[];
+    find(func: (row: DataRow, index: number) => boolean, sharedRow?: SharedRowOptions): DataRow | undefined;
+    reduce<T>(func: (acc: T, row: DataRow, index: number) => T, initialValue: T, sharedRow?: SharedRowOptions): T;
+}

package/dist/indexed-data-container.js

@@ -0,0 +1,214 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexedDataContainer = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+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); // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+/**
+ * @param dataContainer
+ * @param indices
+ * @param sharedRow
+ * @returns
+ */
+function rowsIterator(dataContainer, indices, sharedRow) {
+  var numRows, rowIndex, mappedRowIndex;
+  return _regenerator["default"].wrap(function rowsIterator$(_context) {
+    while (1) switch (_context.prev = _context.next) {
+      case 0:
+        numRows = indices.length;
+        rowIndex = 0;
+      case 2:
+        if (!(rowIndex < numRows)) {
+          _context.next = 9;
+          break;
+        }
+        mappedRowIndex = indices[rowIndex];
+        _context.next = 6;
+        return dataContainer.row(mappedRowIndex, sharedRow);
+      case 6:
+        ++rowIndex;
+        _context.next = 2;
+        break;
+      case 9:
+      case "end":
+        return _context.stop();
+    }
+  }, _marked);
+}
+
+/**
+ * @param dataContainer
+ * @param indices
+ * @param columnIndex
+ * @returns
+ */
+function columnIterator(dataContainer, indices, columnIndex) {
+  var numRows, rowIndex, mappedRowIndex;
+  return _regenerator["default"].wrap(function columnIterator$(_context2) {
+    while (1) switch (_context2.prev = _context2.next) {
+      case 0:
+        numRows = indices.length;
+        rowIndex = 0;
+      case 2:
+        if (!(rowIndex < numRows)) {
+          _context2.next = 9;
+          break;
+        }
+        mappedRowIndex = indices[rowIndex];
+        _context2.next = 6;
+        return dataContainer.valueAt(mappedRowIndex, columnIndex);
+      case 6:
+        ++rowIndex;
+        _context2.next = 2;
+        break;
+      case 9:
+      case "end":
+        return _context2.stop();
+    }
+  }, _marked2);
+}
+
+/**
+ * A data container wrapper around another data container.
+ * You have to pass an array of indices to reference rows in the parent data container.
+ * For example indices [3, 4, 6, 8] means that IndexedDataContainer is going to have
+ * 4 rows and row(2) points to 6th row in the referenced data container.
+ */
+var IndexedDataContainer = exports.IndexedDataContainer = /*#__PURE__*/function () {
+  function IndexedDataContainer(parentDataContainer, indices) {
+    (0, _classCallCheck2["default"])(this, IndexedDataContainer);
+    (0, _defineProperty2["default"])(this, "_parentDataContainer", void 0);
+    (0, _defineProperty2["default"])(this, "_indices", void 0);
+    this._parentDataContainer = parentDataContainer;
+    this._indices = indices;
+  }
+  return (0, _createClass2["default"])(IndexedDataContainer, [{
+    key: "numRows",
+    value: function numRows() {
+      return this._indices.length;
+    }
+  }, {
+    key: "numColumns",
+    value: function numColumns() {
+      return this._parentDataContainer.numColumns();
+    }
+
+    /**
+     * Remaps a local index to an index in the parent dataset
+     * @param rowIndex
+     * @returns number
+     */
+  }, {
+    key: "_mappedRowIndex",
+    value: function _mappedRowIndex(rowIndex) {
+      return this._indices[rowIndex];
+    }
+  }, {
+    key: "valueAt",
+    value: function valueAt(rowIndex, columnIndex) {
+      return this._parentDataContainer.valueAt(this._mappedRowIndex(rowIndex), columnIndex);
+    }
+  }, {
+    key: "row",
+    value: function row(rowIndex, sharedRow) {
+      return this._parentDataContainer.row(this._mappedRowIndex(rowIndex), sharedRow);
+    }
+  }, {
+    key: "rowAsArray",
+    value: function rowAsArray(rowIndex) {
+      return this._parentDataContainer.rowAsArray(this._mappedRowIndex(rowIndex));
+    }
+  }, {
+    key: "rows",
+    value: function rows(sharedRow) {
+      return rowsIterator(this._parentDataContainer, this._indices, sharedRow);
+    }
+  }, {
+    key: "column",
+    value: function column(columnIndex) {
+      return columnIterator(this._parentDataContainer, this._indices, columnIndex);
+    }
+  }, {
+    key: "getPlainIndex",
+    value: function getPlainIndex() {
+      return this._indices.map(function (_, i) {
+        return i;
+      });
+    }
+  }, {
+    key: "flattenData",
+    value: function flattenData() {
+      var _this = this;
+      var tSharedRow = _dataRow.DataRow.createSharedRow(true);
+      return this._indices.map(function (_, i) {
+        return _this.row(i, tSharedRow).values();
+      }, this);
+    }
+  }, {
+    key: "map",
+    value: function map(func, sharedRow) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      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 tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+      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: this._mappedRowIndex(rowIndex)
+        }, this._parentDataContainer));
+      }
+      return out;
+    }
+  }, {
+    key: "find",
+    value: function find(func, sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+      for (var rowIndex = 0; rowIndex < this.numRows(); ++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._indices.length; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        initialValue = func(initialValue, row, rowIndex);
+      }
+      return initialValue;
+    }
+  }]);
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_dataRow","require","_marked","_regenerator","mark","rowsIterator","_marked2","columnIterator","dataContainer","indices","sharedRow","numRows","rowIndex","mappedRowIndex","wrap","rowsIterator$","_context","prev","next","length","row","stop","columnIndex","columnIterator$","_context2","valueAt","IndexedDataContainer","exports","parentDataContainer","_classCallCheck2","_defineProperty2","_parentDataContainer","_indices","_createClass2","key","value","numColumns","_mappedRowIndex","rowAsArray","rows","column","getPlainIndex","map","_","i","flattenData","_this","tSharedRow","DataRow","createSharedRow","values","func","options","arguments","undefined","_options$start","start","_options$end","end","endRow","Math","min","out","push","mapIndex","_options$start2","_options$end2","index","find","reduce","initialValue"],"sources":["../src/indexed-data-container.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {DataContainerInterface, RangeOptions} from './data-container-interface';\nimport {DataRow, SharedRowOptions} from './data-row';\n\n/**\n * @param dataContainer\n * @param indices\n * @param sharedRow\n * @returns\n */\nfunction* rowsIterator(\n  dataContainer: DataContainerInterface,\n  indices: number[],\n  sharedRow: SharedRowOptions\n): Generator<DataRow> {\n  const numRows = indices.length;\n  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {\n    const mappedRowIndex = indices[rowIndex];\n    yield dataContainer.row(mappedRowIndex, sharedRow);\n  }\n}\n\n/**\n * @param dataContainer\n * @param indices\n * @param columnIndex\n * @returns\n */\nfunction* columnIterator(\n  dataContainer: DataContainerInterface,\n  indices: number[],\n  columnIndex: number\n): Generator<any> {\n  const numRows = indices.length;\n  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {\n    const mappedRowIndex = indices[rowIndex];\n    yield dataContainer.valueAt(mappedRowIndex, columnIndex);\n  }\n}\n\n/**\n * A data container wrapper around another data container.\n * You have to pass an array of indices to reference rows in the parent data container.\n * For example indices [3, 4, 6, 8] means that IndexedDataContainer is going to have\n * 4 rows and row(2) points to 6th row in the referenced data container.\n */\nexport class IndexedDataContainer implements DataContainerInterface {\n  _parentDataContainer: DataContainerInterface;\n  _indices: number[];\n\n  constructor(parentDataContainer: DataContainerInterface, indices: number[]) {\n    this._parentDataContainer = parentDataContainer;\n    this._indices = indices;\n  }\n\n  numRows(): number {\n    return this._indices.length;\n  }\n\n  numColumns(): number {\n    return this._parentDataContainer.numColumns();\n  }\n\n  /**\n   * Remaps a local index to an index in the parent dataset\n   * @param rowIndex\n   * @returns number\n   */\n  _mappedRowIndex(rowIndex: number): number {\n    return this._indices[rowIndex];\n  }\n\n  valueAt(rowIndex: number, columnIndex: number): any {\n    return this._parentDataContainer.valueAt(this._mappedRowIndex(rowIndex), columnIndex);\n  }\n\n  row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow {\n    return this._parentDataContainer.row(this._mappedRowIndex(rowIndex), sharedRow);\n  }\n\n  rowAsArray(rowIndex: number): any[] {\n    return this._parentDataContainer.rowAsArray(this._mappedRowIndex(rowIndex));\n  }\n\n  rows(sharedRow?: SharedRowOptions) {\n    return rowsIterator(this._parentDataContainer, this._indices, sharedRow);\n  }\n\n  column(columnIndex: number) {\n    return columnIterator(this._parentDataContainer, this._indices, columnIndex);\n  }\n\n  getPlainIndex(): number[] {\n    return this._indices.map((_, i) => i);\n  }\n\n  flattenData(): any[][] {\n    const tSharedRow = DataRow.createSharedRow(true);\n\n    return this._indices.map((_, i) => {\n      return this.row(i, tSharedRow).values();\n    }, this);\n  }\n\n  map<T>(\n    func: (row: DataRow, index: number) => T,\n    sharedRow?: SharedRowOptions,\n    options: RangeOptions = {}\n  ): T[] {\n    const {start = 0, end = this.numRows()} = options;\n    const endRow = Math.min(this.numRows(), end);\n\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    const out: T[] = [];\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<T>(\n    func: ({index: number}, dc: DataContainerInterface) => T,\n    options: RangeOptions = {}\n  ): T[] {\n    const {start = 0, end = this.numRows()} = options;\n    const endRow = Math.min(this.numRows(), end);\n\n    const out: T[] = [];\n    for (let rowIndex = start; rowIndex < endRow; ++rowIndex) {\n      out.push(func({index: this._mappedRowIndex(rowIndex)}, this._parentDataContainer));\n    }\n    return out;\n  }\n\n  find(\n    func: (row: DataRow, index: number) => boolean,\n    sharedRow?: SharedRowOptions\n  ): DataRow | undefined {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this.numRows(); ++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<T>(\n    func: (acc: T, row: DataRow, index: number) => T,\n    initialValue: T,\n    sharedRow?: SharedRowOptions\n  ): T {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this._indices.length; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      initialValue = func(initialValue, row, rowIndex);\n    }\n    return initialValue;\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/locale-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const flattenMessages: (nestedMessages: any, prefix?: string) => {};
+export declare const mergeMessages: (defaultMessages: any, userMessages: any) => any;

package/dist/locale-utils.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeMessages = exports.flattenMessages = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _utils = require("./utils");
+var _console = _interopRequireDefault(require("global/console"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+// Flat messages since react-intl does not seem to support nested structures
+// Adapted from https://medium.com/siren-apparel-press/internationalization-and-localization-of-sirenapparel-eu-sirenapparel-us-and-sirenapparel-asia-ddee266066a2
+var _flattenMessages = exports.flattenMessages = function flattenMessages(nestedMessages) {
+  var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return Object.keys(nestedMessages).reduce(function (messages, key) {
+    var value = nestedMessages[key];
+    var prefixedKey = prefix ? "".concat(prefix, ".").concat(key) : key;
+    if (typeof value === 'string') {
+      messages[prefixedKey] = value;
+    } else {
+      Object.assign(messages, _flattenMessages(value, prefixedKey));
+    }
+    return messages;
+  }, {});
+};
+var mergeMessages = exports.mergeMessages = function mergeMessages(defaultMessages, userMessages) {
+  if (!(0, _utils.isObject)(userMessages) || !(0, _utils.isObject)(userMessages.en)) {
+    _console["default"].error('message should be an object and contain at least the `en` translation. Read more at https://docs.kepler.gl/docs/api-reference/localization');
+    return defaultMessages;
+  }
+  var userEnFlat = _flattenMessages(userMessages.en);
+  return Object.keys(defaultMessages).reduce(function (acc, key) {
+    return _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2["default"])({}, key, key === 'en' ? _objectSpread(_objectSpread({}, defaultMessages.en), userEnFlat) : _objectSpread(_objectSpread(_objectSpread({}, defaultMessages[key]), userEnFlat), _flattenMessages(userMessages[key] || {}))));
+  }, {});
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/map-info-utils.d.ts

@@ -0,0 +1 @@
+export declare function isValidMapInfo(mapInfo: any): any;

package/dist/map-info-utils.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidMapInfo = isValidMapInfo;
+var _constants = require("@kepler.gl/constants");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+function isValidMapInfo(mapInfo) {
+  return mapInfo.title.length && mapInfo.title.length <= _constants.MAP_INFO_CHARACTER.title && (!mapInfo.description.length || mapInfo.description.length <= _constants.MAP_INFO_CHARACTER.description);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfY29uc3RhbnRzIiwicmVxdWlyZSIsImlzVmFsaWRNYXBJbmZvIiwibWFwSW5mbyIsInRpdGxlIiwibGVuZ3RoIiwiTUFQX0lORk9fQ0hBUkFDVEVSIiwiZGVzY3JpcHRpb24iXSwic291cmNlcyI6WyIuLi9zcmMvbWFwLWluZm8tdXRpbHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVFxuLy8gQ29weXJpZ2h0IGNvbnRyaWJ1dG9ycyB0byB0aGUga2VwbGVyLmdsIHByb2plY3RcblxuaW1wb3J0IHtNQVBfSU5GT19DSEFSQUNURVJ9IGZyb20gJ0BrZXBsZXIuZ2wvY29uc3RhbnRzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGlzVmFsaWRNYXBJbmZvKG1hcEluZm8pIHtcbiAgcmV0dXJuIChcbiAgICBtYXBJbmZvLnRpdGxlLmxlbmd0aCAmJlxuICAgIG1hcEluZm8udGl0bGUubGVuZ3RoIDw9IE1BUF9JTkZPX0NIQVJBQ1RFUi50aXRsZSAmJlxuICAgICghbWFwSW5mby5kZXNjcmlwdGlvbi5sZW5ndGggfHwgbWFwSW5mby5kZXNjcmlwdGlvbi5sZW5ndGggPD0gTUFQX0lORk9fQ0hBUkFDVEVSLmRlc2NyaXB0aW9uKVxuICApO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFHQSxJQUFBQSxVQUFBLEdBQUFDLE9BQUE7QUFIQTtBQUNBOztBQUlPLFNBQVNDLGNBQWNBLENBQUNDLE9BQU8sRUFBRTtFQUN0QyxPQUNFQSxPQUFPLENBQUNDLEtBQUssQ0FBQ0MsTUFBTSxJQUNwQkYsT0FBTyxDQUFDQyxLQUFLLENBQUNDLE1BQU0sSUFBSUMsNkJBQWtCLENBQUNGLEtBQUssS0FDL0MsQ0FBQ0QsT0FBTyxDQUFDSSxXQUFXLENBQUNGLE1BQU0sSUFBSUYsT0FBTyxDQUFDSSxXQUFXLENBQUNGLE1BQU0sSUFBSUMsNkJBQWtCLENBQUNDLFdBQVcsQ0FBQztBQUVqRyIsImlnbm9yZUxpc3QiOltdfQ==

package/dist/map-style-utils/mapbox-gl-style-editor.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="lodash" />
+import { BaseMapStyle, LayerGroup, MapState } from '@kepler.gl/types';
+export declare function getDefaultLayerGroupVisibility({ layerGroups }: {
+    layerGroups: LayerGroup[];
+}): {};
+/**
+ * Edit preset map style to keep only visible layers
+ *
+ * @param mapStyle - preset map style
+ * @param visibleLayerGroups - visible layers of top map
+ * @returns top map style
+ */
+export declare const editTopMapStyle: (({ mapStyle, visibleLayerGroups }: {
+    id?: string | undefined;
+    mapStyle: BaseMapStyle;
+    visibleLayerGroups: false | {
+        [id: string]: boolean | LayerGroup;
+    };
+}) => {
+    layers: any;
+}) & import("lodash").MemoizedFunction;
+/**
+ * Edit preset map style to filter out invisible layers
+ *
+ * @param {Object} mapStyle - preset map style
+ * @param {Object} visibleLayerGroups - visible layers of bottom map
+ * @returns {Object} bottom map style
+ */
+export declare const editBottomMapStyle: (({ id, mapStyle, visibleLayerGroups }: any) => any) & import("lodash").MemoizedFunction;
+export declare function getStyleDownloadUrl(styleUrl: any, accessToken: any, mapboxApiUrl: any): any;
+/**
+ * Generate static map image from style Url to be used as icon
+ * @param param
+ * @param param.styleUrl
+ * @param param.mapboxApiAccessToken
+ * @param param.mapboxApiUrl
+ * @param param.mapState
+ * @param param.mapW
+ * @param param.mapH
+ */
+export declare function getStyleImageIcon({ styleUrl, mapboxApiAccessToken, mapboxApiUrl, mapState, mapW, mapH }: {
+    styleUrl: string;
+    mapboxApiAccessToken: string;
+    mapboxApiUrl?: string;
+    mapState?: Partial<MapState>;
+    mapW?: number;
+    mapH?: number;
+}): string;
+export declare function scaleMapStyleByResolution(mapboxStyle: any, scale: any): any;
+/**
+ * When switch to a new style, try to keep current layer group visibility
+ * by merging default and current
+ * @param {Object} defaultLayerGroup
+ * @param {Object} currentLayerGroup
+ * @return {Object} mergedLayerGroups
+ */
+export declare function mergeLayerGroupVisibility(defaultLayerGroup: any, currentLayerGroup: any): any;

package/dist/map-style-utils/mapbox-gl-style-editor.js

@@ -0,0 +1,188 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.editTopMapStyle = exports.editBottomMapStyle = void 0;
+exports.getDefaultLayerGroupVisibility = getDefaultLayerGroupVisibility;
+exports.getStyleDownloadUrl = getStyleDownloadUrl;
+exports.getStyleImageIcon = getStyleImageIcon;
+exports.mergeLayerGroupVisibility = mergeLayerGroupVisibility;
+exports.scaleMapStyleByResolution = scaleMapStyleByResolution;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _lodash = _interopRequireDefault(require("lodash.memoize"));
+var _lodash2 = _interopRequireDefault(require("lodash.clonedeep"));
+var _constants = require("@kepler.gl/constants");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+function getDefaultLayerGroupVisibility(_ref) {
+  var _ref$layerGroups = _ref.layerGroups,
+    layerGroups = _ref$layerGroups === void 0 ? [] : _ref$layerGroups;
+  return layerGroups.reduce(function (accu, layer) {
+    return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, layer.slug, layer.defaultVisibility));
+  }, {});
+}
+var resolver = function resolver(_ref2) {
+  var id = _ref2.id,
+    _ref2$visibleLayerGro = _ref2.visibleLayerGroups,
+    visibleLayerGroups = _ref2$visibleLayerGro === void 0 ? {} : _ref2$visibleLayerGro;
+  return "".concat(id, ":").concat(Object.keys(visibleLayerGroups).filter(function (d) {
+    return visibleLayerGroups[d];
+  }).sort().join('-'));
+};
+
+/**
+ * Edit preset map style to keep only visible layers
+ *
+ * @param mapStyle - preset map style
+ * @param visibleLayerGroups - visible layers of top map
+ * @returns top map style
+ */
+var editTopMapStyle = exports.editTopMapStyle = (0, _lodash["default"])(function (_ref3) {
+  var mapStyle = _ref3.mapStyle,
+    visibleLayerGroups = _ref3.visibleLayerGroups;
+  var visibleFilters = (mapStyle.layerGroups || []).filter(function (lg) {
+    return visibleLayerGroups[lg.slug];
+  }).map(function (lg) {
+    return lg.filter;
+  });
+
+  // if top map
+  // keep only visible layers
+  // @ts-expect-error
+  var filteredLayers = mapStyle.style.layers.filter(function (layer) {
+    return visibleFilters.some(function (match) {
+      return match(layer);
+    });
+  });
+  return _objectSpread(_objectSpread({}, mapStyle.style), {}, {
+    layers: filteredLayers
+  });
+}, resolver);
+
+/**
+ * Edit preset map style to filter out invisible layers
+ *
+ * @param {Object} mapStyle - preset map style
+ * @param {Object} visibleLayerGroups - visible layers of bottom map
+ * @returns {Object} bottom map style
+ */
+var editBottomMapStyle = exports.editBottomMapStyle = (0, _lodash["default"])(function (_ref4) {
+  var id = _ref4.id,
+    mapStyle = _ref4.mapStyle,
+    visibleLayerGroups = _ref4.visibleLayerGroups;
+  if (id === _constants.NO_MAP_ID) {
+    return _constants.EMPTY_MAPBOX_STYLE;
+  }
+  var invisibleFilters = (mapStyle.layerGroups || []).filter(function (lg) {
+    return !visibleLayerGroups[lg.slug];
+  }).map(function (lg) {
+    return lg.filter;
+  });
+
+  // if bottom map
+  // filter out invisible layers
+  var filteredLayers = mapStyle.style.layers.filter(function (layer) {
+    return invisibleFilters.every(function (match) {
+      return !match(layer);
+    });
+  });
+  return _objectSpread(_objectSpread({}, mapStyle.style), {}, {
+    layers: filteredLayers
+  });
+}, resolver);
+function getStyleDownloadUrl(styleUrl, accessToken, mapboxApiUrl) {
+  if (styleUrl.startsWith('http')) {
+    return styleUrl;
+  }
+
+  // mapbox://styles/jckr/cjhcl0lxv13di2rpfoytdbdyj
+  if (styleUrl.startsWith('mapbox://styles')) {
+    var styleId = styleUrl.replace('mapbox://styles/', '');
+
+    // https://api.mapbox.com/styles/v1/heshan0131/cjg1bfumo1cwm2rlrjxkinfgw?pluginName=Keplergl&access_token=<token>
+    return "".concat(mapboxApiUrl || _constants.DEFAULT_MAPBOX_API_URL, "/styles/v1/").concat(styleId, "?pluginName=Keplergl&access_token=").concat(accessToken);
+  }
+
+  // style url not recognized
+  return null;
+}
+
+/**
+ * Generate static map image from style Url to be used as icon
+ * @param param
+ * @param param.styleUrl
+ * @param param.mapboxApiAccessToken
+ * @param param.mapboxApiUrl
+ * @param param.mapState
+ * @param param.mapW
+ * @param param.mapH
+ */
+function getStyleImageIcon(_ref5) {
+  var styleUrl = _ref5.styleUrl,
+    mapboxApiAccessToken = _ref5.mapboxApiAccessToken,
+    _ref5$mapboxApiUrl = _ref5.mapboxApiUrl,
+    mapboxApiUrl = _ref5$mapboxApiUrl === void 0 ? _constants.DEFAULT_MAPBOX_API_URL : _ref5$mapboxApiUrl,
+    _ref5$mapState = _ref5.mapState,
+    mapState = _ref5$mapState === void 0 ? {
+      longitude: -122.3391,
+      latitude: 37.7922,
+      zoom: 9
+    } : _ref5$mapState,
+    _ref5$mapW = _ref5.mapW,
+    mapW = _ref5$mapW === void 0 ? 400 : _ref5$mapW,
+    _ref5$mapH = _ref5.mapH,
+    mapH = _ref5$mapH === void 0 ? 300 : _ref5$mapH;
+  var styleId = styleUrl.replace('mapbox://styles/', '');
+  return "".concat(mapboxApiUrl, "/styles/v1/").concat(styleId, "/static/") + "".concat(mapState.longitude, ",").concat(mapState.latitude, ",").concat(mapState.zoom, ",0,0/") + "".concat(mapW, "x").concat(mapH) + "?access_token=".concat(mapboxApiAccessToken, "&logo=false&attribution=false");
+}
+function scaleMapStyleByResolution(mapboxStyle, scale) {
+  if (scale !== 1 && mapboxStyle) {
+    var labelLayerGroup = _constants.DEFAULT_LAYER_GROUPS.find(function (lg) {
+      return lg.slug === 'label';
+    });
+    // @ts-ignore
+    var labelLayerFilter = labelLayerGroup.filter;
+    var zoomOffset = Math.log2(scale);
+    var copyStyle = (0, _lodash2["default"])(mapboxStyle);
+    (copyStyle.layers || []).forEach(function (d) {
+      // edit minzoom and maxzoom
+      if (d.maxzoom) {
+        d.maxzoom = Math.max(d.maxzoom + zoomOffset, 1);
+      }
+      if (d.minzoom) {
+        d.minzoom = Math.max(d.minzoom + zoomOffset, 1);
+      }
+
+      // edit text size
+      if (labelLayerFilter(d)) {
+        if (d.layout && d.layout['text-size'] && Array.isArray(d.layout['text-size'].stops)) {
+          d.layout['text-size'].stops.forEach(function (stop) {
+            // zoom
+            stop[0] = Math.max(stop[0] + zoomOffset, 1);
+            // size
+            stop[1] *= scale;
+          });
+        }
+      }
+    });
+    return copyStyle;
+  }
+  return mapboxStyle;
+}
+
+/**
+ * When switch to a new style, try to keep current layer group visibility
+ * by merging default and current
+ * @param {Object} defaultLayerGroup
+ * @param {Object} currentLayerGroup
+ * @return {Object} mergedLayerGroups
+ */
+function mergeLayerGroupVisibility(defaultLayerGroup, currentLayerGroup) {
+  return Object.keys(defaultLayerGroup).reduce(function (accu, key) {
+    return _objectSpread(_objectSpread({}, accu), Object.prototype.hasOwnProperty.call(currentLayerGroup, key) ? (0, _defineProperty2["default"])({}, key, currentLayerGroup[key]) : {});
+  }, defaultLayerGroup);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_lodash2","_constants","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","getDefaultLayerGroupVisibility","_ref","_ref$layerGroups","layerGroups","reduce","accu","layer","slug","defaultVisibility","resolver","_ref2","id","_ref2$visibleLayerGro","visibleLayerGroups","concat","d","sort","join","editTopMapStyle","exports","memoize","_ref3","mapStyle","visibleFilters","lg","map","filteredLayers","style","layers","some","match","editBottomMapStyle","_ref4","NO_MAP_ID","EMPTY_MAPBOX_STYLE","invisibleFilters","every","getStyleDownloadUrl","styleUrl","accessToken","mapboxApiUrl","startsWith","styleId","replace","DEFAULT_MAPBOX_API_URL","getStyleImageIcon","_ref5","mapboxApiAccessToken","_ref5$mapboxApiUrl","_ref5$mapState","mapState","longitude","latitude","zoom","_ref5$mapW","mapW","_ref5$mapH","mapH","scaleMapStyleByResolution","mapboxStyle","scale","labelLayerGroup","DEFAULT_LAYER_GROUPS","find","labelLayerFilter","zoomOffset","Math","log2","copyStyle","clondDeep","maxzoom","max","minzoom","layout","Array","isArray","stops","stop","mergeLayerGroupVisibility","defaultLayerGroup","currentLayerGroup","key","prototype","hasOwnProperty","call"],"sources":["../../src/map-style-utils/mapbox-gl-style-editor.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport memoize from 'lodash.memoize';\nimport clondDeep from 'lodash.clonedeep';\nimport {\n  DEFAULT_LAYER_GROUPS,\n  DEFAULT_MAPBOX_API_URL,\n  NO_MAP_ID,\n  EMPTY_MAPBOX_STYLE\n} from '@kepler.gl/constants';\nimport {BaseMapStyle, LayerGroup, MapState} from '@kepler.gl/types';\n\nexport function getDefaultLayerGroupVisibility({layerGroups = []}: {layerGroups: LayerGroup[]}) {\n  return layerGroups.reduce(\n    (accu, layer) => ({\n      ...accu,\n      [layer.slug]: layer.defaultVisibility\n    }),\n    {}\n  );\n}\n\nconst resolver = ({\n  id,\n  visibleLayerGroups = {}\n}: {\n  id?: string;\n  mapStyle: BaseMapStyle;\n  visibleLayerGroups: {[id: string]: LayerGroup | boolean} | false;\n}) =>\n  `${id}:${Object.keys(visibleLayerGroups)\n    .filter(d => visibleLayerGroups[d])\n    .sort()\n    .join('-')}`;\n\n/**\n * Edit preset map style to keep only visible layers\n *\n * @param mapStyle - preset map style\n * @param visibleLayerGroups - visible layers of top map\n * @returns top map style\n */\nexport const editTopMapStyle = memoize(\n  ({\n    mapStyle,\n    visibleLayerGroups\n  }: {\n    id?: string;\n    mapStyle: BaseMapStyle;\n    visibleLayerGroups: {[id: string]: LayerGroup | boolean} | false;\n  }) => {\n    const visibleFilters = (mapStyle.layerGroups || [])\n      .filter(lg => visibleLayerGroups[lg.slug])\n      .map(lg => lg.filter);\n\n    // if top map\n    // keep only visible layers\n    // @ts-expect-error\n    const filteredLayers = mapStyle.style.layers.filter(layer =>\n      visibleFilters.some(match => match(layer))\n    );\n\n    return {\n      ...mapStyle.style,\n      layers: filteredLayers\n    };\n  },\n  resolver\n);\n\n/**\n * Edit preset map style to filter out invisible layers\n *\n * @param {Object} mapStyle - preset map style\n * @param {Object} visibleLayerGroups - visible layers of bottom map\n * @returns {Object} bottom map style\n */\nexport const editBottomMapStyle = memoize(({id, mapStyle, visibleLayerGroups}) => {\n  if (id === NO_MAP_ID) {\n    return EMPTY_MAPBOX_STYLE;\n  }\n\n  const invisibleFilters = (mapStyle.layerGroups || [])\n    .filter(lg => !visibleLayerGroups[lg.slug])\n    .map(lg => lg.filter);\n\n  // if bottom map\n  // filter out invisible layers\n  const filteredLayers = mapStyle.style.layers.filter(layer =>\n    invisibleFilters.every(match => !match(layer))\n  );\n\n  return {\n    ...mapStyle.style,\n    layers: filteredLayers\n  };\n}, resolver);\n\nexport function getStyleDownloadUrl(styleUrl, accessToken, mapboxApiUrl) {\n  if (styleUrl.startsWith('http')) {\n    return styleUrl;\n  }\n\n  // mapbox://styles/jckr/cjhcl0lxv13di2rpfoytdbdyj\n  if (styleUrl.startsWith('mapbox://styles')) {\n    const styleId = styleUrl.replace('mapbox://styles/', '');\n\n    // https://api.mapbox.com/styles/v1/heshan0131/cjg1bfumo1cwm2rlrjxkinfgw?pluginName=Keplergl&access_token=<token>\n    return `${\n      mapboxApiUrl || DEFAULT_MAPBOX_API_URL\n    }/styles/v1/${styleId}?pluginName=Keplergl&access_token=${accessToken}`;\n  }\n\n  // style url not recognized\n  return null;\n}\n\n/**\n * Generate static map image from style Url to be used as icon\n * @param param\n * @param param.styleUrl\n * @param param.mapboxApiAccessToken\n * @param param.mapboxApiUrl\n * @param param.mapState\n * @param param.mapW\n * @param param.mapH\n */\nexport function getStyleImageIcon({\n  styleUrl,\n  mapboxApiAccessToken,\n  mapboxApiUrl = DEFAULT_MAPBOX_API_URL,\n  mapState = {\n    longitude: -122.3391,\n    latitude: 37.7922,\n    zoom: 9\n  },\n  mapW = 400,\n  mapH = 300\n}: {\n  styleUrl: string;\n  mapboxApiAccessToken: string;\n  mapboxApiUrl?: string;\n  mapState?: Partial<MapState>;\n  mapW?: number;\n  mapH?: number;\n}) {\n  const styleId = styleUrl.replace('mapbox://styles/', '');\n\n  return (\n    `${mapboxApiUrl}/styles/v1/${styleId}/static/` +\n    `${mapState.longitude},${mapState.latitude},${mapState.zoom},0,0/` +\n    `${mapW}x${mapH}` +\n    `?access_token=${mapboxApiAccessToken}&logo=false&attribution=false`\n  );\n}\n\nexport function scaleMapStyleByResolution(mapboxStyle, scale) {\n  if (scale !== 1 && mapboxStyle) {\n    const labelLayerGroup = DEFAULT_LAYER_GROUPS.find(lg => lg.slug === 'label');\n    // @ts-ignore\n    const {filter: labelLayerFilter} = labelLayerGroup;\n    const zoomOffset = Math.log2(scale);\n\n    const copyStyle = clondDeep(mapboxStyle);\n    (copyStyle.layers || []).forEach(d => {\n      // edit minzoom and maxzoom\n      if (d.maxzoom) {\n        d.maxzoom = Math.max(d.maxzoom + zoomOffset, 1);\n      }\n\n      if (d.minzoom) {\n        d.minzoom = Math.max(d.minzoom + zoomOffset, 1);\n      }\n\n      // edit text size\n      if (labelLayerFilter(d)) {\n        if (d.layout && d.layout['text-size'] && Array.isArray(d.layout['text-size'].stops)) {\n          d.layout['text-size'].stops.forEach(stop => {\n            // zoom\n            stop[0] = Math.max(stop[0] + zoomOffset, 1);\n            // size\n            stop[1] *= scale;\n          });\n        }\n      }\n    });\n\n    return copyStyle;\n  }\n\n  return mapboxStyle;\n}\n\n/**\n * When switch to a new style, try to keep current layer group visibility\n * by merging default and current\n * @param {Object} defaultLayerGroup\n * @param {Object} currentLayerGroup\n * @return {Object} mergedLayerGroups\n */\nexport function mergeLayerGroupVisibility(defaultLayerGroup, currentLayerGroup) {\n  return Object.keys(defaultLayerGroup).reduce(\n    (accu, key) => ({\n      ...accu,\n      ...(Object.prototype.hasOwnProperty.call(currentLayerGroup, key)\n        ? {[key]: currentLayerGroup[key]}\n        : {})\n    }),\n    defaultLayerGroup\n  );\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/map-style-utils/mapbox-utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Determines whether a Map Style is using Mapbox Tiles
+ * @param {any} mapStyle the mapStyle to check
+ * @returns true if the style is using Mapbox tiles
+ */
+export declare function isStyleUsingMapboxTiles(mapStyle: any): boolean;
+/**
+ * Transform mapbox protocol so can be used with maplibre
+ * @param mapboxKey mapbox api key
+ * @returns transformed url
+ */
+export declare const transformRequest: (mapboxKey: string) => (url: string, resourceType: string) => {
+    url: string;
+};