@kepler.gl/duckdb 3.3.0-alpha.0 → 3.3.0-alpha.10

package/dist/esm/components/sql-panel.js

@@ -0,0 +1,388 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject0, _templateObject1, _templateObject10;
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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
+
+import React, { useCallback, useState, useEffect, useRef } from 'react';
+import { useDispatch } from 'react-redux';
+import styled from 'styled-components';
+import { Panel, PanelGroup, PanelResizeHandle } from 'react-resizable-panels';
+import { addDataToMap } from '@kepler.gl/actions';
+import { generateHashId } from '@kepler.gl/common-utils';
+import { Button, FileDrop, IconButton, Icons, LoadingSpinner, Tooltip } from '@kepler.gl/components';
+import { arrowSchemaToFields } from '@kepler.gl/processors';
+import { sidePanelBg, panelBorderColor } from '@kepler.gl/styles';
+import { isAppleDevice, getApplicationConfig } from '@kepler.gl/utils';
+import MonacoEditor from './monaco-editor';
+import { SchemaPanel } from './schema-panel';
+import { PreviewDataPanel } from './preview-data-panel';
+import { castDuckDBTypesForKepler, getDuckDBColumnTypes, getDuckDBColumnTypesMap, setGeoArrowWKBExtension, splitSqlStatements, checkIsSelectQuery, removeSQLComments, tableFromFile, SUPPORTED_DUCKDB_DROP_EXTENSIONS } from '../table/duckdb-table-utils';
+var StyledSqlPanel = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  height: 100%;\n  background-color: ", ";\n  border-left: 1px solid #333;\n"])), sidePanelBg);
+var StyledSqlActions = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  flex: 0 0 50px;\n  display: flex;\n  padding-top: 12px;\n  align-items: center;\n  flex-direction: column;\n  justify-content: flex-start;\n  border-bottom: 1px solid #333;\n"])));
+var StyledSqlEditor = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: row;\n  flex: 1;\n  min-width: 0; // Prevents flex child from overflowing\n  height: 100%;\n"])));
+var StyledEditorPanel = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  background-color: ", ";\n  display: flex;\n  height: 100%;\n  flex-direction: row;\n  gap: 5px;\n  flex-grow: 1;\n"])), sidePanelBg);
+var StyledDataPanel = styled.div(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n  height: 100%;\n  background: white;\n"])));
+var StyledEditor = styled.div(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  display: flex;\n  padding: 12px 12px 12px 0;\n  background-color: rgb(30, 30, 30);\n  opacity: ", ";\n  width: 100%;\n  height: 100%;\n  min-height: 0; // Prevents flex child from overflowing\n"])), function (props) {
+  return props.isRunning ? 0.5 : 1;
+});
+var StyledResultActions = styled.div(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n  background-color: white;\n  padding: 2px 12px;\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  font-size: 12px;\n"])));
+var StyledResizeHandle = styled(PanelResizeHandle)(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n  background-color: ", ";\n  width: 4px;\n  cursor: col-resize;\n\n  &:hover {\n    background-color: #555;\n  }\n"])), panelBorderColor);
+var StyledVerticalResizeHandle = styled(PanelResizeHandle)(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["\n  background-color: ", ";\n  height: 4px;\n  cursor: row-resize;\n\n  &:hover {\n    background-color: #555;\n  }\n"])), panelBorderColor);
+var StyledLoadingContainer = styled.div(_templateObject0 || (_templateObject0 = _taggedTemplateLiteral(["\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  height: 100%;\n"])));
+var StyledErrorContainer = styled.pre(_templateObject1 || (_templateObject1 = _taggedTemplateLiteral(["\n  padding: 12px;\n  color: red;\n  font-size: 12px;\n  background-color: ", ";\n  height: 100%;\n  overflow: auto;\n"])), sidePanelBg);
+var StyledFileDropArea = styled(FileDrop)(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["\n  height: 100%;\n  border-width: 1px;\n  border: 1px ", "\n    ", ";\n  .file-drop-target {\n    height: 100%;\n  }\n"])), function (props) {
+  return props.dragOver ? 'solid' : 'dashed';
+}, function (props) {
+  return props.dragOver ? props.theme.subtextColorLT : 'transparent';
+});
+var SCHEMA_PANEL_STYLE = {
+  overflow: 'auto'
+};
+export var SqlPanel = function SqlPanel(_ref) {
+  var _ref$initialSql = _ref.initialSql,
+    initialSql = _ref$initialSql === void 0 ? '' : _ref$initialSql;
+  var _useState = useState(function () {
+      var params = new URLSearchParams(window.location.search);
+      return params.get('sql') || initialSql;
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    sql = _useState2[0],
+    setSql = _useState2[1];
+  var _useState3 = useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    droppedFile = _useState4[0],
+    setDroppedFile = _useState4[1];
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    dragState = _useState6[0],
+    setDragState = _useState6[1];
+  var _useState7 = useState(null),
+    _useState8 = _slicedToArray(_useState7, 2),
+    result = _useState8[0],
+    setResult = _useState8[1];
+  var _useState9 = useState(0),
+    _useState0 = _slicedToArray(_useState9, 2),
+    schemaUpdateTrigger = _useState0[0],
+    setSchemaUpdateTrigger = _useState0[1];
+  var _useState1 = useState(null),
+    _useState10 = _slicedToArray(_useState1, 2),
+    error = _useState10[0],
+    setError = _useState10[1];
+  var _useState11 = useState(0),
+    _useState12 = _slicedToArray(_useState11, 2),
+    counter = _useState12[0],
+    setCounter = _useState12[1];
+  var _useState13 = useState([]),
+    _useState14 = _slicedToArray(_useState13, 2),
+    tableSchema = _useState14[0],
+    setTableSchema = _useState14[1];
+  var _useState15 = useState(false),
+    _useState16 = _slicedToArray(_useState15, 2),
+    isRunning = _useState16[0],
+    setIsRunning = _useState16[1];
+  var _useState17 = useState(function () {
+      return isAppleDevice();
+    }),
+    _useState18 = _slicedToArray(_useState17, 1),
+    isMac = _useState18[0];
+  var dispatch = useDispatch();
+  var droppedFileAreaRef = useRef(null);
+  useEffect(function () {
+    var currentUrl = new URL(window.location.href);
+    if (sql) {
+      currentUrl.searchParams.set('sql', sql);
+    } else {
+      currentUrl.searchParams["delete"]('sql');
+    }
+    window.history.replaceState({}, '', currentUrl.toString());
+  }, [sql]);
+  var runQuery = useCallback(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var adjustedQuery, db, connection, tempTableName, sqlStatements, arrowResult, tableDuckDBTypes, _iterator, _step, statement, isLastQuery, duckDbColumns, _adjustedQuery;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          setIsRunning(true);
+          _context.prev = 1;
+          adjustedQuery = sql ? removeSQLComments(sql) : null;
+          if (adjustedQuery) {
+            _context.next = 6;
+            break;
+          }
+          setError(new Error('Query is empty'));
+          return _context.abrupt("return");
+        case 6:
+          db = getApplicationConfig().database;
+          if (db) {
+            _context.next = 10;
+            break;
+          }
+          setError(new Error('The database is not configured properly.'));
+          return _context.abrupt("return");
+        case 10:
+          _context.next = 12;
+          return db.connect();
+        case 12:
+          connection = _context.sent;
+          // TODO find a cheap way to get DuckDb types with a single query to a remote resource - temp table? cte?
+          tempTableName = 'temp_keplergl_table'; // remove comments
+          sqlStatements = splitSqlStatements(adjustedQuery);
+          arrowResult = null;
+          tableDuckDBTypes = {};
+          _iterator = _createForOfIteratorHelper(sqlStatements);
+          _context.prev = 18;
+          _iterator.s();
+        case 20:
+          if ((_step = _iterator.n()).done) {
+            _context.next = 48;
+            break;
+          }
+          statement = _step.value;
+          isLastQuery = statement === sqlStatements[sqlStatements.length - 1];
+          _context.t0 = isLastQuery;
+          if (!_context.t0) {
+            _context.next = 28;
+            break;
+          }
+          _context.next = 27;
+          return checkIsSelectQuery(connection, statement);
+        case 27:
+          _context.t0 = _context.sent;
+        case 28:
+          if (!_context.t0) {
+            _context.next = 44;
+            break;
+          }
+          _context.next = 31;
+          return connection.query("CREATE OR REPLACE TABLE '".concat(tempTableName, "' AS ").concat(statement));
+        case 31:
+          _context.next = 33;
+          return getDuckDBColumnTypes(connection, tempTableName);
+        case 33:
+          duckDbColumns = _context.sent;
+          tableDuckDBTypes = getDuckDBColumnTypesMap(duckDbColumns);
+
+          // 3) cast GEOMETRY columns to WKB and BigInt to double.
+          _adjustedQuery = castDuckDBTypesForKepler(tempTableName, duckDbColumns);
+          _context.next = 38;
+          return connection.query(_adjustedQuery);
+        case 38:
+          arrowResult = _context.sent;
+          // 4) set geoarrow extension for the arrow table as DuckDB doesn't support the geoarrow extension.
+          setGeoArrowWKBExtension(arrowResult, duckDbColumns);
+
+          // 5) remove temp table
+          _context.next = 42;
+          return connection.query("DROP TABLE ".concat(tempTableName, ";"));
+        case 42:
+          _context.next = 46;
+          break;
+        case 44:
+          _context.next = 46;
+          return connection.query(statement);
+        case 46:
+          _context.next = 20;
+          break;
+        case 48:
+          _context.next = 53;
+          break;
+        case 50:
+          _context.prev = 50;
+          _context.t1 = _context["catch"](18);
+          _iterator.e(_context.t1);
+        case 53:
+          _context.prev = 53;
+          _iterator.f();
+          return _context.finish(53);
+        case 56:
+          // Show preview only for the result of the last query
+          if (arrowResult) {
+            setResult({
+              table: arrowResult,
+              tableDuckDBTypes: tableDuckDBTypes
+            });
+            setError(null);
+          }
+          _context.next = 59;
+          return connection.close();
+        case 59:
+          _context.next = 64;
+          break;
+        case 61:
+          _context.prev = 61;
+          _context.t2 = _context["catch"](1);
+          setError(_context.t2);
+        case 64:
+          _context.prev = 64;
+          setIsRunning(false);
+          return _context.finish(64);
+        case 67:
+          // Indicate that there may be a possible change in DuckDB.
+          setSchemaUpdateTrigger(Date.now());
+        case 68:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[1, 61, 64, 67], [18, 50, 53, 56]]);
+  })), [sql]);
+  var onChange = useCallback(function (value) {
+    setSql(value);
+  }, [setSql]);
+  var onAddResultToMap = useCallback(function () {
+    if (!result) return;
+    var keplerFields = arrowSchemaToFields(result.table, result.tableDuckDBTypes);
+    var datasetToAdd = {
+      data: {
+        fields: keplerFields,
+        // TODO type AddDataToMapPayload -> rows -> + arrow.Table
+        rows: result.table
+      },
+      info: {
+        id: generateHashId(),
+        label: "query_result".concat(counter > 0 ? "_".concat(counter) : ''),
+        format: 'arrow'
+      }
+    };
+    dispatch(addDataToMap({
+      datasets: [datasetToAdd]
+    }));
+    setCounter(counter + 1);
+  }, [result, counter, dispatch]);
+  var isValidFileType = useCallback(function (filename) {
+    var fileExt = SUPPORTED_DUCKDB_DROP_EXTENSIONS.find(function (ext) {
+      return filename.endsWith(ext);
+    });
+    return Boolean(fileExt);
+  }, []);
+  var createTableFromDroppedFile = useCallback(/*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(droppedFile) {
+      var _error;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!droppedFile) {
+              _context2.next = 5;
+              break;
+            }
+            _context2.next = 3;
+            return tableFromFile(droppedFile);
+          case 3:
+            _error = _context2.sent;
+            if (_error) {
+              setError(_error);
+            } else {
+              setError(null);
+            }
+          case 5:
+            setDroppedFile(null);
+            setDragState(false);
+          case 7:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    return function (_x) {
+      return _ref3.apply(this, arguments);
+    };
+  }(), []);
+  useEffect(function () {
+    createTableFromDroppedFile(droppedFile);
+  }, [droppedFile, createTableFromDroppedFile]);
+  var handleFileInput = useCallback(function (fileList, event) {
+    if (event) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+    var files = _toConsumableArray(fileList).filter(Boolean);
+    var disableExtensionFilter = false;
+    var filesToLoad = [];
+    var errorFiles = [];
+    var _iterator2 = _createForOfIteratorHelper(files),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var file = _step2.value;
+        if (disableExtensionFilter || isValidFileType(file.name)) {
+          filesToLoad.push(file);
+        } else {
+          errorFiles.push(file.name);
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    if (filesToLoad.length > 0) {
+      setDroppedFile(filesToLoad[0]);
+    } else if (errorFiles.length > 0) {
+      setError(new Error("Unsupported file formats: ".concat(errorFiles.join(', '))));
+    }
+  }, [isValidFileType]);
+  return /*#__PURE__*/React.createElement(StyledSqlPanel, null, /*#__PURE__*/React.createElement(PanelGroup, {
+    direction: "horizontal"
+  }, /*#__PURE__*/React.createElement(Panel, {
+    defaultSize: 20,
+    minSize: 15,
+    style: SCHEMA_PANEL_STYLE,
+    className: "schema-panel"
+  }, /*#__PURE__*/React.createElement(StyledFileDropArea, {
+    dragOver: dragState,
+    onDragOver: function onDragOver() {
+      return setDragState(true);
+    },
+    onDragLeave: function onDragLeave() {
+      return setDragState(false);
+    },
+    frame: droppedFileAreaRef.current || document,
+    onDrop: handleFileInput,
+    className: "file-uploader__file-drop"
+  }, /*#__PURE__*/React.createElement(SchemaPanel, {
+    setTableSchema: setTableSchema,
+    droppedFile: droppedFile,
+    schemaUpdateTrigger: schemaUpdateTrigger
+  }))), /*#__PURE__*/React.createElement(StyledResizeHandle, null), /*#__PURE__*/React.createElement(Panel, {
+    minSize: 40
+  }, /*#__PURE__*/React.createElement(StyledSqlEditor, null, /*#__PURE__*/React.createElement(PanelGroup, {
+    direction: "vertical"
+  }, /*#__PURE__*/React.createElement(Panel, {
+    defaultSize: 30,
+    className: "editor-panel"
+  }, /*#__PURE__*/React.createElement(StyledEditorPanel, null, /*#__PURE__*/React.createElement(StyledSqlActions, null, /*#__PURE__*/React.createElement(IconButton, {
+    "data-tip": true,
+    "data-for": "run-query-tooltip",
+    onClick: runQuery,
+    disabled: isRunning || !sql
+  }, /*#__PURE__*/React.createElement(Icons.Play, {
+    height: "18px"
+  }), /*#__PURE__*/React.createElement(Tooltip, {
+    id: "run-query-tooltip",
+    place: "top",
+    effect: "solid"
+  }, "Run Query (", isMac ? '⌘Enter' : 'Ctrl+Enter', " or Shift+Enter)"))), /*#__PURE__*/React.createElement(StyledEditor, {
+    isRunning: isRunning
+  }, /*#__PURE__*/React.createElement(MonacoEditor, {
+    isReadOnly: isRunning,
+    onRunQuery: runQuery,
+    onChange: onChange,
+    tableSchema: tableSchema,
+    code: sql
+  })))), /*#__PURE__*/React.createElement(StyledVerticalResizeHandle, null), /*#__PURE__*/React.createElement(Panel, {
+    className: "preview-panel"
+  }, isRunning ? /*#__PURE__*/React.createElement(StyledLoadingContainer, null, /*#__PURE__*/React.createElement(LoadingSpinner, null)) : error ? /*#__PURE__*/React.createElement(StyledErrorContainer, null, /*#__PURE__*/React.createElement("div", null, error.message)) : result ? /*#__PURE__*/React.createElement(StyledDataPanel, null, /*#__PURE__*/React.createElement(StyledResultActions, null, /*#__PURE__*/React.createElement(Button, {
+    secondary: true,
+    onClick: onAddResultToMap
+  }, "Add to Map"), /*#__PURE__*/React.createElement("div", null, result.table.numRows, " rows")), /*#__PURE__*/React.createElement(PreviewDataPanel, {
+    result: result,
+    dataTableStyle: {},
+    onAddResultToMap: onAddResultToMap
+  })) : null))))));
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useState","useEffect","useRef","useDispatch","styled","Panel","PanelGroup","PanelResizeHandle","addDataToMap","generateHashId","Button","FileDrop","IconButton","Icons","LoadingSpinner","Tooltip","arrowSchemaToFields","sidePanelBg","panelBorderColor","isAppleDevice","getApplicationConfig","MonacoEditor","SchemaPanel","PreviewDataPanel","castDuckDBTypesForKepler","getDuckDBColumnTypes","getDuckDBColumnTypesMap","setGeoArrowWKBExtension","splitSqlStatements","checkIsSelectQuery","removeSQLComments","tableFromFile","SUPPORTED_DUCKDB_DROP_EXTENSIONS","StyledSqlPanel","div","_templateObject","_taggedTemplateLiteral","StyledSqlActions","_templateObject2","StyledSqlEditor","_templateObject3","StyledEditorPanel","_templateObject4","StyledDataPanel","_templateObject5","StyledEditor","_templateObject6","props","isRunning","StyledResultActions","_templateObject7","StyledResizeHandle","_templateObject8","StyledVerticalResizeHandle","_templateObject9","StyledLoadingContainer","_templateObject0","StyledErrorContainer","pre","_templateObject1","StyledFileDropArea","_templateObject10","dragOver","theme","subtextColorLT","SCHEMA_PANEL_STYLE","overflow","SqlPanel","_ref","_ref$initialSql","initialSql","_useState","params","URLSearchParams","window","location","search","get","_useState2","_slicedToArray","sql","setSql","_useState3","_useState4","droppedFile","setDroppedFile","_useState5","_useState6","dragState","setDragState","_useState7","_useState8","result","setResult","_useState9","_useState0","schemaUpdateTrigger","setSchemaUpdateTrigger","_useState1","_useState10","error","setError","_useState11","_useState12","counter","setCounter","_useState13","_useState14","tableSchema","setTableSchema","_useState15","_useState16","setIsRunning","_useState17","_useState18","isMac","dispatch","droppedFileAreaRef","currentUrl","URL","href","searchParams","set","history","replaceState","toString","runQuery","_asyncToGenerator","_regeneratorRuntime","mark","_callee","adjustedQuery","db","connection","tempTableName","sqlStatements","arrowResult","tableDuckDBTypes","_iterator","_step","statement","isLastQuery","duckDbColumns","_adjustedQuery","wrap","_callee$","_context","prev","next","Error","abrupt","database","connect","sent","_createForOfIteratorHelper","s","n","done","value","length","t0","query","concat","t1","e","f","finish","table","close","t2","Date","now","stop","onChange","onAddResultToMap","keplerFields","datasetToAdd","data","fields","rows","info","id","label","format","datasets","isValidFileType","filename","fileExt","find","ext","endsWith","Boolean","createTableFromDroppedFile","_ref3","_callee2","_error","_callee2$","_context2","_x","apply","arguments","handleFileInput","fileList","event","preventDefault","stopPropagation","files","_toConsumableArray","filter","disableExtensionFilter","filesToLoad","errorFiles","_iterator2","_step2","file","name","push","err","join","createElement","direction","defaultSize","minSize","style","className","onDragOver","onDragLeave","frame","current","document","onDrop","onClick","disabled","Play","height","place","effect","isReadOnly","onRunQuery","code","message","secondary","numRows","dataTableStyle"],"sources":["../../../src/components/sql-panel.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport * as arrow from 'apache-arrow';\nimport React, {useCallback, useState, useEffect, useRef} from 'react';\nimport {useDispatch} from 'react-redux';\nimport styled from 'styled-components';\nimport {Panel, PanelGroup, PanelResizeHandle} from 'react-resizable-panels';\n\nimport {addDataToMap} from '@kepler.gl/actions';\nimport {generateHashId} from '@kepler.gl/common-utils';\nimport {Button, FileDrop, IconButton, Icons, LoadingSpinner, Tooltip} from '@kepler.gl/components';\nimport {arrowSchemaToFields} from '@kepler.gl/processors';\nimport {sidePanelBg, panelBorderColor} from '@kepler.gl/styles';\nimport {isAppleDevice, getApplicationConfig} from '@kepler.gl/utils';\n\nimport MonacoEditor from './monaco-editor';\nimport {SchemaPanel, SchemaSuggestion} from './schema-panel';\nimport {PreviewDataPanel, QueryResult} from './preview-data-panel';\n\nimport {\n  castDuckDBTypesForKepler,\n  getDuckDBColumnTypes,\n  getDuckDBColumnTypesMap,\n  setGeoArrowWKBExtension,\n  splitSqlStatements,\n  checkIsSelectQuery,\n  removeSQLComments,\n  tableFromFile,\n  SUPPORTED_DUCKDB_DROP_EXTENSIONS\n} from '../table/duckdb-table-utils';\n\nconst StyledSqlPanel = styled.div`\n  display: flex;\n  height: 100%;\n  background-color: ${sidePanelBg};\n  border-left: 1px solid #333;\n`;\n\nconst StyledSqlActions = styled.div`\n  flex: 0 0 50px;\n  display: flex;\n  padding-top: 12px;\n  align-items: center;\n  flex-direction: column;\n  justify-content: flex-start;\n  border-bottom: 1px solid #333;\n`;\n\nconst StyledSqlEditor = styled.div`\n  display: flex;\n  flex-direction: row;\n  flex: 1;\n  min-width: 0; // Prevents flex child from overflowing\n  height: 100%;\n`;\n\nconst StyledEditorPanel = styled.div`\n  background-color: ${sidePanelBg};\n  display: flex;\n  height: 100%;\n  flex-direction: row;\n  gap: 5px;\n  flex-grow: 1;\n`;\n\nconst StyledDataPanel = styled.div`\n  display: flex;\n  flex-direction: column;\n  height: 100%;\n  background: white;\n`;\n\nconst StyledEditor = styled.div<{isRunning: boolean}>`\n  display: flex;\n  padding: 12px 12px 12px 0;\n  background-color: rgb(30, 30, 30);\n  opacity: ${props => (props.isRunning ? 0.5 : 1)};\n  width: 100%;\n  height: 100%;\n  min-height: 0; // Prevents flex child from overflowing\n`;\n\nconst StyledResultActions = styled.div`\n  background-color: white;\n  padding: 2px 12px;\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  font-size: 12px;\n`;\n\nconst StyledResizeHandle = styled(PanelResizeHandle)`\n  background-color: ${panelBorderColor};\n  width: 4px;\n  cursor: col-resize;\n\n  &:hover {\n    background-color: #555;\n  }\n`;\n\nconst StyledVerticalResizeHandle = styled(PanelResizeHandle)`\n  background-color: ${panelBorderColor};\n  height: 4px;\n  cursor: row-resize;\n\n  &:hover {\n    background-color: #555;\n  }\n`;\n\nconst StyledLoadingContainer = styled.div`\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  height: 100%;\n`;\n\nconst StyledErrorContainer = styled.pre`\n  padding: 12px;\n  color: red;\n  font-size: 12px;\n  background-color: ${sidePanelBg};\n  height: 100%;\n  overflow: auto;\n`;\n\ninterface StyledDragPanelProps {\n  dragOver?: boolean;\n}\n\nconst StyledFileDropArea = styled(FileDrop)<StyledDragPanelProps>`\n  height: 100%;\n  border-width: 1px;\n  border: 1px ${props => (props.dragOver ? 'solid' : 'dashed')}\n    ${props => (props.dragOver ? props.theme.subtextColorLT : 'transparent')};\n  .file-drop-target {\n    height: 100%;\n  }\n`;\n\ntype SqlPanelProps = {\n  initialSql?: string;\n};\n\nconst SCHEMA_PANEL_STYLE = {overflow: 'auto'};\n\nexport const SqlPanel: React.FC<SqlPanelProps> = ({initialSql = ''}) => {\n  const [sql, setSql] = useState(() => {\n    const params = new URLSearchParams(window.location.search);\n    return params.get('sql') || initialSql;\n  });\n  const [droppedFile, setDroppedFile] = useState<File | null>(null);\n  const [dragState, setDragState] = useState(false);\n  const [result, setResult] = useState<null | QueryResult>(null);\n  const [schemaUpdateTrigger, setSchemaUpdateTrigger] = useState<number>(0);\n  const [error, setError] = useState<Error | null>(null);\n  const [counter, setCounter] = useState(0);\n  const [tableSchema, setTableSchema] = useState<SchemaSuggestion[]>([]);\n  const [isRunning, setIsRunning] = useState(false);\n  const [isMac] = useState(() => isAppleDevice());\n  const dispatch = useDispatch();\n\n  const droppedFileAreaRef = useRef(null);\n\n  useEffect(() => {\n    const currentUrl = new URL(window.location.href);\n    if (sql) {\n      currentUrl.searchParams.set('sql', sql);\n    } else {\n      currentUrl.searchParams.delete('sql');\n    }\n    window.history.replaceState({}, '', currentUrl.toString());\n  }, [sql]);\n\n  const runQuery = useCallback(async () => {\n    setIsRunning(true);\n    try {\n      const adjustedQuery = sql ? removeSQLComments(sql) : null;\n      if (!adjustedQuery) {\n        setError(new Error('Query is empty'));\n        return;\n      }\n\n      const db = getApplicationConfig().database;\n      if (!db) {\n        setError(new Error('The database is not configured properly.'));\n        return;\n      }\n      const connection = await db.connect();\n\n      // TODO find a cheap way to get DuckDb types with a single query to a remote resource - temp table? cte?\n      const tempTableName = 'temp_keplergl_table';\n\n      // remove comments\n      const sqlStatements = splitSqlStatements(adjustedQuery);\n\n      let arrowResult: arrow.Table | null = null;\n      let tableDuckDBTypes = {};\n\n      for (const statement of sqlStatements) {\n        const isLastQuery = statement === sqlStatements[sqlStatements.length - 1];\n        if (isLastQuery && (await checkIsSelectQuery(connection, statement))) {\n          // 1) create temp table from the original query.\n          await connection.query(`CREATE OR REPLACE TABLE '${tempTableName}' AS ${statement}`);\n\n          // 2) query duckdb types and detect candidate columns for ST_asWKB transform.\n          const duckDbColumns = await getDuckDBColumnTypes(connection, tempTableName);\n          tableDuckDBTypes = getDuckDBColumnTypesMap(duckDbColumns);\n\n          // 3) cast GEOMETRY columns to WKB and BigInt to double.\n          const adjustedQuery = castDuckDBTypesForKepler(tempTableName, duckDbColumns);\n          arrowResult = await connection.query(adjustedQuery);\n\n          // 4) set geoarrow extension for the arrow table as DuckDB doesn't support the geoarrow extension.\n          setGeoArrowWKBExtension(arrowResult, duckDbColumns);\n\n          // 5) remove temp table\n          await connection.query(`DROP TABLE ${tempTableName};`);\n        } else {\n          await connection.query(statement);\n        }\n      }\n\n      // Show preview only for the result of the last query\n      if (arrowResult) {\n        setResult({table: arrowResult, tableDuckDBTypes});\n        setError(null);\n      }\n\n      await connection.close();\n    } catch (e) {\n      setError(e as Error);\n    } finally {\n      setIsRunning(false);\n    }\n\n    // Indicate that there may be a possible change in DuckDB.\n    setSchemaUpdateTrigger(Date.now());\n  }, [sql]);\n\n  const onChange = useCallback(\n    value => {\n      setSql(value);\n    },\n    [setSql]\n  );\n\n  const onAddResultToMap = useCallback(() => {\n    if (!result) return;\n\n    const keplerFields = arrowSchemaToFields(result.table, result.tableDuckDBTypes);\n\n    const datasetToAdd = {\n      data: {\n        fields: keplerFields,\n        // TODO type AddDataToMapPayload -> rows -> + arrow.Table\n        rows: result.table as any\n      },\n      info: {\n        id: generateHashId(),\n        label: `query_result${counter > 0 ? `_${counter}` : ''}`,\n        format: 'arrow'\n      }\n    };\n\n    dispatch(addDataToMap({datasets: [datasetToAdd]}));\n    setCounter(counter + 1);\n  }, [result, counter, dispatch]);\n\n  const isValidFileType = useCallback(filename => {\n    const fileExt = SUPPORTED_DUCKDB_DROP_EXTENSIONS.find(ext => filename.endsWith(ext));\n    return Boolean(fileExt);\n  }, []);\n\n  const createTableFromDroppedFile = useCallback(async (droppedFile: File | null) => {\n    if (droppedFile) {\n      const error = await tableFromFile(droppedFile);\n      if (error) {\n        setError(error);\n      } else {\n        setError(null);\n      }\n    }\n\n    setDroppedFile(null);\n    setDragState(false);\n  }, []);\n\n  useEffect(() => {\n    createTableFromDroppedFile(droppedFile);\n  }, [droppedFile, createTableFromDroppedFile]);\n\n  const handleFileInput = useCallback(\n    (fileList: FileList, event: DragEvent) => {\n      if (event) {\n        event.preventDefault();\n        event.stopPropagation();\n      }\n\n      const files = [...fileList].filter(Boolean);\n\n      const disableExtensionFilter = false;\n\n      const filesToLoad: File[] = [];\n      const errorFiles: string[] = [];\n      for (const file of files) {\n        if (disableExtensionFilter || isValidFileType(file.name)) {\n          filesToLoad.push(file);\n        } else {\n          errorFiles.push(file.name);\n        }\n      }\n\n      if (filesToLoad.length > 0) {\n        setDroppedFile(filesToLoad[0]);\n      } else if (errorFiles.length > 0) {\n        setError(new Error(`Unsupported file formats: ${errorFiles.join(', ')}`));\n      }\n    },\n    [isValidFileType]\n  );\n\n  return (\n    <StyledSqlPanel>\n      <PanelGroup direction=\"horizontal\">\n        <Panel defaultSize={20} minSize={15} style={SCHEMA_PANEL_STYLE} className=\"schema-panel\">\n          <StyledFileDropArea\n            dragOver={dragState}\n            onDragOver={() => setDragState(true)}\n            onDragLeave={() => setDragState(false)}\n            frame={droppedFileAreaRef.current || document}\n            onDrop={handleFileInput}\n            className=\"file-uploader__file-drop\"\n          >\n            <SchemaPanel\n              setTableSchema={setTableSchema}\n              droppedFile={droppedFile}\n              schemaUpdateTrigger={schemaUpdateTrigger}\n            />\n          </StyledFileDropArea>\n        </Panel>\n\n        <StyledResizeHandle />\n\n        <Panel minSize={40}>\n          <StyledSqlEditor>\n            <PanelGroup direction=\"vertical\">\n              <Panel defaultSize={30} className=\"editor-panel\">\n                <StyledEditorPanel>\n                  <StyledSqlActions>\n                    <IconButton\n                      data-tip\n                      data-for=\"run-query-tooltip\"\n                      onClick={runQuery}\n                      disabled={isRunning || !sql}\n                    >\n                      <Icons.Play height=\"18px\" />\n                      <Tooltip id=\"run-query-tooltip\" place=\"top\" effect=\"solid\">\n                        Run Query ({isMac ? '⌘Enter' : 'Ctrl+Enter'} or Shift+Enter)\n                      </Tooltip>\n                    </IconButton>\n                  </StyledSqlActions>\n                  <StyledEditor isRunning={isRunning}>\n                    <MonacoEditor\n                      isReadOnly={isRunning}\n                      onRunQuery={runQuery}\n                      onChange={onChange}\n                      tableSchema={tableSchema}\n                      code={sql}\n                    />\n                  </StyledEditor>\n                </StyledEditorPanel>\n              </Panel>\n\n              <StyledVerticalResizeHandle />\n              <Panel className=\"preview-panel\">\n                {isRunning ? (\n                  <StyledLoadingContainer>\n                    <LoadingSpinner />\n                  </StyledLoadingContainer>\n                ) : error ? (\n                  <StyledErrorContainer>\n                    <div>{error.message}</div>\n                  </StyledErrorContainer>\n                ) : result ? (\n                  <StyledDataPanel>\n                    <StyledResultActions>\n                      <Button secondary onClick={onAddResultToMap}>\n                        Add to Map\n                      </Button>\n                      <div>{result.table.numRows} rows</div>\n                    </StyledResultActions>\n                    <PreviewDataPanel\n                      result={result}\n                      dataTableStyle={{}}\n                      onAddResultToMap={onAddResultToMap}\n                    />\n                  </StyledDataPanel>\n                ) : null}\n              </Panel>\n            </PanelGroup>\n          </StyledSqlEditor>\n        </Panel>\n      </PanelGroup>\n    </StyledSqlPanel>\n  );\n};\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/components/tree.js

@@ -0,0 +1,82 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { Collapsible, CollapsibleTrigger, CollapsibleContent } from '@radix-ui/react-collapsible';
+import styled from 'styled-components';
+import React, { useEffect, useState } from 'react';
+import classNames from 'classnames';
+import { Icons, FieldToken } from '@kepler.gl/components';
+// TODO: consider using react-vtree/react-window for virtualization
+
+/**
+ * Component that renders a generic tree.
+ * @param treeData - The tree data.
+ * @param renderNode - A function that renders a tree node.
+ */
+export function Tree(props) {
+  var treeData = props.treeData,
+    renderNode = props.renderNode;
+  return /*#__PURE__*/React.createElement("div", {
+    className: "flex flex-col"
+  }, /*#__PURE__*/React.createElement(TreeNode, {
+    treeData: treeData,
+    renderNode: renderNode
+  }));
+}
+var StyledCollapsibleTriggerContent = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  width: 100%;\n  cursor: pointer;\n  align-items: center;\n"])));
+/**
+ * Component that renders a tree node.
+ */
+function TreeNode(props) {
+  var treeData = props.treeData,
+    renderNode = props.renderNode;
+  var children = treeData.children;
+  var _useState = useState(Boolean(treeData.isOpen)),
+    _useState2 = _slicedToArray(_useState, 2),
+    isOpen = _useState2[0],
+    setIsOpen = _useState2[1];
+  useEffect(function () {
+    setIsOpen(Boolean(treeData.isOpen));
+  }, [treeData.isOpen]);
+  if (!children) {
+    return renderNode(treeData, isOpen);
+  }
+  return /*#__PURE__*/React.createElement(Collapsible, {
+    open: isOpen,
+    onOpenChange: setIsOpen
+  }, /*#__PURE__*/React.createElement(CollapsibleTrigger, {
+    className: "w-full",
+    asChild: true
+  }, /*#__PURE__*/React.createElement(StyledCollapsibleTriggerContent, null, /*#__PURE__*/React.createElement(Icons.ArrowRight, {
+    className: classNames('flex-shrink-0 text-gray-500', {
+      'rotate-90 transform': isOpen
+    }),
+    height: "18px"
+  }), renderNode(treeData, isOpen))), /*#__PURE__*/React.createElement(CollapsibleContent, {
+    className: "pl-4"
+  }, isOpen ? children.map(function (child) {
+    return /*#__PURE__*/React.createElement(TreeNode, {
+      key: child.key,
+      treeData: child,
+      renderNode: renderNode
+    });
+  }) : null));
+}
+var StyledDatasetNode = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  font-weight: bold;\n"])));
+export var DatasetNode = function DatasetNode(_ref) {
+  var node = _ref.node;
+  return /*#__PURE__*/React.createElement(StyledDatasetNode, null, node.object.tableName);
+};
+var StyledColumnNode = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  padding: 4px 0;\n  margin-left: 16px;\n\n  .column-name {\n    margin-left: 8px;\n  }\n"])));
+export var ColumnNode = function ColumnNode(_ref2) {
+  var node = _ref2.node;
+  return /*#__PURE__*/React.createElement(StyledColumnNode, null, /*#__PURE__*/React.createElement(FieldToken, {
+    type: node.object.fieldType
+  }), /*#__PURE__*/React.createElement("div", {
+    className: "column-name"
+  }, node.object.name));
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Collapsible","CollapsibleTrigger","CollapsibleContent","styled","React","useEffect","useState","classNames","Icons","FieldToken","Tree","props","treeData","renderNode","createElement","className","TreeNode","StyledCollapsibleTriggerContent","div","_templateObject","_taggedTemplateLiteral","children","_useState","Boolean","isOpen","_useState2","_slicedToArray","setIsOpen","open","onOpenChange","asChild","ArrowRight","height","map","child","key","StyledDatasetNode","_templateObject2","DatasetNode","_ref","node","object","tableName","StyledColumnNode","_templateObject3","ColumnNode","_ref2","type","fieldType","name"],"sources":["../../../src/components/tree.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {Collapsible, CollapsibleTrigger, CollapsibleContent} from '@radix-ui/react-collapsible';\nimport styled from 'styled-components';\nimport React, {useEffect, useState} from 'react';\nimport classNames from 'classnames';\n\nimport {Icons, FieldToken} from '@kepler.gl/components';\n\nexport type TreeNodeData<T> = {\n  key: string;\n  object: T;\n  children?: TreeNodeData<T>[];\n  isOpen?: boolean;\n};\n\nexport type TreeProps<T> = {\n  className?: string;\n  treeData: TreeNodeData<T>;\n  renderNode: TreeNodeProps<T>['renderNode'];\n};\n\n// TODO: consider using react-vtree/react-window for virtualization\n\n/**\n * Component that renders a generic tree.\n * @param treeData - The tree data.\n * @param renderNode - A function that renders a tree node.\n */\nexport function Tree<T>(props: TreeProps<T>): React.ReactElement {\n  const {treeData, renderNode} = props;\n  return (\n    <div className=\"flex flex-col\">\n      <TreeNode<T> treeData={treeData} renderNode={renderNode} />\n    </div>\n  );\n}\n\nexport type TreeNodeProps<T> = {\n  treeData: TreeNodeData<T>;\n  renderNode: (node: TreeNodeData<T>, isOpen: boolean) => JSX.Element | null;\n};\n\nconst StyledCollapsibleTriggerContent = styled.div`\n  display: flex;\n  width: 100%;\n  cursor: pointer;\n  align-items: center;\n`;\n/**\n * Component that renders a tree node.\n */\nfunction TreeNode<T>(props: TreeNodeProps<T>): JSX.Element | null {\n  const {treeData, renderNode} = props;\n  const {children} = treeData;\n  const [isOpen, setIsOpen] = useState(Boolean(treeData.isOpen));\n  useEffect(() => {\n    setIsOpen(Boolean(treeData.isOpen));\n  }, [treeData.isOpen]);\n  if (!children) {\n    return renderNode(treeData, isOpen);\n  }\n  return (\n    <Collapsible open={isOpen} onOpenChange={setIsOpen}>\n      <CollapsibleTrigger className=\"w-full\" asChild>\n        <StyledCollapsibleTriggerContent>\n          <Icons.ArrowRight\n            className={classNames('flex-shrink-0 text-gray-500', {'rotate-90 transform': isOpen})}\n            height=\"18px\"\n          />\n          {renderNode(treeData, isOpen)}\n        </StyledCollapsibleTriggerContent>\n      </CollapsibleTrigger>\n      <CollapsibleContent className=\"pl-4\">\n        {isOpen\n          ? children.map(child => (\n              <TreeNode<T> key={child.key} treeData={child} renderNode={renderNode} />\n            ))\n          : null}\n      </CollapsibleContent>\n    </Collapsible>\n  );\n}\n\nconst StyledDatasetNode = styled.div`\n  font-weight: bold;\n`;\n\nexport const DatasetNode = ({node}) => {\n  return <StyledDatasetNode>{node.object.tableName}</StyledDatasetNode>;\n};\n\nconst StyledColumnNode = styled.div`\n  display: flex;\n  align-items: center;\n  padding: 4px 0;\n  margin-left: 16px;\n\n  .column-name {\n    margin-left: 8px;\n  }\n`;\nexport const ColumnNode = ({node}) => {\n  return (\n    <StyledColumnNode>\n      <FieldToken type={node.object.fieldType} />\n      <div className=\"column-name\">{node.object.name}</div>\n    </StyledColumnNode>\n  );\n};\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/index.js

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+export { DuckDBWasmAdapter } from './adapters/duckdb-wasm-adapter';
+export { keplerGlDuckDBPlugin, keplerGlDuckDBPlugin as default } from './plugin';
+export * from './table/duckdb-table';
+export * from './table/duckdb-table-utils';
+export * from './processors/data-processor';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJEdWNrREJXYXNtQWRhcHRlciIsImtlcGxlckdsRHVja0RCUGx1Z2luIiwiZGVmYXVsdCJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5leHBvcnQge0R1Y2tEQldhc21BZGFwdGVyfSBmcm9tICcuL2FkYXB0ZXJzL2R1Y2tkYi13YXNtLWFkYXB0ZXInO1xuZXhwb3J0IHtrZXBsZXJHbER1Y2tEQlBsdWdpbiwga2VwbGVyR2xEdWNrREJQbHVnaW4gYXMgZGVmYXVsdH0gZnJvbSAnLi9wbHVnaW4nO1xuZXhwb3J0ICogZnJvbSAnLi90YWJsZS9kdWNrZGItdGFibGUnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJsZS9kdWNrZGItdGFibGUtdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9wcm9jZXNzb3JzL2RhdGEtcHJvY2Vzc29yJztcbiJdLCJtYXBwaW5ncyI6IkFBQUE7QUFDQTs7QUFFQSxTQUFRQSxpQkFBaUIsUUFBTyxnQ0FBZ0M7QUFDaEUsU0FBUUMsb0JBQW9CLEVBQUVBLG9CQUFvQixJQUFJQyxPQUFPLFFBQU8sVUFBVTtBQUM5RSxjQUFjLHNCQUFzQjtBQUNwQyxjQUFjLDRCQUE0QjtBQUMxQyxjQUFjLDZCQUE2QiIsImlnbm9yZUxpc3QiOltdfQ==

package/dist/esm/plugin.js

@@ -0,0 +1,22 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+export var keplerGlDuckDBPlugin = {
+  name: 'duckdb',
+  init: function init() {
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            console.log('kepler.gl DuckDB Plugin initialized');
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJrZXBsZXJHbER1Y2tEQlBsdWdpbiIsIm5hbWUiLCJpbml0IiwiX2FzeW5jVG9HZW5lcmF0b3IiLCJfcmVnZW5lcmF0b3JSdW50aW1lIiwibWFyayIsIl9jYWxsZWUiLCJ3cmFwIiwiX2NhbGxlZSQiLCJfY29udGV4dCIsInByZXYiLCJuZXh0IiwiY29uc29sZSIsImxvZyIsInN0b3AiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvcGx1Z2luLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbmV4cG9ydCBjb25zdCBrZXBsZXJHbER1Y2tEQlBsdWdpbiA9IHtcbiAgbmFtZTogJ2R1Y2tkYicsXG4gIGFzeW5jIGluaXQoKSB7XG4gICAgY29uc29sZS5sb2coJ2tlcGxlci5nbCBEdWNrREIgUGx1Z2luIGluaXRpYWxpemVkJyk7XG4gIH1cbn07XG4iXSwibWFwcGluZ3MiOiI7O0FBQUE7QUFDQTs7QUFFQSxPQUFPLElBQU1BLG9CQUFvQixHQUFHO0VBQ2xDQyxJQUFJLEVBQUUsUUFBUTtFQUNSQyxJQUFJLFdBQUpBLElBQUlBLENBQUEsRUFBRztJQUFBLE9BQUFDLGlCQUFBLGNBQUFDLG1CQUFBLENBQUFDLElBQUEsVUFBQUMsUUFBQTtNQUFBLE9BQUFGLG1CQUFBLENBQUFHLElBQUEsVUFBQUMsU0FBQUMsUUFBQTtRQUFBLGtCQUFBQSxRQUFBLENBQUFDLElBQUEsR0FBQUQsUUFBQSxDQUFBRSxJQUFBO1VBQUE7WUFDWEMsT0FBTyxDQUFDQyxHQUFHLENBQUMscUNBQXFDLENBQUM7VUFBQztVQUFBO1lBQUEsT0FBQUosUUFBQSxDQUFBSyxJQUFBO1FBQUE7TUFBQSxHQUFBUixPQUFBO0lBQUE7RUFDckQ7QUFDRixDQUFDIiwiaWdub3JlTGlzdCI6W119