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

package/dist/schemas/schema-manager.js

@@ -0,0 +1,262 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.KeplerGLSchema = exports.reducerSchema = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _window = require("global/window");
+
+var _visStateSchema = _interopRequireDefault(require("./vis-state-schema"));
+
+var _datasetSchema = _interopRequireDefault(require("./dataset-schema"));
+
+var _mapStyleSchema = _interopRequireDefault(require("./map-style-schema"));
+
+var _mapStateSchema = _interopRequireDefault(require("./map-state-schema"));
+
+var _versions = require("./versions");
+
+var _utils = require("../utils/utils");
+
+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; }
+
+var reducerSchema = {
+  visState: _visStateSchema["default"],
+  mapState: _mapStateSchema["default"],
+  mapStyle: _mapStyleSchema["default"]
+};
+/** @type {typeof import('./schema-manager').KeplerGLSchema} */
+
+exports.reducerSchema = reducerSchema;
+
+var KeplerGLSchema = /*#__PURE__*/function () {
+  function KeplerGLSchema() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref$reducers = _ref.reducers,
+        reducers = _ref$reducers === void 0 ? reducerSchema : _ref$reducers,
+        _ref$datasets = _ref.datasets,
+        datasets = _ref$datasets === void 0 ? _datasetSchema["default"] : _ref$datasets,
+        _ref$validVersions = _ref.validVersions,
+        validVersions = _ref$validVersions === void 0 ? _versions.VERSIONS : _ref$validVersions,
+        _ref$version = _ref.version,
+        version = _ref$version === void 0 ? _versions.CURRENT_VERSION : _ref$version;
+
+    (0, _classCallCheck2["default"])(this, KeplerGLSchema);
+    this._validVersions = validVersions;
+    this._version = version;
+    this._reducerSchemas = reducers;
+    this._datasetSchema = datasets;
+    this._datasetLastSaved = null;
+    this._savedDataset = null;
+  }
+  /**
+   * stateToSave = {
+   *   datasets: [
+   *     {
+   *       version: 'v0',
+   *       data: {id, label, color, allData, fields}
+   *     },
+   *     {
+   *       version: 'v0',
+   *       data: {id, label, color, allData, fields}
+   *     }
+   *   ],
+   *   config: {
+   *     version: 'v0',
+   *     config: {}
+   *   },
+   *   info: {
+   *     app: 'kepler.gl',
+   *     create_at: 'Mon May 28 2018 21:04:46 GMT-0700 (PDT)'
+   *   }
+   * }
+   *
+   * Get config and data of current map to save
+   * @param state
+   * @returns app state to save
+   */
+
+
+  (0, _createClass2["default"])(KeplerGLSchema, [{
+    key: "save",
+    value: function save(state) {
+      return {
+        datasets: this.getDatasetToSave(state),
+        config: this.getConfigToSave(state),
+        info: _objectSpread({
+          app: 'kepler.gl',
+          created_at: new Date().toString()
+        }, this.getMapInfo(state))
+      };
+    }
+  }, {
+    key: "getMapInfo",
+    value: function getMapInfo(state) {
+      return state.visState.mapInfo;
+    }
+    /**
+     *  Load saved map, argument can be (datasets, config) or ({datasets, config})
+     * @param savedDatasets
+     * @param savedConfig
+     */
+
+  }, {
+    key: "load",
+    value: function load(savedDatasets, savedConfig) {
+      // if pass dataset and config in as a single object
+      if (arguments.length === 1 && (0, _utils.isPlainObject)(arguments[0]) && (Array.isArray(arguments[0].datasets) || (0, _utils.isPlainObject)(arguments[0].config))) {
+        return this.load(arguments[0].datasets, arguments[0].config);
+      }
+
+      return _objectSpread(_objectSpread({}, Array.isArray(savedDatasets) ? {
+        datasets: this.parseSavedData(savedDatasets)
+      } : {}), savedConfig ? {
+        config: this.parseSavedConfig(savedConfig)
+      } : {});
+    }
+    /**
+     * Get data to save
+     * @param state - app state
+     * @returns - dataset to save
+     */
+
+  }, {
+    key: "getDatasetToSave",
+    value: function getDatasetToSave(state) {
+      var _this = this;
+
+      var dataChangedSinceLastSave = this.hasDataChanged(state);
+
+      if (!dataChangedSinceLastSave) {
+        return this._savedDataset;
+      }
+
+      var visState = state.visState;
+      var datasets = Object.values(visState.datasets).map(function (ds) {
+        return {
+          version: _this._version,
+          data: _this._datasetSchema[_this._version].save(ds)
+        };
+      }); // keep a copy of formatted datasets to save
+
+      this._datasetLastSaved = visState.datasets;
+      this._savedDataset = datasets;
+      return datasets;
+    }
+    /**
+     * Get App config to save
+     * @param {Object} state - app state
+     * @returns {{version: String, config: Object}} - config to save
+     */
+
+  }, {
+    key: "getConfigToSave",
+    value: function getConfigToSave(state) {
+      var _this2 = this;
+
+      var config = Object.keys(this._reducerSchemas).reduce(function (accu, key) {
+        return _objectSpread(_objectSpread({}, accu), state[key] ? _this2._reducerSchemas[key][_this2._version].save(state[key]) : {});
+      }, {});
+      return {
+        version: this._version,
+        config: config
+      };
+    }
+    /**
+     * Parse saved data
+     * @param datasets
+     * @returns - dataset to pass to addDataToMap
+     */
+
+  }, {
+    key: "parseSavedData",
+    value: function parseSavedData(datasets) {
+      var _this3 = this;
+
+      return datasets.reduce(function (accu, ds) {
+        var validVersion = _this3.validateVersion(ds.version);
+
+        if (!validVersion) {
+          return accu;
+        }
+
+        accu.push(_this3._datasetSchema[validVersion].load(ds.data));
+        return accu;
+      }, []);
+    }
+    /**
+     * Parse saved App config
+     */
+
+  }, {
+    key: "parseSavedConfig",
+    value: function parseSavedConfig(_ref2) {
+      var _this4 = this;
+
+      var version = _ref2.version,
+          config = _ref2.config;
+      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var validVersion = this.validateVersion(version);
+
+      if (!validVersion) {
+        return null;
+      }
+
+      return Object.keys(config).reduce(function (accu, key) {
+        return _objectSpread(_objectSpread({}, accu), key in _this4._reducerSchemas ? _this4._reducerSchemas[key][validVersion].load(config[key]) : {});
+      }, {});
+    }
+    /**
+     * Validate version
+     * @param version
+     * @returns validVersion
+     */
+
+  }, {
+    key: "validateVersion",
+    value: function validateVersion(version) {
+      if (!version) {
+        _window.console.error('There is no version number associated with this saved map');
+
+        return null;
+      }
+
+      if (!this._validVersions[version]) {
+        _window.console.error("".concat(version, " is not a valid version"));
+
+        return null;
+      }
+
+      return version;
+    }
+    /**
+     * Check if data has changed since last save
+     * @param state
+     * @returns - whether data has changed or not
+     */
+
+  }, {
+    key: "hasDataChanged",
+    value: function hasDataChanged(state) {
+      return this._datasetLastSaved !== state.visState.datasets;
+    }
+  }]);
+  return KeplerGLSchema;
+}();
+
+exports.KeplerGLSchema = KeplerGLSchema;
+var KeplerGLSchemaManager = new KeplerGLSchema();
+var _default = KeplerGLSchemaManager;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/schemas/schema-manager.js"],"names":["reducerSchema","visState","visStateSchema","mapState","mapStateSchema","mapStyle","mapStyleSchema","KeplerGLSchema","reducers","datasets","datasetSchema","validVersions","VERSIONS","version","CURRENT_VERSION","_validVersions","_version","_reducerSchemas","_datasetSchema","_datasetLastSaved","_savedDataset","state","getDatasetToSave","config","getConfigToSave","info","app","created_at","Date","toString","getMapInfo","mapInfo","savedDatasets","savedConfig","arguments","length","Array","isArray","load","parseSavedData","parseSavedConfig","dataChangedSinceLastSave","hasDataChanged","Object","values","map","ds","data","save","keys","reduce","accu","key","validVersion","validateVersion","push","Console","error","KeplerGLSchemaManager"],"mappings":";;;;;;;;;;;;;;;AAoBA;;AAEA;;AACA;;AACA;;AACA;;AAEA;;AACA;;;;;;AAEO,IAAMA,aAAa,GAAG;AAC3BC,EAAAA,QAAQ,EAAEC,0BADiB;AAE3BC,EAAAA,QAAQ,EAAEC,0BAFiB;AAG3BC,EAAAA,QAAQ,EAAEC;AAHiB,CAAtB;AAMP;;;;IACaC,c;AACX,4BAKQ;AAAA,mFAAJ,EAAI;AAAA,6BAJNC,QAIM;AAAA,QAJNA,QAIM,8BAJKR,aAIL;AAAA,6BAHNS,QAGM;AAAA,QAHNA,QAGM,8BAHKC,yBAGL;AAAA,kCAFNC,aAEM;AAAA,QAFNA,aAEM,mCAFUC,kBAEV;AAAA,4BADNC,OACM;AAAA,QADNA,OACM,6BADIC,yBACJ;;AAAA;AACN,SAAKC,cAAL,GAAsBJ,aAAtB;AACA,SAAKK,QAAL,GAAgBH,OAAhB;AACA,SAAKI,eAAL,GAAuBT,QAAvB;AACA,SAAKU,cAAL,GAAsBT,QAAtB;AAEA,SAAKU,iBAAL,GAAyB,IAAzB;AACA,SAAKC,aAAL,GAAqB,IAArB;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;WACE,cAAKC,KAAL,EAAY;AACV,aAAO;AACLZ,QAAAA,QAAQ,EAAE,KAAKa,gBAAL,CAAsBD,KAAtB,CADL;AAELE,QAAAA,MAAM,EAAE,KAAKC,eAAL,CAAqBH,KAArB,CAFH;AAGLI,QAAAA,IAAI;AACFC,UAAAA,GAAG,EAAE,WADH;AAEFC,UAAAA,UAAU,EAAE,IAAIC,IAAJ,GAAWC,QAAX;AAFV,WAGC,KAAKC,UAAL,CAAgBT,KAAhB,CAHD;AAHC,OAAP;AASD;;;WAED,oBAAWA,KAAX,EAAkB;AAChB,aAAOA,KAAK,CAACpB,QAAN,CAAe8B,OAAtB;AACD;AACD;AACF;AACA;AACA;AACA;;;;WACE,cAAKC,aAAL,EAAoBC,WAApB,EAAiC;AAC/B;AACA,UACEC,SAAS,CAACC,MAAV,KAAqB,CAArB,IACA,0BAAcD,SAAS,CAAC,CAAD,CAAvB,CADA,KAECE,KAAK,CAACC,OAAN,CAAcH,SAAS,CAAC,CAAD,CAAT,CAAazB,QAA3B,KAAwC,0BAAcyB,SAAS,CAAC,CAAD,CAAT,CAAaX,MAA3B,CAFzC,CADF,EAIE;AACA,eAAO,KAAKe,IAAL,CAAUJ,SAAS,CAAC,CAAD,CAAT,CAAazB,QAAvB,EAAiCyB,SAAS,CAAC,CAAD,CAAT,CAAaX,MAA9C,CAAP;AACD;;AAED,6CACMa,KAAK,CAACC,OAAN,CAAcL,aAAd,IAA+B;AAACvB,QAAAA,QAAQ,EAAE,KAAK8B,cAAL,CAAoBP,aAApB;AAAX,OAA/B,GAAgF,EADtF,GAEMC,WAAW,GAAG;AAACV,QAAAA,MAAM,EAAE,KAAKiB,gBAAL,CAAsBP,WAAtB;AAAT,OAAH,GAAkD,EAFnE;AAID;AAED;AACF;AACA;AACA;AACA;;;;WACE,0BAAiBZ,KAAjB,EAAwB;AAAA;;AACtB,UAAMoB,wBAAwB,GAAG,KAAKC,cAAL,CAAoBrB,KAApB,CAAjC;;AACA,UAAI,CAACoB,wBAAL,EAA+B;AAC7B,eAAO,KAAKrB,aAAZ;AACD;;AAJqB,UAMfnB,QANe,GAMHoB,KANG,CAMfpB,QANe;AAQtB,UAAMQ,QAAQ,GAAGkC,MAAM,CAACC,MAAP,CAAc3C,QAAQ,CAACQ,QAAvB,EAAiCoC,GAAjC,CAAqC,UAAAC,EAAE;AAAA,eAAK;AAC3DjC,UAAAA,OAAO,EAAE,KAAI,CAACG,QAD6C;AAE3D+B,UAAAA,IAAI,EAAE,KAAI,CAAC7B,cAAL,CAAoB,KAAI,CAACF,QAAzB,EAAmCgC,IAAnC,CAAwCF,EAAxC;AAFqD,SAAL;AAAA,OAAvC,CAAjB,CARsB,CAatB;;AACA,WAAK3B,iBAAL,GAAyBlB,QAAQ,CAACQ,QAAlC;AACA,WAAKW,aAAL,GAAqBX,QAArB;AAEA,aAAOA,QAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,yBAAgBY,KAAhB,EAAuB;AAAA;;AACrB,UAAME,MAAM,GAAGoB,MAAM,CAACM,IAAP,CAAY,KAAKhC,eAAjB,EAAkCiC,MAAlC,CACb,UAACC,IAAD,EAAOC,GAAP;AAAA,+CACKD,IADL,GAEM9B,KAAK,CAAC+B,GAAD,CAAL,GAAa,MAAI,CAACnC,eAAL,CAAqBmC,GAArB,EAA0B,MAAI,CAACpC,QAA/B,EAAyCgC,IAAzC,CAA8C3B,KAAK,CAAC+B,GAAD,CAAnD,CAAb,GAAyE,EAF/E;AAAA,OADa,EAKb,EALa,CAAf;AAQA,aAAO;AACLvC,QAAAA,OAAO,EAAE,KAAKG,QADT;AAELO,QAAAA,MAAM,EAANA;AAFK,OAAP;AAID;AAED;AACF;AACA;AACA;AACA;;;;WACE,wBAAed,QAAf,EAAyB;AAAA;;AACvB,aAAOA,QAAQ,CAACyC,MAAT,CAAgB,UAACC,IAAD,EAAOL,EAAP,EAAc;AACnC,YAAMO,YAAY,GAAG,MAAI,CAACC,eAAL,CAAqBR,EAAE,CAACjC,OAAxB,CAArB;;AACA,YAAI,CAACwC,YAAL,EAAmB;AACjB,iBAAOF,IAAP;AACD;;AACDA,QAAAA,IAAI,CAACI,IAAL,CAAU,MAAI,CAACrC,cAAL,CAAoBmC,YAApB,EAAkCf,IAAlC,CAAuCQ,EAAE,CAACC,IAA1C,CAAV;AACA,eAAOI,IAAP;AACD,OAPM,EAOJ,EAPI,CAAP;AAQD;AAED;AACF;AACA;;;;WACE,iCAAgD;AAAA;;AAAA,UAA9BtC,OAA8B,SAA9BA,OAA8B;AAAA,UAArBU,MAAqB,SAArBA,MAAqB;AAAA,UAAZF,KAAY,uEAAJ,EAAI;AAC9C,UAAMgC,YAAY,GAAG,KAAKC,eAAL,CAAqBzC,OAArB,CAArB;;AACA,UAAI,CAACwC,YAAL,EAAmB;AACjB,eAAO,IAAP;AACD;;AAED,aAAOV,MAAM,CAACM,IAAP,CAAY1B,MAAZ,EAAoB2B,MAApB,CACL,UAACC,IAAD,EAAOC,GAAP;AAAA,+CACKD,IADL,GAEMC,GAAG,IAAI,MAAI,CAACnC,eAAZ,GACA,MAAI,CAACA,eAAL,CAAqBmC,GAArB,EAA0BC,YAA1B,EAAwCf,IAAxC,CAA6Cf,MAAM,CAAC6B,GAAD,CAAnD,CADA,GAEA,EAJN;AAAA,OADK,EAOL,EAPK,CAAP;AASD;AAED;AACF;AACA;AACA;AACA;;;;WACE,yBAAgBvC,OAAhB,EAAyB;AACvB,UAAI,CAACA,OAAL,EAAc;AACZ2C,wBAAQC,KAAR,CAAc,2DAAd;;AACA,eAAO,IAAP;AACD;;AAED,UAAI,CAAC,KAAK1C,cAAL,CAAoBF,OAApB,CAAL,EAAmC;AACjC2C,wBAAQC,KAAR,WAAiB5C,OAAjB;;AACA,eAAO,IAAP;AACD;;AAED,aAAOA,OAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,wBAAeQ,KAAf,EAAsB;AACpB,aAAO,KAAKF,iBAAL,KAA2BE,KAAK,CAACpB,QAAN,CAAeQ,QAAjD;AACD;;;;;;AAGH,IAAMiD,qBAAqB,GAAG,IAAInD,cAAJ,EAA9B;eAEemD,qB","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 {console as Console} from 'global/window';\n\nimport visStateSchema from './vis-state-schema';\nimport datasetSchema from './dataset-schema';\nimport mapStyleSchema from './map-style-schema';\nimport mapStateSchema from './map-state-schema';\n\nimport {CURRENT_VERSION, VERSIONS} from './versions';\nimport {isPlainObject} from 'utils/utils';\n\nexport const reducerSchema = {\n  visState: visStateSchema,\n  mapState: mapStateSchema,\n  mapStyle: mapStyleSchema\n};\n\n/** @type {typeof import('./schema-manager').KeplerGLSchema} */\nexport class KeplerGLSchema {\n  constructor({\n    reducers = reducerSchema,\n    datasets = datasetSchema,\n    validVersions = VERSIONS,\n    version = CURRENT_VERSION\n  } = {}) {\n    this._validVersions = validVersions;\n    this._version = version;\n    this._reducerSchemas = reducers;\n    this._datasetSchema = datasets;\n\n    this._datasetLastSaved = null;\n    this._savedDataset = null;\n  }\n\n  /**\n   * stateToSave = {\n   *   datasets: [\n   *     {\n   *       version: 'v0',\n   *       data: {id, label, color, allData, fields}\n   *     },\n   *     {\n   *       version: 'v0',\n   *       data: {id, label, color, allData, fields}\n   *     }\n   *   ],\n   *   config: {\n   *     version: 'v0',\n   *     config: {}\n   *   },\n   *   info: {\n   *     app: 'kepler.gl',\n   *     create_at: 'Mon May 28 2018 21:04:46 GMT-0700 (PDT)'\n   *   }\n   * }\n   *\n   * Get config and data of current map to save\n   * @param state\n   * @returns app state to save\n   */\n  save(state) {\n    return {\n      datasets: this.getDatasetToSave(state),\n      config: this.getConfigToSave(state),\n      info: {\n        app: 'kepler.gl',\n        created_at: new Date().toString(),\n        ...this.getMapInfo(state)\n      }\n    };\n  }\n\n  getMapInfo(state) {\n    return state.visState.mapInfo;\n  }\n  /**\n   *  Load saved map, argument can be (datasets, config) or ({datasets, config})\n   * @param savedDatasets\n   * @param savedConfig\n   */\n  load(savedDatasets, savedConfig) {\n    // if pass dataset and config in as a single object\n    if (\n      arguments.length === 1 &&\n      isPlainObject(arguments[0]) &&\n      (Array.isArray(arguments[0].datasets) || isPlainObject(arguments[0].config))\n    ) {\n      return this.load(arguments[0].datasets, arguments[0].config);\n    }\n\n    return {\n      ...(Array.isArray(savedDatasets) ? {datasets: this.parseSavedData(savedDatasets)} : {}),\n      ...(savedConfig ? {config: this.parseSavedConfig(savedConfig)} : {})\n    };\n  }\n\n  /**\n   * Get data to save\n   * @param state - app state\n   * @returns - dataset to save\n   */\n  getDatasetToSave(state) {\n    const dataChangedSinceLastSave = this.hasDataChanged(state);\n    if (!dataChangedSinceLastSave) {\n      return this._savedDataset;\n    }\n\n    const {visState} = state;\n\n    const datasets = Object.values(visState.datasets).map(ds => ({\n      version: this._version,\n      data: this._datasetSchema[this._version].save(ds)\n    }));\n\n    // keep a copy of formatted datasets to save\n    this._datasetLastSaved = visState.datasets;\n    this._savedDataset = datasets;\n\n    return datasets;\n  }\n\n  /**\n   * Get App config to save\n   * @param {Object} state - app state\n   * @returns {{version: String, config: Object}} - config to save\n   */\n  getConfigToSave(state) {\n    const config = Object.keys(this._reducerSchemas).reduce(\n      (accu, key) => ({\n        ...accu,\n        ...(state[key] ? this._reducerSchemas[key][this._version].save(state[key]) : {})\n      }),\n      {}\n    );\n\n    return {\n      version: this._version,\n      config\n    };\n  }\n\n  /**\n   * Parse saved data\n   * @param datasets\n   * @returns - dataset to pass to addDataToMap\n   */\n  parseSavedData(datasets) {\n    return datasets.reduce((accu, ds) => {\n      const validVersion = this.validateVersion(ds.version);\n      if (!validVersion) {\n        return accu;\n      }\n      accu.push(this._datasetSchema[validVersion].load(ds.data));\n      return accu;\n    }, []);\n  }\n\n  /**\n   * Parse saved App config\n   */\n  parseSavedConfig({version, config}, state = {}) {\n    const validVersion = this.validateVersion(version);\n    if (!validVersion) {\n      return null;\n    }\n\n    return Object.keys(config).reduce(\n      (accu, key) => ({\n        ...accu,\n        ...(key in this._reducerSchemas\n          ? this._reducerSchemas[key][validVersion].load(config[key])\n          : {})\n      }),\n      {}\n    );\n  }\n\n  /**\n   * Validate version\n   * @param version\n   * @returns validVersion\n   */\n  validateVersion(version) {\n    if (!version) {\n      Console.error('There is no version number associated with this saved map');\n      return null;\n    }\n\n    if (!this._validVersions[version]) {\n      Console.error(`${version} is not a valid version`);\n      return null;\n    }\n\n    return version;\n  }\n\n  /**\n   * Check if data has changed since last save\n   * @param state\n   * @returns - whether data has changed or not\n   */\n  hasDataChanged(state) {\n    return this._datasetLastSaved !== state.visState.datasets;\n  }\n}\n\nconst KeplerGLSchemaManager = new KeplerGLSchema();\n\nexport default KeplerGLSchemaManager;\n"]}

package/dist/schemas/schema-utils.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.savePropertiesOrApplySchema = savePropertiesOrApplySchema;
+exports.loadPropertiesOrApplySchema = loadPropertiesOrApplySchema;
+exports.getPropertyValueFromSchema = getPropertyValueFromSchema;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+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; }
+
+// 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.
+
+/**
+ * Recursively save / load value for state based on property keys,
+ * if property[key] is another schema
+ * Use is to get value to save
+ * @param {Object} state - state to save
+ * @param {Object} properties - properties schema
+ * @returns {Object} - saved state
+ */
+function savePropertiesOrApplySchema(state, properties) {
+  return getPropertyValueFromSchema('save', state, properties);
+}
+
+function loadPropertiesOrApplySchema(state, properties) {
+  return getPropertyValueFromSchema('load', state, properties);
+}
+
+function getPropertyValueFromSchema(operation, state, properties) {
+  return Object.keys(properties).reduce(function (accu, key) {
+    return _objectSpread(_objectSpread({}, accu), key in state ? properties[key] ? // if it's another schema
+    properties[key][operation] ? // call save or load
+    properties[key][operation](state[key], state) : // if it's another property object
+    getPropertyValueFromSchema(operation, state[key], properties[key]) : (0, _defineProperty2["default"])({}, key, state[key]) : {});
+  }, {});
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/schemas/schema.js

@@ -0,0 +1,114 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _window = require("global/window");
+
+var _versions = require("./versions");
+
+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; }
+
+/** @type {typeof import('./schema').Schema} */
+var Schema = /*#__PURE__*/function () {
+  function Schema() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref$version = _ref.version,
+        version = _ref$version === void 0 ? _versions.CURRENT_VERSION : _ref$version,
+        _ref$key = _ref.key,
+        key = _ref$key === void 0 ? '' : _ref$key,
+        _ref$properties = _ref.properties,
+        properties = _ref$properties === void 0 ? null : _ref$properties;
+
+    (0, _classCallCheck2["default"])(this, Schema);
+    this.version = version;
+    this.properties = properties;
+    this.key = key;
+  }
+
+  (0, _createClass2["default"])(Schema, [{
+    key: "loadPropertiesOrApplySchema",
+    value: function loadPropertiesOrApplySchema(node) {
+      var parents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      var accumulator = arguments.length > 2 ? arguments[2] : undefined;
+      return this._getPropertyValueFromSchema('load', node, parents, accumulator);
+    }
+  }, {
+    key: "savePropertiesOrApplySchema",
+    value: function savePropertiesOrApplySchema(node) {
+      var parents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      var accumulator = arguments.length > 2 ? arguments[2] : undefined;
+      return this._getPropertyValueFromSchema('save', node, parents, accumulator);
+    }
+  }, {
+    key: "_getPropertyValueFromSchema",
+    value: function _getPropertyValueFromSchema(operation, node) {
+      var _this = this;
+
+      var parents = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      var accumulator = arguments.length > 3 ? arguments[3] : undefined;
+      var internal = "_".concat(operation);
+      return (0, _defineProperty2["default"])({}, this.key, this.properties ? Object.keys(this.properties).reduce(function (accu, key) {
+        return _objectSpread(_objectSpread({}, accu), key in node ? _this.properties[key] ? // if it's another schema
+        _this.properties[key][operation] ? // call save or load
+        _this.properties[key][internal](node[key], [].concat((0, _toConsumableArray2["default"])(parents), [node]), accu) : {} : (0, _defineProperty2["default"])({}, key, node[key]) : {});
+      }, {}) : node);
+    }
+  }, {
+    key: "_isCurrentVersion",
+    value: function _isCurrentVersion() {
+      return this.version === _versions.CURRENT_VERSION;
+    }
+  }, {
+    key: "outdatedVersionError",
+    value: function outdatedVersionError() {
+      if (!this._isCurrentVersion()) {
+        _window.console.error("".concat(this.key, " ").concat(this.version, " is outdated. save should not be called anymore"));
+      }
+    }
+  }, {
+    key: "_save",
+    value: function _save() {
+      // make sure nothing is saved to an outdated version
+      this.outdatedVersionError();
+      return this.save.apply(this, arguments);
+    }
+  }, {
+    key: "save",
+    value: function save(node) {
+      var parents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      var accumulator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      return this.savePropertiesOrApplySchema(node, parents, accumulator);
+    }
+  }, {
+    key: "_load",
+    value: function _load() {
+      return this.load.apply(this, arguments);
+    }
+  }, {
+    key: "load",
+    value: function load(node) {
+      var parents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      var accumulator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      return this.loadPropertiesOrApplySchema(node, parents, accumulator);
+    }
+  }]);
+  return Schema;
+}();
+
+exports["default"] = Schema;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/schemas/versions.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CURRENT_VERSION = exports.VERSIONS = void 0;
+
+var _keymirror = _interopRequireDefault(require("keymirror"));
+
+// 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.
+var VERSIONS = (0, _keymirror["default"])({
+  v0: null,
+  v1: null
+});
+exports.VERSIONS = VERSIONS;
+var CURRENT_VERSION = VERSIONS.v1;
+exports.CURRENT_VERSION = CURRENT_VERSION;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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