kepler.gl 3.1.0-alpha.6 → 3.1.0

package/src/ai-assistant/dist/tools/utils.d.ts

@@ -1,5 +1,14 @@
 import { Layer } from '@kepler.gl/layers';
 import { Datasets, KeplerTable } from '@kepler.gl/table';
+import { SpatialJoinGeometries } from '@openassistant/geoda';
+import { AddDataToMapPayload } from '@kepler.gl/types';
+/**
+ * Check if the dataset exists
+ * @param datasets The kepler.gl datasets
+ * @param datasetName The name of the dataset
+ * @param functionName The name of the function
+ * @returns The result of the check
+ */
 export declare function checkDatasetNotExists(datasets: Datasets, datasetName: string, functionName: string): {
     name: string;
     result: {
@@ -7,6 +16,13 @@ export declare function checkDatasetNotExists(datasets: Datasets, datasetName: s
         details: string;
     };
 } | null;
+/**
+ * Check if the field exists
+ * @param dataset The kepler.gl dataset
+ * @param fieldName The name of the field
+ * @param functionName The name of the function
+ * @returns The result of the check
+ */
 export declare function checkFieldNotExists(dataset: KeplerTable, fieldName: string, functionName: string): {
     type: string;
     name: string;
@@ -15,7 +31,64 @@ export declare function checkFieldNotExists(dataset: KeplerTable, fieldName: str
         details: string;
     };
 } | null;
+/**
+ * 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
+ */
 export declare function interpolateColor(originalColors: string[], numberOfColors: number): string[];
+/**
+ * Get the values from a dataset for a variable
+ * @param datasets
+ * @param datasetName
+ * @param variableName
+ * @returns {number[]}
+ */
 export declare function getValuesFromDataset(datasets: Datasets, datasetName: string, variableName: string): number[];
+/**
+ * Get the x and y values from a dataset for a scatterplot
+ * @param datasets
+ * @param datasetName
+ * @param xVariableName
+ * @param yVariableName
+ * @returns {x: number[], y: number[]}
+ */
+export declare function getScatterplotValuesFromDataset(datasets: Datasets, datasetName: string, xVariableName: string, yVariableName: string): {
+    x: number[];
+    y: number[];
+};
+/**
+ * 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
+ */
 export declare function highlightRows(datasets: Datasets, layers: Layer[], datasetName: string, selectedRowIndices: number[], layerSetIsValid: (layer: Layer, isValid: boolean) => void): void;
+/**
+ * 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
+ */
 export declare function getDatasetContext(datasets: Datasets, layers: Layer[]): string;
+/**
+ * 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
+ */
+export declare function getGeometriesFromDataset(datasets: Datasets, layers: Layer[], layerData: any[], datasetName: string): SpatialJoinGeometries;
+/**
+ * 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
+ */
+export declare function saveAsDataset(datasets: Datasets, datasetName: string, data: Record<string, number[]>, addDataToMap: (data: AddDataToMapPayload) => void): void;
+export declare function highlightRowsByColumnValues(datasets: Datasets, layers: Layer[], datasetName: string, columnName: string, selectedValues: unknown[], layerSetIsValid: (layer: Layer, isValid: boolean) => void): void;

package/src/ai-assistant/dist/tools/utils.js

@@ -7,14 +7,29 @@ Object.defineProperty(exports, "__esModule", {
 exports.checkDatasetNotExists = checkDatasetNotExists;
 exports.checkFieldNotExists = checkFieldNotExists;
 exports.getDatasetContext = getDatasetContext;
+exports.getGeometriesFromDataset = getGeometriesFromDataset;
+exports.getScatterplotValuesFromDataset = getScatterplotValuesFromDataset;
 exports.getValuesFromDataset = getValuesFromDataset;
 exports.highlightRows = highlightRows;
+exports.highlightRowsByColumnValues = highlightRowsByColumnValues;
 exports.interpolateColor = interpolateColor;
+exports.saveAsDataset = saveAsDataset;
+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");
 // SPDX-License-Identifier: MIT
 // Copyright contributors to the kepler.gl project
 
+/**
+ * Check if the dataset exists
+ * @param datasets The kepler.gl datasets
+ * @param datasetName The name of the dataset
+ * @param functionName The name of the function
+ * @returns The result of the check
+ */
 function checkDatasetNotExists(datasets, datasetName, functionName) {
   var datasetId = Object.keys(datasets).find(function (dataId) {
     return datasets[dataId].label === datasetName;
@@ -30,6 +45,14 @@ function checkDatasetNotExists(datasets, datasetName, functionName) {
   }
   return null;
 }
+
+/**
+ * Check if the field exists
+ * @param dataset The kepler.gl dataset
+ * @param fieldName The name of the field
+ * @param functionName The name of the function
+ * @returns The result of the check
+ */
 function checkFieldNotExists(dataset, fieldName, functionName) {
   var field = dataset.fields.find(function (f) {
     return f.name === fieldName;
@@ -48,6 +71,13 @@ function checkFieldNotExists(dataset, fieldName, functionName) {
   }
   return null;
 }
+
+/**
+ * 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;
@@ -67,6 +97,14 @@ function interpolateColor(originalColors, numberOfColors) {
   });
   return hexColors;
 }
+
+/**
+ * Get the values from a dataset for a variable
+ * @param datasets
+ * @param datasetName
+ * @param variableName
+ * @returns {number[]}
+ */
 function getValuesFromDataset(datasets, datasetName, variableName) {
   // find which dataset has the variableName
   var datasetId = Object.keys(datasets).find(function (dataId) {
@@ -83,6 +121,32 @@ function getValuesFromDataset(datasets, datasetName, variableName) {
   }
   return [];
 }
+
+/**
+ * Get the x and y values from a dataset for a scatterplot
+ * @param datasets
+ * @param datasetName
+ * @param xVariableName
+ * @param yVariableName
+ * @returns {x: number[], y: number[]}
+ */
+function getScatterplotValuesFromDataset(datasets, datasetName, xVariableName, yVariableName) {
+  var xValues = getValuesFromDataset(datasets, datasetName, xVariableName);
+  var yValues = getValuesFromDataset(datasets, datasetName, yVariableName);
+  return {
+    x: xValues,
+    y: yValues
+  };
+}
+
+/**
+ * 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) {
@@ -99,10 +163,17 @@ function highlightRows(datasets, layers, datasetName, selectedRowIndices, layerS
     selectLayers.forEach(function (layer) {
       layer.formatLayerData(datasets);
       // trigger a re-render using layerSetIsValid() to update the top layer
-      layerSetIsValid(selectLayers[0], true);
+      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) {
   var context = 'Please remember the following dataset context:';
   var dataMeta = Object.values(datasets).map(function (dataset) {
@@ -118,11 +189,148 @@ function getDatasetContext(datasets, layers) {
         return {
           id: layer.id,
           label: layer.config.label,
-          type: layer.type
+          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));
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_colorInterpolate","_interopRequireDefault","require","checkDatasetNotExists","datasets","datasetName","functionName","datasetId","Object","keys","find","dataId","label","name","result","success","details","concat","join","checkFieldNotExists","dataset","fieldName","field","fields","f","type","map","interpolateColor","originalColors","numberOfColors","length","interp","interpolate","colors","Array","from","_","j","hexColors","color","rgb","match","c","parseInt","toString","padStart","getValuesFromDataset","variableName","i","getValue","highlightRows","layers","selectedRowIndices","layerSetIsValid","filteredIndex","allIndexes","selectLayers","filter","layer","config","id","forEach","formatLayerData","getDatasetContext","context","dataMeta","values","_defineProperty2","JSON","stringify"],"sources":["../../src/tools/utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport interpolate from 'color-interpolate';\n\nimport {Layer} from '@kepler.gl/layers';\nimport {Datasets, KeplerTable} from '@kepler.gl/table';\n\nexport function checkDatasetNotExists(\n  datasets: Datasets,\n  datasetName: string,\n  functionName: string\n) {\n  const datasetId = Object.keys(datasets).find(dataId => datasets[dataId].label === datasetName);\n  if (!datasetId) {\n    return {\n      name: functionName,\n      result: {\n        success: false,\n        details: `Dataset not found. Please specify one from the following datasets: ${Object.keys(\n          datasets\n        ).join(', ')}`\n      }\n    };\n  }\n  return null;\n}\n\nexport function checkFieldNotExists(dataset: KeplerTable, fieldName: string, functionName: string) {\n  const field = dataset.fields.find(f => f.name === fieldName);\n  if (!field) {\n    return {\n      type: 'layer',\n      name: functionName,\n      result: {\n        success: false,\n        details: `Field not found. Please specify one from the following fields: ${dataset.fields\n          .map(f => f.name)\n          .join(', ')}`\n      }\n    };\n  }\n  return null;\n}\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\nexport function getValuesFromDataset(\n  datasets: Datasets,\n  datasetName: string,\n  variableName: string\n): number[] {\n  // find which dataset has the variableName\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    return Array.from({length: dataset.length}, (_, i) => dataset.getValue(variableName, i));\n  }\n  return [];\n}\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(selectLayers[0], true);\n    });\n  }\n}\n\nexport function getDatasetContext(datasets: Datasets, layers: Layer[]) {\n  const context = 'Please remember the following dataset context:';\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 => ({id: layer.id, label: layer.config.label, type: layer.type}))\n  }));\n  return `${context}\\n${JSON.stringify(dataMeta)}`;\n}\n"],"mappings":"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","ignoreList":[]}
+
+/**
+ * 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];
+
+  // get the index of the layer
+  var layerIndex = layers.findIndex(function (layer) {
+    return layer.config.dataId === dataset.id;
+  });
+  if (layerIndex === -1) return [];
+  var geometries = layerData[layerIndex];
+  return geometries === null || geometries === void 0 ? void 0 : geometries.data;
+}
+
+/**
+ * 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, datasetName, data, addDataToMap) {
+  // find datasetId from datasets
+  var datasetId = Object.keys(datasets).find(function (dataId) {
+    return datasets[dataId].label === datasetName;
+  });
+  if (!datasetId) return;
+  var leftDataset = datasets[datasetId];
+  var numRows = leftDataset.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
+    };
+  })));
+
+  // 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) {
+      return leftDataset.getValue(field.name, rowIdx);
+    })));
+  });
+
+  // create new dataset
+  var newDatasetName = "".concat(datasetName, "_joined");
+  var newDataset = {
+    info: {
+      id: newDatasetName,
+      label: newDatasetName
+    },
+    data: {
+      fields: fields,
+      rows: rows
+    }
+  };
+  addDataToMap({
+    datasets: [newDataset],
+    options: {
+      autoCreateLayers: true,
+      centerMap: true
+    }
+  });
+}
+
+/**
+ * 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);
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_colorInterpolate","_interopRequireDefault","require","_constants","checkDatasetNotExists","datasets","datasetName","functionName","datasetId","Object","keys","find","dataId","label","name","result","success","details","concat","join","checkFieldNotExists","dataset","fieldName","field","fields","f","type","map","interpolateColor","originalColors","numberOfColors","length","interp","interpolate","colors","Array","from","_","j","hexColors","color","rgb","match","c","parseInt","toString","padStart","getValuesFromDataset","variableName","i","getValue","getScatterplotValuesFromDataset","xVariableName","yVariableName","xValues","yValues","x","y","highlightRows","layers","selectedRowIndices","layerSetIsValid","filteredIndex","allIndexes","selectLayers","filter","layer","config","id","forEach","formatLayerData","getDatasetContext","context","dataMeta","values","_defineProperty2","geometryMode","columnMode","geometryColumns","fromEntries","entries","columns","_ref2","_ref3","_slicedToArray2","value","_ref4","_ref5","key","_typeof2","_ref6","_ref7","v","JSON","stringify","getGeometriesFromDataset","layerData","layerIndex","findIndex","geometries","data","saveAsDataset","addDataToMap","leftDataset","numRows","_toConsumableArray2","index","displayName","determineFieldType","dataValues","rows","fill","rowIdx","col","newDatasetName","newDataset","info","options","autoCreateLayers","centerMap","Number","isInteger","ALL_FIELD_TYPES","integer","real","string","highlightRowsByColumnValues","columnName","selectedValues","valueDict","reduce","acc","selectedIndices"],"sources":["../../src/tools/utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport interpolate from 'color-interpolate';\n\nimport {Layer} from '@kepler.gl/layers';\nimport {Datasets, KeplerTable} from '@kepler.gl/table';\nimport {SpatialJoinGeometries} from '@openassistant/geoda';\nimport {ALL_FIELD_TYPES} from '@kepler.gl/constants';\nimport {AddDataToMapPayload, ProtoDataset, ProtoDatasetField} from '@kepler.gl/types';\n\n/**\n * Check if the dataset exists\n * @param datasets The kepler.gl datasets\n * @param datasetName The name of the dataset\n * @param functionName The name of the function\n * @returns The result of the check\n */\nexport function checkDatasetNotExists(\n  datasets: Datasets,\n  datasetName: string,\n  functionName: string\n) {\n  const datasetId = Object.keys(datasets).find(dataId => datasets[dataId].label === datasetName);\n  if (!datasetId) {\n    return {\n      name: functionName,\n      result: {\n        success: false,\n        details: `Dataset not found. Please specify one from the following datasets: ${Object.keys(\n          datasets\n        ).join(', ')}`\n      }\n    };\n  }\n  return null;\n}\n\n/**\n * Check if the field exists\n * @param dataset The kepler.gl dataset\n * @param fieldName The name of the field\n * @param functionName The name of the function\n * @returns The result of the check\n */\nexport function checkFieldNotExists(dataset: KeplerTable, fieldName: string, functionName: string) {\n  const field = dataset.fields.find(f => f.name === fieldName);\n  if (!field) {\n    return {\n      type: 'layer',\n      name: functionName,\n      result: {\n        success: false,\n        details: `Field not found. Please specify one from the following fields: ${dataset.fields\n          .map(f => f.name)\n          .join(', ')}`\n      }\n    };\n  }\n  return null;\n}\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  datasetName: string,\n  variableName: string\n): number[] {\n  // find which dataset has the variableName\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    return Array.from({length: dataset.length}, (_, i) => dataset.getValue(variableName, i));\n  }\n  return [];\n}\n\n/**\n * Get the x and y values from a dataset for a scatterplot\n * @param datasets\n * @param datasetName\n * @param xVariableName\n * @param yVariableName\n * @returns {x: number[], y: number[]}\n */\nexport function getScatterplotValuesFromDataset(\n  datasets: Datasets,\n  datasetName: string,\n  xVariableName: string,\n  yVariableName: string\n): {x: number[]; y: number[]} {\n  const xValues = getValuesFromDataset(datasets, datasetName, xVariableName);\n  const yValues = getValuesFromDataset(datasets, datasetName, yVariableName);\n  return {x: xValues, y: yValues};\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  const context = 'Please remember the following dataset context:';\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) return [];\n  const dataset = datasets[datasetId];\n\n  // get the index of the layer\n  const layerIndex = layers.findIndex(layer => layer.config.dataId === dataset.id);\n  if (layerIndex === -1) return [];\n\n  const geometries = layerData[layerIndex];\n\n  return geometries?.data;\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  datasetName: string,\n  data: Record<string, number[]>,\n  addDataToMap: (data: AddDataToMapPayload) => void\n) {\n  // find datasetId from datasets\n  const datasetId = Object.keys(datasets).find(dataId => datasets[dataId].label === datasetName);\n  if (!datasetId) return;\n\n  const leftDataset = datasets[datasetId];\n  const numRows = leftDataset.length;\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  ];\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 => leftDataset.getValue(field.name, rowIdx))\n    ]);\n\n  // create new dataset\n  const newDatasetName = `${datasetName}_joined`;\n  const newDataset: ProtoDataset = {\n    info: {\n      id: newDatasetName,\n      label: newDatasetName\n    },\n    data: {\n      fields,\n      rows\n    }\n  };\n\n  addDataToMap({datasets: [newDataset], options: {autoCreateLayers: true, centerMap: true}});\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"],"mappings":";;;;;;;;;;;;;;;;;;;;AAGA,IAAAA,iBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAKA,IAAAC,UAAA,GAAAD,OAAA;AARA;AACA;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,qBAAqBA,CACnCC,QAAkB,EAClBC,WAAmB,EACnBC,YAAoB,EACpB;EACA,IAAMC,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACL,QAAQ,CAAC,CAACM,IAAI,CAAC,UAAAC,MAAM;IAAA,OAAIP,QAAQ,CAACO,MAAM,CAAC,CAACC,KAAK,KAAKP,WAAW;EAAA,EAAC;EAC9F,IAAI,CAACE,SAAS,EAAE;IACd,OAAO;MACLM,IAAI,EAAEP,YAAY;MAClBQ,MAAM,EAAE;QACNC,OAAO,EAAE,KAAK;QACdC,OAAO,wEAAAC,MAAA,CAAwET,MAAM,CAACC,IAAI,CACxFL,QACF,CAAC,CAACc,IAAI,CAAC,IAAI,CAAC;MACd;IACF,CAAC;EACH;EACA,OAAO,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,mBAAmBA,CAACC,OAAoB,EAAEC,SAAiB,EAAEf,YAAoB,EAAE;EACjG,IAAMgB,KAAK,GAAGF,OAAO,CAACG,MAAM,CAACb,IAAI,CAAC,UAAAc,CAAC;IAAA,OAAIA,CAAC,CAACX,IAAI,KAAKQ,SAAS;EAAA,EAAC;EAC5D,IAAI,CAACC,KAAK,EAAE;IACV,OAAO;MACLG,IAAI,EAAE,OAAO;MACbZ,IAAI,EAAEP,YAAY;MAClBQ,MAAM,EAAE;QACNC,OAAO,EAAE,KAAK;QACdC,OAAO,oEAAAC,MAAA,CAAoEG,OAAO,CAACG,MAAM,CACtFG,GAAG,CAAC,UAAAF,CAAC;UAAA,OAAIA,CAAC,CAACX,IAAI;QAAA,EAAC,CAChBK,IAAI,CAAC,IAAI,CAAC;MACf;IACF,CAAC;EACH;EACA,OAAO,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASS,gBAAgBA,CAACC,cAAwB,EAAEC,cAAsB,EAAE;EACjF,IAAID,cAAc,CAACE,MAAM,KAAKD,cAAc,EAAE;IAC5C,OAAOD,cAAc;EACvB;EACA,IAAMG,MAAM,GAAG,IAAAC,4BAAW,EAACJ,cAAc,CAAC;EAC1C,IAAMK,MAAM,GAAGC,KAAK,CAACC,IAAI,CAAC;IAACL,MAAM,EAAED;EAAc,CAAC,EAAE,UAACO,CAAC,EAAEC,CAAC;IAAA,OAAKN,MAAM,CAACM,CAAC,IAAIR,cAAc,GAAG,CAAC,CAAC,CAAC;EAAA,EAAC;EAC/F;EACA,IAAMS,SAAS,GAAGL,MAAM,CAACP,GAAG,CAAC,UAAAa,KAAK,EAAI;IACpC,IAAMC,GAAG,GAAGD,KAAK,CAACE,KAAK,CAAC,MAAM,CAAC;IAC/B,WAAAxB,MAAA,CAAWuB,GAAG,aAAHA,GAAG,uBAAHA,GAAG,CAAEd,GAAG,CAAC,UAAAgB,CAAC;MAAA,OAAIC,QAAQ,CAACD,CAAC,CAAC,CAACE,QAAQ,CAAC,EAAE,CAAC,CAACC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC;IAAA,EAAC,CAAC3B,IAAI,CAAC,EAAE,CAAC;EAC9E,CAAC,CAAC;EACF,OAAOoB,SAAS;AAClB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASQ,oBAAoBA,CAClC1C,QAAkB,EAClBC,WAAmB,EACnB0C,YAAoB,EACV;EACV;EACA,IAAMxC,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACL,QAAQ,CAAC,CAACM,IAAI,CAAC,UAAAC,MAAM;IAAA,OAAIP,QAAQ,CAACO,MAAM,CAAC,CAACC,KAAK,KAAKP,WAAW;EAAA,EAAC;EAC9F,IAAI,CAACE,SAAS,EAAE,OAAO,EAAE;EACzB,IAAMa,OAAO,GAAGhB,QAAQ,CAACG,SAAS,CAAC;EACnC,IAAIa,OAAO,EAAE;IACX,OAAOc,KAAK,CAACC,IAAI,CAAC;MAACL,MAAM,EAAEV,OAAO,CAACU;IAAM,CAAC,EAAE,UAACM,CAAC,EAAEY,CAAC;MAAA,OAAK5B,OAAO,CAAC6B,QAAQ,CAACF,YAAY,EAAEC,CAAC,CAAC;IAAA,EAAC;EAC1F;EACA,OAAO,EAAE;AACX;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,+BAA+BA,CAC7C9C,QAAkB,EAClBC,WAAmB,EACnB8C,aAAqB,EACrBC,aAAqB,EACO;EAC5B,IAAMC,OAAO,GAAGP,oBAAoB,CAAC1C,QAAQ,EAAEC,WAAW,EAAE8C,aAAa,CAAC;EAC1E,IAAMG,OAAO,GAAGR,oBAAoB,CAAC1C,QAAQ,EAAEC,WAAW,EAAE+C,aAAa,CAAC;EAC1E,OAAO;IAACG,CAAC,EAAEF,OAAO;IAAEG,CAAC,EAAEF;EAAO,CAAC;AACjC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,aAAaA,CAC3BrD,QAAkB,EAClBsD,MAAe,EACfrD,WAAmB,EACnBsD,kBAA4B,EAC5BC,eAAyD,EACzD;EACA;EACA,IAAMrD,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACL,QAAQ,CAAC,CAACM,IAAI,CAAC,UAAAC,MAAM;IAAA,OAAIP,QAAQ,CAACO,MAAM,CAAC,CAACC,KAAK,KAAKP,WAAW;EAAA,EAAC;EAC9F,IAAI,CAACE,SAAS,EAAE;EAChB,IAAMa,OAAO,GAAGhB,QAAQ,CAACG,SAAS,CAAC;EACnC,IAAIa,OAAO,EAAE;IACXA,OAAO,CAACyC,aAAa,GACnBF,kBAAkB,CAAC7B,MAAM,KAAK,CAAC,GAAGV,OAAO,CAAC0C,UAAU,GAAGH,kBAAkB;IAC3E;IACA,IAAMI,YAAY,GAAGL,MAAM,CAACM,MAAM,CAAC,UAAAC,KAAK;MAAA,OAAIA,KAAK,CAACC,MAAM,CAACvD,MAAM,KAAKS,OAAO,CAAC+C,EAAE;IAAA,EAAC;IAC/EJ,YAAY,CAACK,OAAO,CAAC,UAAAH,KAAK,EAAI;MAC5BA,KAAK,CAACI,eAAe,CAACjE,QAAQ,CAAC;MAC/B;MACAwD,eAAe,CAACK,KAAK,EAAE,IAAI,CAAC;IAC9B,CAAC,CAAC;EACJ;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASK,iBAAiBA,CAAClE,QAAkB,EAAEsD,MAAe,EAAE;EACrE,IAAMa,OAAO,GAAG,gDAAgD;EAChE,IAAMC,QAAQ,GAAGhE,MAAM,CAACiE,MAAM,CAACrE,QAAQ,CAAC,CAACsB,GAAG,CAAC,UAACN,OAAoB;IAAA,OAAM;MACtEf,WAAW,EAAEe,OAAO,CAACR,KAAK;MAC1BL,SAAS,EAAEa,OAAO,CAAC+C,EAAE;MACrB5C,MAAM,EAAEH,OAAO,CAACG,MAAM,CAACG,GAAG,CAAC,UAAAJ,KAAK;QAAA,WAAAoD,gBAAA,iBAAOpD,KAAK,CAACT,IAAI,EAAGS,KAAK,CAACG,IAAI;MAAA,CAAE,CAAC;MACjEiC,MAAM,EAAEA,MAAM,CACXM,MAAM,CAAC,UAAAC,KAAK;QAAA,OAAIA,KAAK,CAACC,MAAM,CAACvD,MAAM,KAAKS,OAAO,CAAC+C,EAAE;MAAA,EAAC,CACnDzC,GAAG,CAAC,UAAAuC,KAAK;QAAA,OAAK;UACbE,EAAE,EAAEF,KAAK,CAACE,EAAE;UACZvD,KAAK,EAAEqD,KAAK,CAACC,MAAM,CAACtD,KAAK;UACzBa,IAAI,EAAEwC,KAAK,CAACxC,IAAI;UAChBkD,YAAY,EAAEV,KAAK,CAACC,MAAM,CAACU,UAAU;UACrC;UACAC,eAAe,EAAErE,MAAM,CAACsE,WAAW,CACjCtE,MAAM,CAACuE,OAAO,CAACd,KAAK,CAACC,MAAM,CAACc,OAAO,CAAC,CACjChB,MAAM,CAAC,UAAAiB,KAAA;YAAA,IAAAC,KAAA,OAAAC,eAAA,aAAAF,KAAA;cAAIG,KAAK,GAAAF,KAAA;YAAA,OAAME,KAAK,KAAK,IAAI;UAAA,EAAC,CACrC1D,GAAG,CAAC,UAAA2D,KAAA;YAAA,IAAAC,KAAA,OAAAH,eAAA,aAAAE,KAAA;cAAEE,GAAG,GAAAD,KAAA;cAAEF,KAAK,GAAAE,KAAA;YAAA,OAAM,CACrBC,GAAG,EACH,IAAAC,QAAA,aAAOJ,KAAK,MAAK,QAAQ,IAAIA,KAAK,KAAK,IAAI,GACvC5E,MAAM,CAACsE,WAAW,CAACtE,MAAM,CAACuE,OAAO,CAACK,KAAK,CAAC,CAACpB,MAAM,CAAC,UAAAyB,KAAA;cAAA,IAAAC,KAAA,OAAAP,eAAA,aAAAM,KAAA;gBAAIE,CAAC,GAAAD,KAAA;cAAA,OAAMC,CAAC,KAAK,IAAI;YAAA,EAAC,CAAC,GACvEP,KAAK,CACV;UAAA,EACL;QACF,CAAC;MAAA,CAAC;IACN,CAAC;EAAA,CAAC,CAAC;EACH,UAAAnE,MAAA,CAAUsD,OAAO,QAAAtD,MAAA,CAAK2E,IAAI,CAACC,SAAS,CAACrB,QAAQ,CAAC;AAChD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASsB,wBAAwBA,CACtC1F,QAAkB,EAClBsD,MAAe,EACfqC,SAAgB,EAChB1F,WAAmB,EACI;EACvB,IAAME,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACL,QAAQ,CAAC,CAACM,IAAI,CAAC,UAAAC,MAAM;IAAA,OAAIP,QAAQ,CAACO,MAAM,CAAC,CAACC,KAAK,KAAKP,WAAW;EAAA,EAAC;EAC9F,IAAI,CAACE,SAAS,EAAE,OAAO,EAAE;EACzB,IAAMa,OAAO,GAAGhB,QAAQ,CAACG,SAAS,CAAC;;EAEnC;EACA,IAAMyF,UAAU,GAAGtC,MAAM,CAACuC,SAAS,CAAC,UAAAhC,KAAK;IAAA,OAAIA,KAAK,CAACC,MAAM,CAACvD,MAAM,KAAKS,OAAO,CAAC+C,EAAE;EAAA,EAAC;EAChF,IAAI6B,UAAU,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE;EAEhC,IAAME,UAAU,GAAGH,SAAS,CAACC,UAAU,CAAC;EAExC,OAAOE,UAAU,aAAVA,UAAU,uBAAVA,UAAU,CAAEC,IAAI;AACzB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,aAAaA,CAC3BhG,QAAkB,EAClBC,WAAmB,EACnB8F,IAA8B,EAC9BE,YAAiD,EACjD;EACA;EACA,IAAM9F,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACL,QAAQ,CAAC,CAACM,IAAI,CAAC,UAAAC,MAAM;IAAA,OAAIP,QAAQ,CAACO,MAAM,CAAC,CAACC,KAAK,KAAKP,WAAW;EAAA,EAAC;EAC9F,IAAI,CAACE,SAAS,EAAE;EAEhB,IAAM+F,WAAW,GAAGlG,QAAQ,CAACG,SAAS,CAAC;EACvC,IAAMgG,OAAO,GAAGD,WAAW,CAACxE,MAAM;EAElC,IAAMP,MAA2B,MAAAN,MAAA,KAAAuF,mBAAA,aAE5BhG,MAAM,CAACC,IAAI,CAAC0F,IAAI,CAAC,CAACzE,GAAG,CAAC,UAACL,SAAS,EAAEoF,KAAK;IAAA,OAAM;MAC9C5F,IAAI,EAAEQ,SAAS;MACf8C,EAAE,KAAAlD,MAAA,CAAKI,SAAS,OAAAJ,MAAA,CAAIwF,KAAK,CAAE;MAC3BC,WAAW,EAAErF,SAAS;MACtBI,IAAI,EAAEkF,kBAAkB,CAACR,IAAI,CAAC9E,SAAS,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;EAAA,CAAC,CAAC,OAAAmF,mBAAA,aAEAF,WAAW,CAAC/E,MAAM,CAACG,GAAG,CAAC,UAACJ,KAAK,EAAEmF,KAAK;IAAA,OAAM;MAC3C5F,IAAI,EAAES,KAAK,CAACT,IAAI;MAChBsD,EAAE,EAAE7C,KAAK,CAAC6C,EAAE,OAAAlD,MAAA,CAAOK,KAAK,CAACT,IAAI,OAAAI,MAAA,CAAIwF,KAAK,CAAE;MACxCC,WAAW,EAAEpF,KAAK,CAACoF,WAAW;MAC9BjF,IAAI,EAAEH,KAAK,CAACG;IACd,CAAC;EAAA,CAAC,CAAC,EACJ;;EAED;EACA,IAAMmF,UAAU,GAAGpG,MAAM,CAACiE,MAAM,CAAC0B,IAAI,CAAC;EAEtC,IAAMU,IAAI,GAAG3E,KAAK,CAACqE,OAAO,CAAC,CACxBO,IAAI,CAAC,IAAI,CAAC,CACVpF,GAAG,CAAC,UAACU,CAAC,EAAE2E,MAAM;IAAA,UAAA9F,MAAA,KAAAuF,mBAAA,aAEVI,UAAU,CAAClF,GAAG,CAAC,UAAAsF,GAAG;MAAA,OAAIA,GAAG,CAACD,MAAM,CAAC;IAAA,EAAC,OAAAP,mBAAA,aAElCF,WAAW,CAAC/E,MAAM,CAACG,GAAG,CAAC,UAAAJ,KAAK;MAAA,OAAIgF,WAAW,CAACrD,QAAQ,CAAC3B,KAAK,CAACT,IAAI,EAAEkG,MAAM,CAAC;IAAA,EAAC;EAAA,CAC7E,CAAC;;EAEJ;EACA,IAAME,cAAc,MAAAhG,MAAA,CAAMZ,WAAW,YAAS;EAC9C,IAAM6G,UAAwB,GAAG;IAC/BC,IAAI,EAAE;MACJhD,EAAE,EAAE8C,cAAc;MAClBrG,KAAK,EAAEqG;IACT,CAAC;IACDd,IAAI,EAAE;MACJ5E,MAAM,EAANA,MAAM;MACNsF,IAAI,EAAJA;IACF;EACF,CAAC;EAEDR,YAAY,CAAC;IAACjG,QAAQ,EAAE,CAAC8G,UAAU,CAAC;IAAEE,OAAO,EAAE;MAACC,gBAAgB,EAAE,IAAI;MAAEC,SAAS,EAAE;IAAI;EAAC,CAAC,CAAC;AAC5F;;AAEA;AACA;AACA;AACA;AACA;AACA,SAASX,kBAAkBA,CAACvB,KAAc,EAAgC;EACxE,OAAO,OAAOA,KAAK,KAAK,QAAQ,GAC5BmC,MAAM,CAACC,SAAS,CAACpC,KAAK,CAAC,GACrBqC,0BAAe,CAACC,OAAO,GACvBD,0BAAe,CAACE,IAAI,GACtBF,0BAAe,CAACG,MAAM;AAC5B;AAEO,SAASC,2BAA2BA,CACzCzH,QAAkB,EAClBsD,MAAe,EACfrD,WAAmB,EACnByH,UAAkB,EAClBC,cAAyB,EACzBnE,eAAyD,EACzD;EACA,IAAMrD,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACL,QAAQ,CAAC,CAACM,IAAI,CAAC,UAAAC,MAAM;IAAA,OAAIP,QAAQ,CAACO,MAAM,CAAC,CAACC,KAAK,KAAKP,WAAW;EAAA,EAAC;EAC9F,IAAI,CAACE,SAAS,EAAE;EAChB,IAAMa,OAAO,GAAGhB,QAAQ,CAACG,SAAS,CAAC;EACnC,IAAIa,OAAO,EAAE;IACX;IACA,IAAMqD,MAAM,GAAGvC,KAAK,CAACC,IAAI,CAAC;MAACL,MAAM,EAAEV,OAAO,CAACU;IAAM,CAAC,EAAE,UAACM,CAAC,EAAEY,CAAC;MAAA,OAAK5B,OAAO,CAAC6B,QAAQ,CAAC6E,UAAU,EAAE9E,CAAC,CAAC;IAAA,EAAC;IAC9F;IACA,IAAMgF,SAAS,GAAGvD,MAAM,CAACwD,MAAM,CAAC,UAACC,GAAG,EAAE9C,KAAK,EAAEqB,KAAK,EAAK;MACrDyB,GAAG,CAAC9C,KAAK,CAAC,GAAGqB,KAAK;MAClB,OAAOyB,GAAG;IACZ,CAAC,EAAE,CAAC,CAAC,CAAC;IACN;IACA,IAAMC,eAAe,GAAGJ,cAAc,CAACrG,GAAG,CAAC,UAAA0D,KAAK;MAAA,OAAI4C,SAAS,CAAC5C,KAAK,CAAQ;IAAA,EAAC;IAC5E;IACA3B,aAAa,CAACrD,QAAQ,EAAEsD,MAAM,EAAErD,WAAW,EAAE8H,eAAe,EAAEvE,eAAe,CAAC;EAChF;AACF","ignoreList":[]}

package/src/ai-assistant/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kepler.gl/ai-assistant",
   "author": "Xun Li<lixun910@gmail.com>",
-  "version": "3.1.0-alpha.6",
+  "version": "3.1.0",
   "description": "kepler.gl AI assistant",
   "license": "MIT",
   "main": "dist/index.js",
@@ -30,17 +30,21 @@
     "umd"
   ],
   "dependencies": {
-    "@kepler.gl/components": "3.1.0-alpha.6",
-    "@kepler.gl/constants": "3.1.0-alpha.6",
-    "@kepler.gl/layers": "3.1.0-alpha.6",
-    "@kepler.gl/table": "3.1.0-alpha.6",
-    "@kepler.gl/types": "3.1.0-alpha.6",
-    "@kepler.gl/utils": "3.1.0-alpha.6",
+    "@kepler.gl/components": "3.1.0",
+    "@kepler.gl/constants": "3.1.0",
+    "@kepler.gl/layers": "3.1.0",
+    "@kepler.gl/table": "3.1.0",
+    "@kepler.gl/types": "3.1.0",
+    "@kepler.gl/utils": "3.1.0",
+    "@openassistant/core": "^0.0.7",
+    "@openassistant/echarts": "^0.0.6",
+    "@openassistant/geoda": "^0.0.6",
+    "@openassistant/ui": "^0.0.7",
     "color-interpolate": "^1.0.5",
     "echarts": "^5.5.1",
     "global": "^4.3.0",
-    "react-ai-assist": "0.0.20",
-    "react-intl": "^6.3.0"
+    "react-intl": "^6.3.0",
+    "usehooks-ts": "^3.1.0"
   },
   "nyc": {
     "sourceMap": false,

package/src/ai-assistant/src/actions.ts

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright contributors to the kepler.gl project
 
-import {MessageModel} from 'react-ai-assist';
+import {MessageModel} from '@openassistant/core';
 import {AiAssistantConfig} from './reducers';
 
-const ACTION_PREFIX = '@@react-ai-assistant/';
+const ACTION_PREFIX = '@@openassistant/';
 
 export const UPDATE_AI_ASSISTANT_CONFIG = `${ACTION_PREFIX}UPDATE_AI_ASSISTANT_CONFIG`;
 export const UPDATE_AI_ASSISTANT_MESSAGES = `${ACTION_PREFIX}UPDATE_AI_ASSISTANT_MESSAGES`;

package/src/ai-assistant/src/components/ai-assistant-component.tsx

@@ -3,13 +3,16 @@
 
 import React, {useEffect} from 'react';
 import styled, {withTheme} from 'styled-components';
+import {MessageModel, useAssistant} from '@openassistant/core';
 import {
-  AiAssistant,
-  MessageModel,
-  useAssistant,
-  histogramFunctionDefinition
-} from 'react-ai-assist';
-import 'react-ai-assist/dist/index.css';
+  dataClassifyFunctionDefinition,
+  spatialCountFunctionDefinition,
+  SpatialJoinGeometries
+} from '@openassistant/geoda';
+import {histogramFunctionDefinition, scatterplotFunctionDefinition} from '@openassistant/echarts';
+import {AiAssistant} from '@openassistant/ui';
+import '@openassistant/echarts/dist/index.css';
+import '@openassistant/ui/dist/index.css';
 
 import {textColorLT} from '@kepler.gl/styles';
 import {ActionHandler} from '@kepler.gl/actions';
@@ -29,11 +32,17 @@ import {
   PROMPT_IDEAS,
   WELCOME_MESSAGE
 } from '../constants';
-import {filterFunctionDefinition} from '../tools/filter-function';
 import {addLayerFunctionDefinition} from '../tools/layer-creation-function';
 import {updateLayerColorFunctionDefinition} from '../tools/layer-style-function';
 import {SelectedKeplerGlActions} from './ai-assistant-manager';
-import {getDatasetContext, getValuesFromDataset, highlightRows} from '../tools/utils';
+import {
+  getDatasetContext,
+  getGeometriesFromDataset,
+  getScatterplotValuesFromDataset,
+  getValuesFromDataset,
+  highlightRows,
+  saveAsDataset
+} from '../tools/utils';
 
 type ThemeProps = {theme: any};
 
@@ -69,6 +78,21 @@ function AiAssistantComponentFactory() {
     mapStyle,
     visState
   }: AiAssistantComponentProps & ThemeProps) => {
+    // get values from dataset, used by LLM functions
+    const getValuesCallback = (datasetName: string, variableName: string): number[] =>
+      getValuesFromDataset(visState.datasets, datasetName, variableName);
+
+    // highlight rows, used by LLM functions and plots (scatterplot, histogram)
+    const highlightRowsCallback = (datasetName: string, selectedRowIndices: number[]) =>
+      highlightRows(
+        visState.datasets,
+        visState.layers,
+        datasetName,
+        selectedRowIndices,
+        keplerGlActions.layerSetIsValid
+      );
+
+    // define LLM functions
     const functions = [
       basemapFunctionDefinition({mapStyleChange: keplerGlActions.mapStyleChange, mapStyle}),
       loadUrlFunctionDefinition({
@@ -84,30 +108,37 @@ function AiAssistantComponentFactory() {
         layerVisualChannelConfigChange: keplerGlActions.layerVisualChannelConfigChange,
         layers: visState.layers
       }),
-      filterFunctionDefinition({
-        datasets: visState.datasets,
-        filters: visState.filters,
-        createOrUpdateFilter: keplerGlActions.createOrUpdateFilter,
-        setFilter: keplerGlActions.setFilter,
-        setFilterPlot: keplerGlActions.setFilterPlot
-      }),
       histogramFunctionDefinition({
-        getValues: (datasetName: string, variableName: string): number[] =>
-          getValuesFromDataset(visState.datasets, datasetName, variableName),
-        onSelected: (datasetName: string, selectedRowIndices: number[]) =>
-          highlightRows(
+        getValues: getValuesCallback,
+        onSelected: highlightRowsCallback
+      }),
+      scatterplotFunctionDefinition({
+        getValues: async (datasetName: string, xVar: string, yVar: string) =>
+          getScatterplotValuesFromDataset(visState.datasets, datasetName, xVar, yVar),
+        onSelected: highlightRowsCallback
+      }),
+      dataClassifyFunctionDefinition({
+        getValues: getValuesCallback
+      }),
+      spatialCountFunctionDefinition({
+        getValues: getValuesCallback,
+        getGeometries: (datasetName: string): SpatialJoinGeometries =>
+          getGeometriesFromDataset(
             visState.datasets,
             visState.layers,
-            datasetName,
-            selectedRowIndices,
-            keplerGlActions.layerSetIsValid
-          )
+            visState.layerData,
+            datasetName
+          ),
+        saveAsDataset: (datasetName: string, data: Record<string, number[]>) =>
+          saveAsDataset(visState.datasets, datasetName, data, keplerGlActions.addDataToMap)
       })
     ];
 
+    // enable voice and screen capture
     const enableVoiceAndScreenCapture =
       aiAssistant.config.provider === 'openai' || aiAssistant.config.provider === 'google';
 
+    // define assistant props
     const assistantProps = {
       name: ASSISTANT_NAME,
       description: ASSISTANT_DESCRIPTION,
@@ -121,12 +152,14 @@ function AiAssistantComponentFactory() {
 
     const {initializeAssistant, addAdditionalContext} = useAssistant(assistantProps);
 
+    // initialize assistant with context
     const initializeAssistantWithContext = async () => {
       await initializeAssistant();
       const context = getDatasetContext(visState.datasets, visState.layers);
       addAdditionalContext({context});
     };
 
+    // initialize assistant with context
     useEffect(() => {
       initializeAssistantWithContext();
       // re-initialize assistant when datasets, filters or layers change