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

package/dist/layers/trip-layer/trip-utils.js

@@ -0,0 +1,204 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.coordHasLength4 = coordHasLength4;
+exports.containValidTime = containValidTime;
+exports.isTripGeoJsonField = isTripGeoJsonField;
+exports.parseTripGeoJsonTimestamp = parseTripGeoJsonTimestamp;
+exports.getAnimationDomainFromTimestamps = getAnimationDomainFromTimestamps;
+
+var _typeAnalyzer = require("type-analyzer");
+
+var _dataUtils = require("../../utils/data-utils");
+
+var _dataContainerUtils = require("../../utils/table-utils/data-container-utils");
+
+var _geojsonUtils = require("../geojson-layer/geojson-utils");
+
+// 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.
+
+/**
+ * Parse geojson from string
+ * @param {array} samples feature object values
+ * @returns {boolean} whether the geometry coordinates has length of 4
+ */
+function coordHasLength4(samples) {
+  var hasLength4 = true;
+
+  for (var i = 0; i < samples.length; i += 1) {
+    hasLength4 = !samples[i].geometry.coordinates.find(function (c) {
+      return c.length < 4;
+    });
+
+    if (!hasLength4) {
+      break;
+    }
+  }
+
+  return hasLength4;
+}
+/**
+ * Check whether geojson linestring's 4th coordinate is 1) not timestamp 2) unix time stamp 3) real date time
+ * @param {array} timestamps array to be tested if its elements are timestamp
+ * @returns {object | boolean} the type of timestamp: unix/datetime/invalid(not timestamp)
+ */
+
+
+function containValidTime(timestamps) {
+  var formattedTimeStamps = timestamps.map(function (ts) {
+    return {
+      ts: ts
+    };
+  });
+  var ignoredDataTypes = Object.keys(_typeAnalyzer.DATA_TYPES).filter(function (type) {
+    return ![_typeAnalyzer.DATA_TYPES.TIME, _typeAnalyzer.DATA_TYPES.DATETIME].includes(type);
+  }); // ignore all types but TIME to improve performance
+
+  var analyzedType = _typeAnalyzer.Analyzer.computeColMeta(formattedTimeStamps, [], {
+    ignoredDataTypes: ignoredDataTypes
+  })[0];
+
+  if (!analyzedType || analyzedType.category !== 'TIME') {
+    return false;
+  }
+
+  return analyzedType;
+}
+/**
+ * Check if geojson features are trip layer animatable by meeting 3 conditions
+ * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} dataContainer geojson feature objects container
+ * @param {object} field array of geojson feature objects
+ * @returns {boolean} whether it is trip layer animatable
+ */
+
+
+function isTripGeoJsonField(dataContainer, field) {
+  if (dataContainer.numRows() < 1) {
+    return false;
+  }
+
+  var maxCount = 10000;
+  var sampleRawFeatures = dataContainer.numRows() > maxCount ? (0, _dataContainerUtils.getSampleData)(dataContainer, maxCount) : dataContainer;
+  var features = sampleRawFeatures.mapIndex(field.valueAccessor).map(_geojsonUtils.parseGeoJsonRawFeature).filter(function (f) {
+    return f;
+  });
+  var featureTypes = (0, _geojsonUtils.getGeojsonFeatureTypes)(features); // condition 1: contain line string
+
+  if (!featureTypes.line) {
+    return false;
+  } // condition 2:sample line strings contain 4 coordinates
+
+
+  if (!coordHasLength4(features)) {
+    return false;
+  } // condition 3:the 4th coordinate of the first feature line strings is valid time
+
+
+  var tsHolder = features[0].geometry.coordinates.map(function (coord) {
+    return coord[3];
+  });
+  return Boolean(containValidTime(tsHolder));
+}
+/**
+ * Get unix timestamp from animatable geojson for deck.gl trip layer
+ * @param {Array<Object>} dataToFeature array of geojson feature objects, can be null
+ * @returns {{dataToTimeStamp: Array[Number], animationDomain: null | Array<Number>}} {dataToTimeStamp: [], animationDomain: null}
+ */
+
+
+function parseTripGeoJsonTimestamp(dataToFeature) {
+  // Analyze type based on coordinates of the 1st lineString
+  // select a sample trip to analyze time format
+  var empty = {
+    dataToTimeStamp: [],
+    animationDomain: null
+  };
+  var sampleTrip = dataToFeature.find(function (f) {
+    return f && f.geometry && f.geometry.coordinates && f.geometry.coordinates.length >= 3;
+  }); // if no valid geometry
+
+  if (!sampleTrip) {
+    return empty;
+  }
+
+  var analyzedType = containValidTime(sampleTrip.geometry.coordinates.map(function (coord) {
+    return coord[3];
+  }));
+
+  if (!analyzedType) {
+    return empty;
+  }
+
+  var format = analyzedType.format;
+
+  var getTimeValue = function getTimeValue(coord) {
+    return coord && (0, _dataUtils.notNullorUndefined)(coord[3]) ? (0, _dataUtils.timeToUnixMilli)(coord[3], format) : null;
+  };
+
+  var dataToTimeStamp = dataToFeature.map(function (f) {
+    return f && f.geometry && Array.isArray(f.geometry.coordinates) ? f.geometry.coordinates.map(getTimeValue) : null;
+  });
+  var animationDomain = getAnimationDomainFromTimestamps(dataToTimeStamp);
+  return {
+    dataToTimeStamp: dataToTimeStamp,
+    animationDomain: animationDomain
+  };
+}
+
+function findMinFromSorted() {
+  var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return list.find(function (d) {
+    return (0, _dataUtils.notNullorUndefined)(d) && Number.isFinite(d);
+  }) || null;
+}
+
+function findMaxFromSorted() {
+  var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var i = list.length - 1;
+
+  while (i > 0) {
+    if ((0, _dataUtils.notNullorUndefined)(list[i]) && Number.isFinite(list[i])) {
+      return list[i];
+    }
+
+    i--;
+  }
+
+  return null;
+}
+
+function getAnimationDomainFromTimestamps() {
+  var dataToTimeStamp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return dataToTimeStamp.reduce(function (accu, tss) {
+    var tsMin = findMinFromSorted(tss);
+    var tsMax = findMaxFromSorted(tss);
+
+    if (Number.isFinite(tsMin) && Number.isFinite(tsMax)) {
+      accu[0] = Math.min(accu[0], tsMin);
+      accu[1] = Math.max(accu[1], tsMax);
+    }
+
+    return accu;
+  }, [Infinity, -Infinity]);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/layers/trip-layer/trip-utils.js"],"names":["coordHasLength4","samples","hasLength4","i","length","geometry","coordinates","find","c","containValidTime","timestamps","formattedTimeStamps","map","ts","ignoredDataTypes","Object","keys","DATA_TYPES","filter","type","TIME","DATETIME","includes","analyzedType","Analyzer","computeColMeta","category","isTripGeoJsonField","dataContainer","field","numRows","maxCount","sampleRawFeatures","features","mapIndex","valueAccessor","parseGeoJsonRawFeature","f","featureTypes","line","tsHolder","coord","Boolean","parseTripGeoJsonTimestamp","dataToFeature","empty","dataToTimeStamp","animationDomain","sampleTrip","format","getTimeValue","Array","isArray","getAnimationDomainFromTimestamps","findMinFromSorted","list","d","Number","isFinite","findMaxFromSorted","reduce","accu","tss","tsMin","tsMax","Math","min","max","Infinity"],"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 {Analyzer, DATA_TYPES} from 'type-analyzer';\n\nimport {timeToUnixMilli, notNullorUndefined} from 'utils/data-utils';\nimport {getSampleData} from 'utils/table-utils/data-container-utils';\n\nimport {parseGeoJsonRawFeature, getGeojsonFeatureTypes} from 'layers/geojson-layer/geojson-utils';\n\n/**\n * Parse geojson from string\n * @param {array} samples feature object values\n * @returns {boolean} whether the geometry coordinates has length of 4\n */\nexport function coordHasLength4(samples) {\n  let hasLength4 = true;\n  for (let i = 0; i < samples.length; i += 1) {\n    hasLength4 = !samples[i].geometry.coordinates.find(c => c.length < 4);\n    if (!hasLength4) {\n      break;\n    }\n  }\n  return hasLength4;\n}\n\n/**\n * Check whether geojson linestring's 4th coordinate is 1) not timestamp 2) unix time stamp 3) real date time\n * @param {array} timestamps array to be tested if its elements are timestamp\n * @returns {object | boolean} the type of timestamp: unix/datetime/invalid(not timestamp)\n */\n\nexport function containValidTime(timestamps) {\n  const formattedTimeStamps = timestamps.map(ts => ({ts}));\n  const ignoredDataTypes = Object.keys(DATA_TYPES).filter(\n    type => ![DATA_TYPES.TIME, DATA_TYPES.DATETIME].includes(type)\n  );\n\n  // ignore all types but TIME to improve performance\n  const analyzedType = Analyzer.computeColMeta(formattedTimeStamps, [], {ignoredDataTypes})[0];\n\n  if (!analyzedType || analyzedType.category !== 'TIME') {\n    return false;\n  }\n  return analyzedType;\n}\n\n/**\n * Check if geojson features are trip layer animatable by meeting 3 conditions\n * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} dataContainer geojson feature objects container\n * @param {object} field array of geojson feature objects\n * @returns {boolean} whether it is trip layer animatable\n */\nexport function isTripGeoJsonField(dataContainer, field) {\n  if (dataContainer.numRows() < 1) {\n    return false;\n  }\n\n  const maxCount = 10000;\n  const sampleRawFeatures =\n    dataContainer.numRows() > maxCount ? getSampleData(dataContainer, maxCount) : dataContainer;\n\n  const features = sampleRawFeatures\n    .mapIndex(field.valueAccessor)\n    .map(parseGeoJsonRawFeature)\n    .filter(f => f);\n  const featureTypes = getGeojsonFeatureTypes(features);\n\n  // condition 1: contain line string\n  if (!featureTypes.line) {\n    return false;\n  }\n\n  // condition 2:sample line strings contain 4 coordinates\n  if (!coordHasLength4(features)) {\n    return false;\n  }\n\n  // condition 3:the 4th coordinate of the first feature line strings is valid time\n  const tsHolder = features[0].geometry.coordinates.map(coord => coord[3]);\n\n  return Boolean(containValidTime(tsHolder));\n}\n\n/**\n * Get unix timestamp from animatable geojson for deck.gl trip layer\n * @param {Array<Object>} dataToFeature array of geojson feature objects, can be null\n * @returns {{dataToTimeStamp: Array[Number], animationDomain: null | Array<Number>}} {dataToTimeStamp: [], animationDomain: null}\n */\nexport function parseTripGeoJsonTimestamp(dataToFeature) {\n  // Analyze type based on coordinates of the 1st lineString\n  // select a sample trip to analyze time format\n  const empty = {dataToTimeStamp: [], animationDomain: null};\n  const sampleTrip = dataToFeature.find(\n    f => f && f.geometry && f.geometry.coordinates && f.geometry.coordinates.length >= 3\n  );\n\n  // if no valid geometry\n  if (!sampleTrip) {\n    return empty;\n  }\n\n  const analyzedType = containValidTime(sampleTrip.geometry.coordinates.map(coord => coord[3]));\n\n  if (!analyzedType) {\n    return empty;\n  }\n\n  const {format} = analyzedType;\n  const getTimeValue = coord =>\n    coord && notNullorUndefined(coord[3]) ? timeToUnixMilli(coord[3], format) : null;\n\n  const dataToTimeStamp = dataToFeature.map(f =>\n    f && f.geometry && Array.isArray(f.geometry.coordinates)\n      ? f.geometry.coordinates.map(getTimeValue)\n      : null\n  );\n\n  const animationDomain = getAnimationDomainFromTimestamps(dataToTimeStamp);\n\n  return {dataToTimeStamp, animationDomain};\n}\n\nfunction findMinFromSorted(list = []) {\n  return list.find(d => notNullorUndefined(d) && Number.isFinite(d)) || null;\n}\n\nfunction findMaxFromSorted(list = []) {\n  let i = list.length - 1;\n  while (i > 0) {\n    if (notNullorUndefined(list[i]) && Number.isFinite(list[i])) {\n      return list[i];\n    }\n    i--;\n  }\n  return null;\n}\n\nexport function getAnimationDomainFromTimestamps(dataToTimeStamp = []) {\n  return dataToTimeStamp.reduce(\n    (accu, tss) => {\n      const tsMin = findMinFromSorted(tss);\n      const tsMax = findMaxFromSorted(tss);\n      if (Number.isFinite(tsMin) && Number.isFinite(tsMax)) {\n        accu[0] = Math.min(accu[0], tsMin);\n        accu[1] = Math.max(accu[1], tsMax);\n      }\n      return accu;\n    },\n    [Infinity, -Infinity]\n  );\n}\n"]}

package/dist/layers/types.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LAYER_TYPES = 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 LAYER_TYPES = (0, _keymirror["default"])({
+  point: null,
+  arc: null,
+  line: null,
+  grid: null,
+  hexagon: null,
+  geojson: null,
+  cluster: null,
+  icon: null,
+  heatmap: null,
+  hexagonId: null,
+  '3D': null,
+  trip: null,
+  s2: null
+});
+exports.LAYER_TYPES = LAYER_TYPES;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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