kepler.gl
Version:
kepler.gl is a webgl based application to visualize large scale location data in the browser
524 lines (509 loc) • 65.9 kB
JavaScript
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.appendColumnsToDataset = appendColumnsToDataset;
exports.getDatasetContext = getDatasetContext;
exports.getGeometriesFromDataset = getGeometriesFromDataset;
exports.getValuesFromDataset = getValuesFromDataset;
exports.getValuesFromVectorTileLayer = getValuesFromVectorTileLayer;
exports.highlightRows = highlightRows;
exports.highlightRowsByColumnValues = highlightRowsByColumnValues;
exports.interpolateColor = interpolateColor;
exports.saveAsDataset = saveAsDataset;
var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _colorInterpolate = _interopRequireDefault(require("color-interpolate"));
var _constants = require("@kepler.gl/constants");
var _processors = require("@kepler.gl/processors");
function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } // SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project
/**
* Interpolate the colors from the original colors with the given number of colors
* @param originalColors The original colors
* @param numberOfColors The number of colors
* @returns The interpolated colors
*/
function interpolateColor(originalColors, numberOfColors) {
if (originalColors.length === numberOfColors) {
return originalColors;
}
var interp = (0, _colorInterpolate["default"])(originalColors);
var colors = Array.from({
length: numberOfColors
}, function (_, j) {
return interp(j / (numberOfColors - 1));
});
// convert colors from 'rgb(255, 255, 255)' to '#ffffff'
var hexColors = colors.map(function (color) {
var rgb = color.match(/\d+/g);
return "#".concat(rgb === null || rgb === void 0 ? void 0 : rgb.map(function (c) {
return parseInt(c).toString(16).padStart(2, '0');
}).join(''));
});
return hexColors;
}
/**
* Get the values from a dataset for a variable
* @param datasets
* @param datasetName
* @param variableName
* @returns {number[]}
*/
function getValuesFromDataset(datasets, layers, datasetName, variableName) {
// find which dataset has the variableName
var datasetId = Object.keys(datasets).find(function (dataId) {
return datasets[dataId].label === datasetName;
});
if (!datasetId) {
throw new Error("Dataset ".concat(datasetName, " not found"));
}
var dataset = datasets[datasetId];
if (dataset) {
// check if field exists
var field = dataset.fields.find(function (field) {
return field.name === variableName;
});
if (!field) {
throw new Error("Field ".concat(variableName, " not found in dataset ").concat(datasetName));
}
// for vector-tile, getting values from layerData
if (dataset.type === 'vector-tile') {
// get field from dataset
var _field = dataset.fields.find(function (field) {
return field.name === variableName;
});
if (_field) {
return getValuesFromVectorTileLayer(datasetId, layers, _field);
}
}
return Array.from({
length: dataset.length
}, function (_, i) {
return dataset.getValue(variableName, i);
});
}
return [];
}
function isVectorTileLayer(layer) {
return layer.type === _constants.LAYER_TYPES.vectorTile;
}
function getValuesFromVectorTileLayer(datasetId, layers, field) {
// get the index of the layer
var layerIndex = layers.findIndex(function (layer) {
return layer.config.dataId === datasetId;
});
if (layerIndex === -1) return [];
var layer = layers[layerIndex];
if (!isVectorTileLayer(layer)) return [];
var accessor = layer.accessRowValue(field);
var values = [];
// @ts-expect-error TODO fix this later in the vector-tile layer
var _iterator = _createForOfIteratorHelper(layer.tileDataset.tileSet),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var row = _step.value;
var value = accessor(field, row);
if (value === null) break;
values.push(value);
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
return values;
}
/**
* Highlight the rows in a dataset
* @param datasets The kepler.gl datasets
* @param layers The kepler.gl layers
* @param datasetName The name of the dataset
* @param selectedRowIndices The indices of the rows to highlight
* @param layerSetIsValid The function to set the layer validity
*/
function highlightRows(datasets, layers, datasetName, selectedRowIndices, layerSetIsValid) {
// update the filteredIndex in the dataset
var datasetId = Object.keys(datasets).find(function (dataId) {
return datasets[dataId].label === datasetName;
});
if (!datasetId) return;
var dataset = datasets[datasetId];
if (dataset) {
dataset.filteredIndex = selectedRowIndices.length === 0 ? dataset.allIndexes : selectedRowIndices;
// get all layers that use this dataset
var selectLayers = layers.filter(function (layer) {
return layer.config.dataId === dataset.id;
});
selectLayers.forEach(function (layer) {
layer.formatLayerData(datasets);
// trigger a re-render using layerSetIsValid() to update the top layer
layerSetIsValid(layer, true);
});
}
}
/**
* Get the dataset context, which is used to provide the dataset information to the AI assistant
* @param datasets The kepler.gl datasets
* @param layers The kepler.gl layers
* @returns The dataset context
*/
function getDatasetContext(datasets, layers) {
if (!datasets || !layers) return '';
var context = 'Please remember the following datasets and layers for answering the user question:';
var dataMeta = Object.values(datasets).map(function (dataset) {
return {
datasetName: dataset.label,
datasetId: dataset.id,
fields: dataset.fields.map(function (field) {
return (0, _defineProperty2["default"])({}, field.name, field.type);
}),
layers: layers.filter(function (layer) {
return layer.config.dataId === dataset.id;
}).map(function (layer) {
return {
id: layer.id,
label: layer.config.label,
type: layer.type,
geometryMode: layer.config.columnMode,
// get the valid geometry columns as string
geometryColumns: Object.fromEntries(Object.entries(layer.config.columns).filter(function (_ref2) {
var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
value = _ref3[1];
return value !== null;
}).map(function (_ref4) {
var _ref5 = (0, _slicedToArray2["default"])(_ref4, 2),
key = _ref5[0],
value = _ref5[1];
return [key, (0, _typeof2["default"])(value) === 'object' && value !== null ? Object.fromEntries(Object.entries(value).filter(function (_ref6) {
var _ref7 = (0, _slicedToArray2["default"])(_ref6, 2),
v = _ref7[1];
return v !== null;
})) : value];
}))
};
})
};
});
return "".concat(context, "\n").concat(JSON.stringify(dataMeta));
}
/**
* Get the geometries from a dataset
* @param datasets The kepler.gl datasets
* @param layers The kepler.gl layers
* @param layerData The layer data
* @param datasetName The name of the dataset
* @returns The geometries
*/
function getGeometriesFromDataset(datasets, layers, layerData, datasetName) {
var datasetId = Object.keys(datasets).find(function (dataId) {
return datasets[dataId].label === datasetName;
});
if (!datasetId) {
return [];
}
var dataset = datasets[datasetId];
// if layer is vector-tile, get the geometries from the layer
if (dataset.type === 'vector-tile') {
// find the vector-tile layer
var selected = layers.filter(function (layer) {
return layer.config.dataId === dataset.id;
});
var layer = selected.find(function (layer) {
return layer.type === _constants.LAYER_TYPES.vectorTile;
});
if (!layer) return [];
var geometries = [];
// @ts-expect-error TODO fix this later in the vector-tile layer
var _iterator2 = _createForOfIteratorHelper(layer.tileDataset.tileSet),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var row = _step2.value;
geometries.push(row);
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
return geometries;
}
// for non-vector-tile dataset, get the geometries from the possible layer
var selectedLayers = layers.filter(function (layer) {
return layer.config.dataId === dataset.id;
});
if (selectedLayers.length === 0) return [];
// find geojson layer, then point layer, then other layers
var geojsonLayer = selectedLayers.find(function (layer) {
return layer.type === _constants.LAYER_TYPES.geojson;
});
var pointLayer = selectedLayers.find(function (layer) {
return layer.type === _constants.LAYER_TYPES.point;
});
var otherLayers = selectedLayers.filter(function (layer) {
return layer.type !== _constants.LAYER_TYPES.geojson && layer.type !== _constants.LAYER_TYPES.point;
});
var validLayer = geojsonLayer || pointLayer || otherLayers[0];
if (validLayer) {
var layerIndex = layers.findIndex(function (layer) {
return layer.id === validLayer.id;
});
var _geometries = layerData[layerIndex];
return _geometries.data;
}
return [];
}
/**
* Save the data as a new dataset by joining it with the left dataset
* @param datasets The kepler.gl datasets
* @param datasetName The name of the left dataset
* @param data The data to save
* @param addDataToMap The function to add the data to the map
*/
function saveAsDataset(datasets, layers, datasetName, newDatasetName, data) {
// find datasetId from datasets
var datasetId = Object.keys(datasets).find(function (dataId) {
return datasets[dataId].label === datasetName;
});
if (!datasetId) return;
// check if newDatasetName already exists
if (Object.keys(datasets).includes(newDatasetName)) return;
// Save the data as a new dataset by joining it with the left dataset
var leftDataset = datasets[datasetId];
var numRows = leftDataset.length;
var geometries;
if (leftDataset.type === 'vector-tile') {
// we need to get geometries from the vector-tile layer
geometries = getFeaturesFromVectorTile(leftDataset, layers) || [];
numRows = geometries.length;
}
var fields = [].concat((0, _toConsumableArray2["default"])(Object.keys(data).map(function (fieldName, index) {
return {
name: fieldName,
id: "".concat(fieldName, "_").concat(index),
displayName: fieldName,
type: determineFieldType(data[fieldName][0])
};
})), (0, _toConsumableArray2["default"])(leftDataset.fields.map(function (field, index) {
return {
name: field.name,
id: field.id || "".concat(field.name, "_").concat(index),
displayName: field.displayName,
type: field.type
};
})), (0, _toConsumableArray2["default"])(leftDataset.type === 'vector-tile' ? [{
name: '_geojson',
id: '_geojson',
displayName: '_geojson',
type: 'geojson'
}] : []));
// Pre-calculate data values array
var dataValues = Object.values(data);
var rows = Array(numRows).fill(null).map(function (_, rowIdx) {
return [].concat((0, _toConsumableArray2["default"])(dataValues.map(function (col) {
return col[rowIdx];
})), (0, _toConsumableArray2["default"])(leftDataset.fields.map(function (field) {
var _geometries$rowIdx$pr;
return leftDataset.type === 'vector-tile' ? (_geometries$rowIdx$pr = geometries[rowIdx].properties) === null || _geometries$rowIdx$pr === void 0 ? void 0 : _geometries$rowIdx$pr[field.name] : leftDataset.getValue(field.name, rowIdx);
})), (0, _toConsumableArray2["default"])(leftDataset.type === 'vector-tile' ? [geometries[rowIdx]] : []));
});
// create new dataset
var newDataset = {
info: {
id: newDatasetName,
label: newDatasetName
},
data: {
fields: fields,
rows: rows
}
};
return newDataset;
}
/**
* Helper function to determine field type
* @param value The value to determine the field type
* @returns The field type
*/
function determineFieldType(value) {
return typeof value === 'number' ? Number.isInteger(value) ? _constants.ALL_FIELD_TYPES.integer : _constants.ALL_FIELD_TYPES.real : _constants.ALL_FIELD_TYPES.string;
}
function highlightRowsByColumnValues(datasets, layers, datasetName, columnName, selectedValues, layerSetIsValid) {
var datasetId = Object.keys(datasets).find(function (dataId) {
return datasets[dataId].label === datasetName;
});
if (!datasetId) return;
var dataset = datasets[datasetId];
if (dataset) {
// get the values of the column
var values = Array.from({
length: dataset.length
}, function (_, i) {
return dataset.getValue(columnName, i);
});
// create a dict using the values
var valueDict = values.reduce(function (acc, value, index) {
acc[value] = index;
return acc;
}, {});
// need to fix the type error of value here
var selectedIndices = selectedValues.map(function (value) {
return valueDict[value];
});
// highlight the rows
highlightRows(datasets, layers, datasetName, selectedIndices, layerSetIsValid);
}
}
function getFeaturesFromVectorTile(leftDataset, layers) {
var layerIndex = layers.findIndex(function (layer) {
return layer.config.dataId === leftDataset.id;
});
if (layerIndex === -1) return;
var layer = layers[layerIndex];
if (!isVectorTileLayer(layer)) return;
var features = [];
// @ts-expect-error TODO fix this later in the vector-tile layer
var _iterator3 = _createForOfIteratorHelper(layer.tileDataset.tileSet),
_step3;
try {
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
var row = _step3.value;
features.push(row);
}
} catch (err) {
_iterator3.e(err);
} finally {
_iterator3.f();
}
return features;
}
function appendColumnsToDataset(_x, _x2, _x3, _x4, _x5) {
return _appendColumnsToDataset.apply(this, arguments);
}
function _appendColumnsToDataset() {
_appendColumnsToDataset = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(datasets, layers, datasetName, result, newDatasetName) {
var datasetId, originalDataset, fields, numRows, rowObjects, columnData, _iterator4, _step4, _field2, i, rowObject, _iterator5, _step5, field, _i, _rowObject, _iterator6, _step6, _field3, value, _loop, _i2, processedData;
return _regenerator["default"].wrap(function _callee$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
// find datasetId from datasets
datasetId = Object.keys(datasets).find(function (dataId) {
return datasets[dataId].label === datasetName;
});
if (datasetId) {
_context2.next = 3;
break;
}
throw new Error("Dataset ".concat(datasetName, " not found"));
case 3:
originalDataset = datasets[datasetId];
fields = originalDataset.fields;
numRows = originalDataset.length || result.length; // create a rowObjects array to store the original dataset values + query result values
rowObjects = [];
if (originalDataset.type === 'vector-tile') {
columnData = {};
_iterator4 = _createForOfIteratorHelper(fields);
try {
for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
_field2 = _step4.value;
// get the values from the vector tile layer
columnData[_field2.name] = getValuesFromVectorTileLayer(datasetId, layers, _field2);
}
// convert columnData to rowObjects
} catch (err) {
_iterator4.e(err);
} finally {
_iterator4.f();
}
for (i = 0; i < numRows; i++) {
rowObject = {};
_iterator5 = _createForOfIteratorHelper(fields);
try {
for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
field = _step5.value;
rowObject[field.name] = columnData[field.name][i];
}
} catch (err) {
_iterator5.e(err);
} finally {
_iterator5.f();
}
rowObjects.push(rowObject);
}
} else {
for (_i = 0; _i < numRows; _i++) {
_rowObject = {};
_iterator6 = _createForOfIteratorHelper(fields);
try {
for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
_field3 = _step6.value;
value = originalDataset.getValue(_field3.name, _i);
_rowObject[_field3.name] = value;
}
} catch (err) {
_iterator6.e(err);
} finally {
_iterator6.f();
}
rowObjects.push(_rowObject);
}
}
// add the query result to the original dataset or update the field values from query result
_loop = /*#__PURE__*/_regenerator["default"].mark(function _loop() {
var queryRow, rowObject;
return _regenerator["default"].wrap(function _loop$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
queryRow = result[_i2];
rowObject = rowObjects[_i2]; // iterate over the keys of queryRow
Object.keys(queryRow).forEach(function (key) {
var value = queryRow[key];
rowObject[key] = value;
});
case 3:
case "end":
return _context.stop();
}
}, _loop);
});
_i2 = 0;
case 10:
if (!(_i2 < numRows)) {
_context2.next = 15;
break;
}
return _context2.delegateYield(_loop(), "t0", 12);
case 12:
_i2++;
_context2.next = 10;
break;
case 15:
_context2.next = 17;
return (0, _processors.processFileData)({
content: {
fileName: newDatasetName,
data: rowObjects
},
fileCache: []
});
case 17:
processedData = _context2.sent;
return _context2.abrupt("return", processedData);
case 19:
case "end":
return _context2.stop();
}
}, _callee);
}));
return _appendColumnsToDataset.apply(this, arguments);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_colorInterpolate","_interopRequireDefault","require","_constants","_processors","_createForOfIteratorHelper","r","e","t","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","_n","F","s","n","done","value","f","TypeError","o","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","interpolateColor","originalColors","numberOfColors","interp","interpolate","colors","_","j","hexColors","map","color","rgb","match","concat","c","parseInt","padStart","join","getValuesFromDataset","datasets","layers","datasetName","variableName","datasetId","Object","keys","find","dataId","label","Error","dataset","field","fields","type","getValuesFromVectorTileLayer","i","getValue","isVectorTileLayer","layer","LAYER_TYPES","vectorTile","layerIndex","findIndex","config","accessor","accessRowValue","values","_iterator","tileDataset","tileSet","_step","row","push","err","highlightRows","selectedRowIndices","layerSetIsValid","filteredIndex","allIndexes","selectLayers","filter","id","forEach","formatLayerData","getDatasetContext","context","dataMeta","_defineProperty2","geometryMode","columnMode","geometryColumns","fromEntries","entries","columns","_ref2","_ref3","_slicedToArray2","_ref4","_ref5","key","_typeof2","_ref6","_ref7","v","JSON","stringify","getGeometriesFromDataset","layerData","selected","geometries","_iterator2","_step2","selectedLayers","geojsonLayer","geojson","pointLayer","point","otherLayers","validLayer","data","saveAsDataset","newDatasetName","includes","leftDataset","numRows","getFeaturesFromVectorTile","_toConsumableArray2","fieldName","index","displayName","determineFieldType","dataValues","rows","fill","rowIdx","col","_geometries$rowIdx$pr","properties","newDataset","info","Number","isInteger","ALL_FIELD_TYPES","integer","real","string","highlightRowsByColumnValues","columnName","selectedValues","valueDict","reduce","acc","selectedIndices","features","_iterator3","_step3","appendColumnsToDataset","_x","_x2","_x3","_x4","_x5","_appendColumnsToDataset","apply","arguments","_asyncToGenerator2","_regenerator","mark","_callee","result","originalDataset","rowObjects","columnData","_iterator4","_step4","_field2","rowObject","_iterator5","_step5","_i","_rowObject","_iterator6","_step6","_field3","_loop","_i2","processedData","wrap","_callee$","_context2","prev","queryRow","_loop$","_context","stop","delegateYield","processFileData","content","fileName","fileCache","sent","abrupt"],"sources":["../../src/tools/utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport interpolate from 'color-interpolate';\nimport {Feature} from 'geojson';\nimport {Layer, VectorTileLayer} from '@kepler.gl/layers';\nimport {Datasets, KeplerTable} from '@kepler.gl/table';\nimport {SpatialJoinGeometries} from '@openassistant/geoda';\nimport {ALL_FIELD_TYPES, LAYER_TYPES} from '@kepler.gl/constants';\nimport {Field, ProtoDataset, ProtoDatasetField} from '@kepler.gl/types';\nimport {processFileData} from '@kepler.gl/processors';\n\n/**\n * Interpolate the colors from the original colors with the given number of colors\n * @param originalColors The original colors\n * @param numberOfColors The number of colors\n * @returns The interpolated colors\n */\nexport function interpolateColor(originalColors: string[], numberOfColors: number) {\n  if (originalColors.length === numberOfColors) {\n    return originalColors;\n  }\n  const interp = interpolate(originalColors);\n  const colors = Array.from({length: numberOfColors}, (_, j) => interp(j / (numberOfColors - 1)));\n  // convert colors from 'rgb(255, 255, 255)' to '#ffffff'\n  const hexColors = colors.map(color => {\n    const rgb = color.match(/\\d+/g);\n    return `#${rgb?.map(c => parseInt(c).toString(16).padStart(2, '0')).join('')}`;\n  });\n  return hexColors;\n}\n\n/**\n * Get the values from a dataset for a variable\n * @param datasets\n * @param datasetName\n * @param variableName\n * @returns {number[]}\n */\nexport function getValuesFromDataset(\n  datasets: Datasets,\n  layers: Layer[],\n  datasetName: string,\n  variableName: string\n): unknown[] {\n  // find which dataset has the variableName\n  const datasetId = Object.keys(datasets).find(dataId => datasets[dataId].label === datasetName);\n  if (!datasetId) {\n    throw new Error(`Dataset ${datasetName} not found`);\n  }\n  const dataset = datasets[datasetId];\n  if (dataset) {\n    // check if field exists\n    const field = dataset.fields.find(field => field.name === variableName);\n    if (!field) {\n      throw new Error(`Field ${variableName} not found in dataset ${datasetName}`);\n    }\n    // for vector-tile, getting values from layerData\n    if (dataset.type === 'vector-tile') {\n      // get field from dataset\n      const field = dataset.fields.find(field => field.name === variableName);\n      if (field) {\n        return getValuesFromVectorTileLayer(datasetId, layers, field);\n      }\n    }\n    return Array.from({length: dataset.length}, (_, i) => dataset.getValue(variableName, i));\n  }\n  return [];\n}\n\nfunction isVectorTileLayer(layer: Layer): layer is VectorTileLayer {\n  return layer.type === LAYER_TYPES.vectorTile;\n}\n\nexport function getValuesFromVectorTileLayer(datasetId: string, layers: Layer[], field: Field) {\n  // get the index of the layer\n  const layerIndex = layers.findIndex(layer => layer.config.dataId === datasetId);\n  if (layerIndex === -1) return [];\n  const layer = layers[layerIndex];\n  if (!isVectorTileLayer(layer)) return [];\n  const accessor = layer.accessRowValue(field);\n  const values: unknown[] = [];\n  // @ts-expect-error TODO fix this later in the vector-tile layer\n  for (const row of layer.tileDataset.tileSet) {\n    const value = accessor(field, row);\n    if (value === null) break;\n    values.push(value);\n  }\n  return values;\n}\n\n/**\n * Highlight the rows in a dataset\n * @param datasets The kepler.gl datasets\n * @param layers The kepler.gl layers\n * @param datasetName The name of the dataset\n * @param selectedRowIndices The indices of the rows to highlight\n * @param layerSetIsValid The function to set the layer validity\n */\nexport function highlightRows(\n  datasets: Datasets,\n  layers: Layer[],\n  datasetName: string,\n  selectedRowIndices: number[],\n  layerSetIsValid: (layer: Layer, isValid: boolean) => void\n) {\n  // update the filteredIndex in the dataset\n  const datasetId = Object.keys(datasets).find(dataId => datasets[dataId].label === datasetName);\n  if (!datasetId) return;\n  const dataset = datasets[datasetId];\n  if (dataset) {\n    dataset.filteredIndex =\n      selectedRowIndices.length === 0 ? dataset.allIndexes : selectedRowIndices;\n    // get all layers that use this dataset\n    const selectLayers = layers.filter(layer => layer.config.dataId === dataset.id);\n    selectLayers.forEach(layer => {\n      layer.formatLayerData(datasets);\n      // trigger a re-render using layerSetIsValid() to update the top layer\n      layerSetIsValid(layer, true);\n    });\n  }\n}\n\n/**\n * Get the dataset context, which is used to provide the dataset information to the AI assistant\n * @param datasets The kepler.gl datasets\n * @param layers The kepler.gl layers\n * @returns The dataset context\n */\nexport function getDatasetContext(datasets?: Datasets, layers?: Layer[]) {\n  if (!datasets || !layers) return '';\n  const context =\n    'Please remember the following datasets and layers for answering the user question:';\n  const dataMeta = Object.values(datasets).map((dataset: KeplerTable) => ({\n    datasetName: dataset.label,\n    datasetId: dataset.id,\n    fields: dataset.fields.map(field => ({[field.name]: field.type})),\n    layers: layers\n      .filter(layer => layer.config.dataId === dataset.id)\n      .map(layer => ({\n        id: layer.id,\n        label: layer.config.label,\n        type: layer.type,\n        geometryMode: layer.config.columnMode,\n        // get the valid geometry columns as string\n        geometryColumns: Object.fromEntries(\n          Object.entries(layer.config.columns)\n            .filter(([, value]) => value !== null)\n            .map(([key, value]) => [\n              key,\n              typeof value === 'object' && value !== null\n                ? Object.fromEntries(Object.entries(value).filter(([, v]) => v !== null))\n                : value\n            ])\n        )\n      }))\n  }));\n  return `${context}\\n${JSON.stringify(dataMeta)}`;\n}\n\n/**\n * Get the geometries from a dataset\n * @param datasets The kepler.gl datasets\n * @param layers The kepler.gl layers\n * @param layerData The layer data\n * @param datasetName The name of the dataset\n * @returns The geometries\n */\nexport function getGeometriesFromDataset(\n  datasets: Datasets,\n  layers: Layer[],\n  layerData: any[],\n  datasetName: string\n): SpatialJoinGeometries {\n  const datasetId = Object.keys(datasets).find(dataId => datasets[dataId].label === datasetName);\n  if (!datasetId) {\n    return [];\n  }\n  const dataset = datasets[datasetId];\n\n  // if layer is vector-tile, get the geometries from the layer\n  if (dataset.type === 'vector-tile') {\n    // find the vector-tile layer\n    const selected = layers.filter(layer => layer.config.dataId === dataset.id);\n    const layer = selected.find(layer => layer.type === LAYER_TYPES.vectorTile);\n    if (!layer) return [];\n\n    const geometries: Feature[] = [];\n    // @ts-expect-error TODO fix this later in the vector-tile layer\n    for (const row of layer.tileDataset.tileSet) {\n      geometries.push(row);\n    }\n    return geometries;\n  }\n\n  // for non-vector-tile dataset, get the geometries from the possible layer\n  const selectedLayers = layers.filter(layer => layer.config.dataId === dataset.id);\n  if (selectedLayers.length === 0) return [];\n\n  // find geojson layer, then point layer, then other layers\n  const geojsonLayer = selectedLayers.find(layer => layer.type === LAYER_TYPES.geojson);\n  const pointLayer = selectedLayers.find(layer => layer.type === LAYER_TYPES.point);\n  const otherLayers = selectedLayers.filter(\n    layer => layer.type !== LAYER_TYPES.geojson && layer.type !== LAYER_TYPES.point\n  );\n\n  const validLayer = geojsonLayer || pointLayer || otherLayers[0];\n  if (validLayer) {\n    const layerIndex = layers.findIndex(layer => layer.id === validLayer.id);\n    const geometries = layerData[layerIndex];\n    return geometries.data;\n  }\n\n  return [];\n}\n\n/**\n * Save the data as a new dataset by joining it with the left dataset\n * @param datasets The kepler.gl datasets\n * @param datasetName The name of the left dataset\n * @param data The data to save\n * @param addDataToMap The function to add the data to the map\n */\nexport function saveAsDataset(\n  datasets: Datasets,\n  layers: Layer[],\n  datasetName: string,\n  newDatasetName: string,\n  data: Record<string, unknown[]>\n) {\n  // find datasetId from datasets\n  const datasetId = Object.keys(datasets).find(dataId => datasets[dataId].label === datasetName);\n  if (!datasetId) return;\n\n  // check if newDatasetName already exists\n  if (Object.keys(datasets).includes(newDatasetName)) return;\n\n  // Save the data as a new dataset by joining it with the left dataset\n  const leftDataset = datasets[datasetId];\n  let numRows = leftDataset.length;\n  let geometries: Feature[];\n\n  if (leftDataset.type === 'vector-tile') {\n    // we need to get geometries from the vector-tile layer\n    geometries = getFeaturesFromVectorTile(leftDataset, layers) || [];\n    numRows = geometries.length;\n  }\n\n  const fields: ProtoDatasetField[] = [\n    // New fields from data\n    ...Object.keys(data).map((fieldName, index) => ({\n      name: fieldName,\n      id: `${fieldName}_${index}`,\n      displayName: fieldName,\n      type: determineFieldType(data[fieldName][0])\n    })),\n    // Existing fields from leftDataset\n    ...leftDataset.fields.map((field, index) => ({\n      name: field.name,\n      id: field.id || `${field.name}_${index}`,\n      displayName: field.displayName,\n      type: field.type\n    })),\n    // add geometry column for vector-tile\n    ...(leftDataset.type === 'vector-tile'\n      ? [\n          {\n            name: '_geojson',\n            id: '_geojson',\n            displayName: '_geojson',\n            type: 'geojson'\n          }\n        ]\n      : [])\n  ];\n\n  // Pre-calculate data values array\n  const dataValues = Object.values(data);\n\n  const rows = Array(numRows)\n    .fill(null)\n    .map((_, rowIdx) => [\n      // New data values\n      ...dataValues.map(col => col[rowIdx]),\n      // Existing dataset values\n      ...leftDataset.fields.map(field =>\n        leftDataset.type === 'vector-tile'\n          ? geometries[rowIdx].properties?.[field.name]\n          : leftDataset.getValue(field.name, rowIdx)\n      ),\n      // geometry column for vector-tile\n      ...(leftDataset.type === 'vector-tile' ? [geometries[rowIdx]] : [])\n    ]);\n\n  // create new dataset\n  const newDataset: ProtoDataset = {\n    info: {\n      id: newDatasetName,\n      label: newDatasetName\n    },\n    data: {\n      fields,\n      rows\n    }\n  };\n\n  return newDataset;\n}\n\n/**\n * Helper function to determine field type\n * @param value The value to determine the field type\n * @returns The field type\n */\nfunction determineFieldType(value: unknown): keyof typeof ALL_FIELD_TYPES {\n  return typeof value === 'number'\n    ? Number.isInteger(value)\n      ? ALL_FIELD_TYPES.integer\n      : ALL_FIELD_TYPES.real\n    : ALL_FIELD_TYPES.string;\n}\n\nexport function highlightRowsByColumnValues(\n  datasets: Datasets,\n  layers: Layer[],\n  datasetName: string,\n  columnName: string,\n  selectedValues: unknown[],\n  layerSetIsValid: (layer: Layer, isValid: boolean) => void\n) {\n  const datasetId = Object.keys(datasets).find(dataId => datasets[dataId].label === datasetName);\n  if (!datasetId) return;\n  const dataset = datasets[datasetId];\n  if (dataset) {\n    // get the values of the column\n    const values = Array.from({length: dataset.length}, (_, i) => dataset.getValue(columnName, i));\n    // create a dict using the values\n    const valueDict = values.reduce((acc, value, index) => {\n      acc[value] = index;\n      return acc;\n    }, {});\n    // need to fix the type error of value here\n    const selectedIndices = selectedValues.map(value => valueDict[value as any]);\n    // highlight the rows\n    highlightRows(datasets, layers, datasetName, selectedIndices, layerSetIsValid);\n  }\n}\n\nfunction getFeaturesFromVectorTile(leftDataset: KeplerTable, layers: Layer[]) {\n  const layerIndex = layers.findIndex(layer => layer.config.dataId === leftDataset.id);\n  if (layerIndex === -1) return;\n\n  const layer = layers[layerIndex];\n  if (!isVectorTileLayer(layer)) return;\n\n  const features: Feature[] = [];\n  // @ts-expect-error TODO fix this later in the vector-tile layer\n  for (const row of layer.tileDataset.tileSet) {\n    features.push(row);\n  }\n\n  return features;\n}\n\nexport async function appendColumnsToDataset(\n  datasets: Datasets,\n  layers: Layer[],\n  datasetName: string,\n  result: Record<string, number>[],\n  newDatasetName: string\n) {\n  // find datasetId from datasets\n  const datasetId = Object.keys(datasets).find(dataId => datasets[dataId].label === datasetName);\n  if (!datasetId) {\n    throw new Error(`Dataset ${datasetName} not found`);\n  }\n\n  const originalDataset = datasets[datasetId];\n\n  const fields = originalDataset.fields;\n\n  const numRows = originalDataset.length || result.length;\n\n  // create a rowObjects array to store the original dataset values + query result values\n  const rowObjects: Record<string, unknown>[] = [];\n\n  if (originalDataset.type === 'vector-tile') {\n    const columnData = {};\n    for (const field of fields) {\n      // get the values from the vector tile layer\n      columnData[field.name] = getValuesFromVectorTileLayer(datasetId, layers, field);\n    }\n    // convert columnData to rowObjects\n    for (let i = 0; i < numRows; i++) {\n      const rowObject: Record<string, unknown> = {};\n      for (const field of fields) {\n        rowObject[field.name] = columnData[field.name][i];\n      }\n      rowObjects.push(rowObject);\n    }\n  } else {\n    for (let i = 0; i < numRows; i++) {\n      const rowObject: Record<string, unknown> = {};\n      for (const field of fields) {\n        const value = originalDataset.getValue(field.name, i);\n        rowObject[field.name] = value;\n      }\n      rowObjects.push(rowObject);\n    }\n  }\n\n  // add the query result to the original dataset or update the field values from query result\n  for (let i = 0; i < numRows; i++) {\n    const queryRow = result[i];\n    const rowObject = rowObjects[i];\n    // iterate over the keys of queryRow\n    Object.keys(queryRow).forEach(key => {\n      const value = queryRow[key];\n      rowObject[key] = value;\n    });\n  }\n\n  // use processFileData to process the rowObject\n  const processedData = await processFileData({\n    content: {fileName: newDatasetName, data: rowObjects},\n    fileCache: []\n  });\n\n  return processedData;\n}\n"],"mappings":"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