@kepler.gl/mcp 0.0.0-stage → 3.3.0-alpha.20

package/dist/esm/commands/split-view-command.js

@@ -0,0 +1,255 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+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 { z } from 'zod';
+import { toggleSplitMap, toggleLayerForMap } from '@kepler.gl/actions';
+var sleep = function sleep(ms) {
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, ms);
+  });
+};
+export var splitViewCommandId = 'map.split-view';
+export function getSplitViewCommand(ctx) {
+  return {
+    id: splitViewCommandId,
+    name: 'Toggle split map view',
+    group: 'Map',
+    description: "Enable or disable the dual-map (split view) comparison mode.\n\nWhen enabled, the map splits into two panels for side-by-side comparison. Pass layerIdsForMap0 / layerIdsForMap1 to assign which layers show ONLY in the left / right panel; without these, all layers show on both panels (no comparison).\n\nWhen disabled, the map returns to a single panel.\n\nUse the SAME colorBy / colorType for the layers being compared, so the comparison is fair.",
+    metadata: {
+      readOnly: false,
+      riskLevel: 'low',
+      idempotent: true
+    },
+    inputSchema: z.object({
+      action: z["enum"](['enable', 'disable']).describe('"enable" activates dual map mode; "disable" returns to a single map.'),
+      layerIdsForMap0: z.array(z.string()).optional().describe('Layer IDs to show ONLY in the LEFT panel. Layers not listed are hidden from the left panel.'),
+      layerIdsForMap1: z.array(z.string()).optional().describe('Layer IDs to show ONLY in the RIGHT panel. Layers not listed are hidden from the right panel.')
+    }),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_execCtx, input) {
+        var _ref, action, layerIdsForMap0, layerIdsForMap1, _iterator, _step, _step$value, name, _ids, visState, isSplit, hasLayerAssignment, updatedVis, splitMaps, allLayers, allLayerIds, allLayerIdSet, _iterator2, _step2, _step2$value, panel, ids, unknown, _splitMaps$, map0Layers, desiredSet0, _iterator3, _step3, layerId, isVisible, shouldBeVisible, _freshSplitMaps$, freshSplitMaps, map1Layers, desiredSet1, _iterator4, _step4, _layerId, _isVisible, _shouldBeVisible, finalVis, layers;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _ref = input !== null && input !== void 0 ? input : {}, action = _ref.action, layerIdsForMap0 = _ref.layerIdsForMap0, layerIdsForMap1 = _ref.layerIdsForMap1;
+              _context.prev = 1;
+              if (!(action !== 'enable' && action !== 'disable')) {
+                _context.next = 4;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: splitViewCommandId,
+                error: "Invalid action \"".concat(String(action), "\". Must be \"enable\" or \"disable\"."),
+                data: {
+                  instruction: 'Pass action: "enable" to activate dual map mode, or "disable" to return to a single map.'
+                }
+              });
+            case 4:
+              // Runtime guard: the bridge/webMCP call execute without zod parsing, so
+              // a string/object passed as layerIdsForMap0/1 must not be treated as
+              // iterable (`.length`, `.filter`) and produce surprising layer toggles.
+              // Reject non-array or non-string entries when these fields are provided.
+              _iterator = _createForOfIteratorHelper([['layerIdsForMap0', layerIdsForMap0], ['layerIdsForMap1', layerIdsForMap1]]);
+              _context.prev = 5;
+              _iterator.s();
+            case 7:
+              if ((_step = _iterator.n()).done) {
+                _context.next = 13;
+                break;
+              }
+              _step$value = _slicedToArray(_step.value, 2), name = _step$value[0], _ids = _step$value[1];
+              if (!(_ids !== undefined && (!Array.isArray(_ids) || _ids.some(function (id) {
+                return typeof id !== 'string' || id.length === 0;
+              })))) {
+                _context.next = 11;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: splitViewCommandId,
+                error: "Invalid ".concat(name, ". Must be an array of non-empty layer id strings."),
+                data: {
+                  instruction: "Pass ".concat(name, " as an array of layer id strings, or omit it to show all layers on that panel.")
+                }
+              });
+            case 11:
+              _context.next = 7;
+              break;
+            case 13:
+              _context.next = 18;
+              break;
+            case 15:
+              _context.prev = 15;
+              _context.t0 = _context["catch"](5);
+              _iterator.e(_context.t0);
+            case 18:
+              _context.prev = 18;
+              _iterator.f();
+              return _context.finish(18);
+            case 21:
+              visState = ctx.getVisState();
+              isSplit = visState.splitMaps && visState.splitMaps.length > 1;
+              if (!(action === 'disable')) {
+                _context.next = 26;
+                break;
+              }
+              if (isSplit) {
+                // Close the RIGHT panel (index 1) so the LEFT panel (map0) survives:
+                // `closeSpecificMapAtIndex` keeps `1 - payload`, so closing 0 would
+                // keep the right panel and flip layer visibility to map1's config.
+                ctx.dispatch(toggleSplitMap(1));
+              }
+              return _context.abrupt("return", {
+                success: true,
+                commandId: splitViewCommandId,
+                data: {
+                  details: 'Split map view disabled. Returned to single map view.'
+                }
+              });
+            case 26:
+              // enable
+              if (!isSplit) {
+                ctx.dispatch(toggleSplitMap(0));
+              }
+              hasLayerAssignment = layerIdsForMap0 && layerIdsForMap0.length > 0 || layerIdsForMap1 && layerIdsForMap1.length > 0;
+              if (!hasLayerAssignment) {
+                _context.next = 58;
+                break;
+              }
+              _context.next = 31;
+              return sleep(200);
+            case 31:
+              updatedVis = ctx.getVisState();
+              splitMaps = updatedVis.splitMaps;
+              if (!(splitMaps && splitMaps.length > 1)) {
+                _context.next = 58;
+                break;
+              }
+              allLayers = updatedVis.layers || [];
+              allLayerIds = allLayers.map(function (l) {
+                return l.id;
+              }); // Fail fast on unknown layer ids — silently ignoring them would
+              // hide every real layer not listed and produce an unexpected blank
+              // panel.
+              allLayerIdSet = new Set(allLayerIds);
+              _iterator2 = _createForOfIteratorHelper([['left (map0)', layerIdsForMap0], ['right (map1)', layerIdsForMap1]]);
+              _context.prev = 38;
+              _iterator2.s();
+            case 40:
+              if ((_step2 = _iterator2.n()).done) {
+                _context.next = 48;
+                break;
+              }
+              _step2$value = _slicedToArray(_step2.value, 2), panel = _step2$value[0], ids = _step2$value[1];
+              if (!(ids && ids.length > 0)) {
+                _context.next = 46;
+                break;
+              }
+              unknown = ids.filter(function (id) {
+                return !allLayerIdSet.has(id);
+              });
+              if (!(unknown.length > 0)) {
+                _context.next = 46;
+                break;
+              }
+              throw new Error("Unknown layer id(s) for the ".concat(panel, " panel: ").concat(unknown.join(', '), ". ") + "Available layer ids: ".concat(allLayerIds.join(', ')));
+            case 46:
+              _context.next = 40;
+              break;
+            case 48:
+              _context.next = 53;
+              break;
+            case 50:
+              _context.prev = 50;
+              _context.t1 = _context["catch"](38);
+              _iterator2.e(_context.t1);
+            case 53:
+              _context.prev = 53;
+              _iterator2.f();
+              return _context.finish(53);
+            case 56:
+              if (layerIdsForMap0 && layerIdsForMap0.length > 0) {
+                map0Layers = ((_splitMaps$ = splitMaps[0]) === null || _splitMaps$ === void 0 ? void 0 : _splitMaps$.layers) || {};
+                desiredSet0 = new Set(layerIdsForMap0);
+                _iterator3 = _createForOfIteratorHelper(allLayerIds);
+                try {
+                  for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                    layerId = _step3.value;
+                    // Coerce to boolean: a missing entry means "hidden", and
+                    // `toggleLayerForMapUpdater` toggles missing entries to visible.
+                    isVisible = Boolean(map0Layers[layerId]);
+                    shouldBeVisible = desiredSet0.has(layerId);
+                    if (isVisible !== shouldBeVisible) {
+                      ctx.dispatch(toggleLayerForMap(0, layerId));
+                    }
+                  }
+                } catch (err) {
+                  _iterator3.e(err);
+                } finally {
+                  _iterator3.f();
+                }
+              }
+              if (layerIdsForMap1 && layerIdsForMap1.length > 0) {
+                freshSplitMaps = ctx.getVisState().splitMaps;
+                map1Layers = (freshSplitMaps === null || freshSplitMaps === void 0 || (_freshSplitMaps$ = freshSplitMaps[1]) === null || _freshSplitMaps$ === void 0 ? void 0 : _freshSplitMaps$.layers) || {};
+                desiredSet1 = new Set(layerIdsForMap1);
+                _iterator4 = _createForOfIteratorHelper(allLayerIds);
+                try {
+                  for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                    _layerId = _step4.value;
+                    // Coerce to boolean: a missing entry means "hidden", and
+                    // `toggleLayerForMapUpdater` toggles missing entries to visible.
+                    _isVisible = Boolean(map1Layers[_layerId]);
+                    _shouldBeVisible = desiredSet1.has(_layerId);
+                    if (_isVisible !== _shouldBeVisible) {
+                      ctx.dispatch(toggleLayerForMap(1, _layerId));
+                    }
+                  }
+                } catch (err) {
+                  _iterator4.e(err);
+                } finally {
+                  _iterator4.f();
+                }
+              }
+            case 58:
+              finalVis = ctx.getVisState();
+              layers = finalVis.layers || [];
+              return _context.abrupt("return", {
+                success: true,
+                commandId: splitViewCommandId,
+                data: {
+                  details: "Split map view enabled. ".concat(layers.length, " layer(s) available.").concat(hasLayerAssignment ? " Left panel: ".concat((layerIdsForMap0 || []).length, " layer(s), Right panel: ").concat((layerIdsForMap1 || []).length, " layer(s).") : ' All layers visible on both panels. Provide layerIdsForMap0/layerIdsForMap1 to assign layers to each panel.')
+                }
+              });
+            case 63:
+              _context.prev = 63;
+              _context.t2 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: splitViewCommandId,
+                error: _context.t2 instanceof Error ? _context.t2.message : 'Unknown error',
+                data: {
+                  instruction: 'Check that a map is loaded and layers exist. If the error persists, ask the user to try with different parameters.'
+                }
+              });
+            case 66:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 63], [5, 15, 18, 21], [38, 50, 53, 56]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["z","toggleSplitMap","toggleLayerForMap","sleep","ms","Promise","resolve","setTimeout","splitViewCommandId","getSplitViewCommand","ctx","id","name","group","description","metadata","readOnly","riskLevel","idempotent","inputSchema","object","action","describe","layerIdsForMap0","array","string","optional","layerIdsForMap1","execute","_execute","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_execCtx","input","_ref","_iterator","_step","_step$value","_ids","visState","isSplit","hasLayerAssignment","updatedVis","splitMaps","allLayers","allLayerIds","allLayerIdSet","_iterator2","_step2","_step2$value","panel","ids","unknown","_splitMaps$","map0Layers","desiredSet0","_iterator3","_step3","layerId","isVisible","shouldBeVisible","_freshSplitMaps$","freshSplitMaps","map1Layers","desiredSet1","_iterator4","_step4","_layerId","_isVisible","_shouldBeVisible","finalVis","layers","wrap","_callee$","_context","prev","next","abrupt","success","commandId","error","concat","String","data","instruction","_createForOfIteratorHelper","s","n","done","_slicedToArray","value","undefined","Array","isArray","some","length","t0","e","f","finish","getVisState","dispatch","details","map","l","Set","filter","has","Error","join","t1","Boolean","err","t2","message","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/split-view-command.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport type {RoomCommand} from './types';\nimport {z} from 'zod';\nimport {toggleSplitMap, toggleLayerForMap} from '@kepler.gl/actions';\nimport type {KeplerContext} from './types';\n\nconst sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));\n\nexport const splitViewCommandId = 'map.split-view' as const;\n\nexport function getSplitViewCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: splitViewCommandId,\n    name: 'Toggle split map view',\n    group: 'Map',\n    description: `Enable or disable the dual-map (split view) comparison mode.\n\nWhen enabled, the map splits into two panels for side-by-side comparison. Pass layerIdsForMap0 / layerIdsForMap1 to assign which layers show ONLY in the left / right panel; without these, all layers show on both panels (no comparison).\n\nWhen disabled, the map returns to a single panel.\n\nUse the SAME colorBy / colorType for the layers being compared, so the comparison is fair.`,\n    metadata: {readOnly: false, riskLevel: 'low', idempotent: true},\n    inputSchema: z.object({\n      action: z\n        .enum(['enable', 'disable'])\n        .describe('\"enable\" activates dual map mode; \"disable\" returns to a single map.'),\n      layerIdsForMap0: z\n        .array(z.string())\n        .optional()\n        .describe(\n          'Layer IDs to show ONLY in the LEFT panel. Layers not listed are hidden from the left panel.'\n        ),\n      layerIdsForMap1: z\n        .array(z.string())\n        .optional()\n        .describe(\n          'Layer IDs to show ONLY in the RIGHT panel. Layers not listed are hidden from the right panel.'\n        )\n    }) as any,\n    execute: async (_execCtx, input) => {\n      const {action, layerIdsForMap0, layerIdsForMap1} = (input ?? {}) as {\n        action: 'enable' | 'disable';\n        layerIdsForMap0?: string[];\n        layerIdsForMap1?: string[];\n      };\n      try {\n        // Runtime guard: the bridge/webMCP call execute without zod parsing, so\n        // a missing/invalid action must not fall through to the enable path and\n        // toggle split view unexpectedly.\n        if (action !== 'enable' && action !== 'disable') {\n          return {\n            success: false,\n            commandId: splitViewCommandId,\n            error: `Invalid action \"${String(action)}\". Must be \"enable\" or \"disable\".`,\n            data: {\n              instruction:\n                'Pass action: \"enable\" to activate dual map mode, or \"disable\" to return to a single map.'\n            }\n          };\n        }\n\n        // Runtime guard: the bridge/webMCP call execute without zod parsing, so\n        // a string/object passed as layerIdsForMap0/1 must not be treated as\n        // iterable (`.length`, `.filter`) and produce surprising layer toggles.\n        // Reject non-array or non-string entries when these fields are provided.\n        for (const [name, ids] of [\n          ['layerIdsForMap0', layerIdsForMap0],\n          ['layerIdsForMap1', layerIdsForMap1]\n        ] as const) {\n          if (\n            ids !== undefined &&\n            (!Array.isArray(ids) || ids.some(id => typeof id !== 'string' || id.length === 0))\n          ) {\n            return {\n              success: false,\n              commandId: splitViewCommandId,\n              error: `Invalid ${name}. Must be an array of non-empty layer id strings.`,\n              data: {\n                instruction: `Pass ${name} as an array of layer id strings, or omit it to show all layers on that panel.`\n              }\n            };\n          }\n        }\n\n        const visState = ctx.getVisState();\n        const isSplit = visState.splitMaps && visState.splitMaps.length > 1;\n\n        if (action === 'disable') {\n          if (isSplit) {\n            // Close the RIGHT panel (index 1) so the LEFT panel (map0) survives:\n            // `closeSpecificMapAtIndex` keeps `1 - payload`, so closing 0 would\n            // keep the right panel and flip layer visibility to map1's config.\n            ctx.dispatch(toggleSplitMap(1));\n          }\n          return {\n            success: true,\n            commandId: splitViewCommandId,\n            data: {details: 'Split map view disabled. Returned to single map view.'}\n          };\n        }\n\n        // enable\n        if (!isSplit) {\n          ctx.dispatch(toggleSplitMap(0));\n        }\n\n        const hasLayerAssignment =\n          (layerIdsForMap0 && layerIdsForMap0.length > 0) ||\n          (layerIdsForMap1 && layerIdsForMap1.length > 0);\n\n        if (hasLayerAssignment) {\n          await sleep(200);\n          const updatedVis = ctx.getVisState();\n          const splitMaps = updatedVis.splitMaps;\n\n          if (splitMaps && splitMaps.length > 1) {\n            const allLayers = updatedVis.layers || [];\n            const allLayerIds = allLayers.map((l: any) => l.id);\n\n            // Fail fast on unknown layer ids — silently ignoring them would\n            // hide every real layer not listed and produce an unexpected blank\n            // panel.\n            const allLayerIdSet = new Set(allLayerIds);\n            for (const [panel, ids] of [\n              ['left (map0)', layerIdsForMap0],\n              ['right (map1)', layerIdsForMap1]\n            ] as const) {\n              if (ids && ids.length > 0) {\n                const unknown = ids.filter(id => !allLayerIdSet.has(id));\n                if (unknown.length > 0) {\n                  throw new Error(\n                    `Unknown layer id(s) for the ${panel} panel: ${unknown.join(', ')}. ` +\n                      `Available layer ids: ${allLayerIds.join(', ')}`\n                  );\n                }\n              }\n            }\n\n            if (layerIdsForMap0 && layerIdsForMap0.length > 0) {\n              const map0Layers = splitMaps[0]?.layers || {};\n              const desiredSet0 = new Set(layerIdsForMap0);\n              for (const layerId of allLayerIds) {\n                // Coerce to boolean: a missing entry means \"hidden\", and\n                // `toggleLayerForMapUpdater` toggles missing entries to visible.\n                const isVisible = Boolean(map0Layers[layerId]);\n                const shouldBeVisible = desiredSet0.has(layerId);\n                if (isVisible !== shouldBeVisible) {\n                  ctx.dispatch(toggleLayerForMap(0, layerId));\n                }\n              }\n            }\n\n            if (layerIdsForMap1 && layerIdsForMap1.length > 0) {\n              const freshSplitMaps = ctx.getVisState().splitMaps;\n              const map1Layers = freshSplitMaps?.[1]?.layers || {};\n              const desiredSet1 = new Set(layerIdsForMap1);\n              for (const layerId of allLayerIds) {\n                // Coerce to boolean: a missing entry means \"hidden\", and\n                // `toggleLayerForMapUpdater` toggles missing entries to visible.\n                const isVisible = Boolean(map1Layers[layerId]);\n                const shouldBeVisible = desiredSet1.has(layerId);\n                if (isVisible !== shouldBeVisible) {\n                  ctx.dispatch(toggleLayerForMap(1, layerId));\n                }\n              }\n            }\n          }\n        }\n\n        const finalVis = ctx.getVisState();\n        const layers = finalVis.layers || [];\n\n        return {\n          success: true,\n          commandId: splitViewCommandId,\n          data: {\n            details: `Split map view enabled. ${layers.length} layer(s) available.${\n              hasLayerAssignment\n                ? ` Left panel: ${(layerIdsForMap0 || []).length} layer(s), Right panel: ${\n                    (layerIdsForMap1 || []).length\n                  } layer(s).`\n                : ' All layers visible on both panels. Provide layerIdsForMap0/layerIdsForMap1 to assign layers to each panel.'\n            }`\n          }\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: splitViewCommandId,\n          error: error instanceof Error ? error.message : 'Unknown error',\n          data: {\n            instruction:\n              'Check that a map is loaded and layers exist. If the error persists, ask the user to try with different parameters.'\n          }\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/commands/table-command.js

@@ -0,0 +1,194 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+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 { z } from 'zod';
+import { tableFromArrays } from 'apache-arrow';
+import { addDataToMap } from '@kepler.gl/actions';
+import { processFileData } from '@kepler.gl/processors';
+import { datasetNameToTableName, arrowTableToObjects } from './utils';
+import { isObjectColumn, stringifyObjectColumn, restoreObjectColumns } from './utils';
+export var tableCommandId = 'map.create-table';
+export function getTableCommand(ctx) {
+  return {
+    id: tableCommandId,
+    name: 'Create map dataset via SQL',
+    group: 'Map',
+    description: "Create a NEW dataset in kepler.gl from a SQL query. The result becomes a SEPARATE new dataset (resultDatasetName); the ORIGINAL dataset and its layers/filters are left untouched. Use it to build a new table with different columns \u2014 e.g. add, delete, or rename columns, or change a column's type (CAST(col AS <type>)) \u2014 inside the new dataset.\nNOTE: To modify an EXISTING dataset in place, do NOT use this command \u2014 use map.add-column instead (add a column that copies an existing one to \"rename\", or casts it via expression to change its type). Only reach for map.create-table when the user wants a NEW, separate dataset.\nPlease note:\n1. Do not use * to select all columns, instead use all the column names in dataset.\n2. List all column names the new table or dataset will have.\nIMPORTANT: Use __TABLE__ as the table name placeholder in SQL. It will be replaced with the actual DuckDB table name at runtime.",
+    metadata: {
+      readOnly: false,
+      riskLevel: 'high',
+      idempotent: false,
+      requiresConfirmation: true
+    },
+    inputSchema: z.object({
+      datasetName: z.string().describe('The name of the source dataset'),
+      variableNames: z.array(z.string()).describe('Only use variable names that already exist in the dataset.'),
+      sql: z.string().describe('The SQL query to execute. Use __TABLE__ as the table name placeholder.'),
+      resultDatasetName: z.string().describe('The name for the new dataset')
+    }),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_execCtx, input) {
+        var _ref, datasetName, variableNames, sql, resultDatasetName, visState, datasets, dataId, dbTableName, resolvedSql, uniqueVariableNames, columnData, objectColumns, _iterator, _step, varName, values, arrowTable, db, arrowResult, jsonResult, parsedData, firstFiveRows;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _ref = input !== null && input !== void 0 ? input : {}, datasetName = _ref.datasetName, variableNames = _ref.variableNames, sql = _ref.sql, resultDatasetName = _ref.resultDatasetName;
+              _context.prev = 1;
+              if (!(typeof datasetName !== 'string' || datasetName.length === 0)) {
+                _context.next = 4;
+                break;
+              }
+              throw new Error('datasetName must be a non-empty string.');
+            case 4:
+              if (!(!Array.isArray(variableNames) || variableNames.length === 0 || variableNames.some(function (v) {
+                return typeof v !== 'string' || v.length === 0;
+              }))) {
+                _context.next = 6;
+                break;
+              }
+              throw new Error('variableNames must be a non-empty array of non-empty strings.');
+            case 6:
+              if (!(typeof sql !== 'string' || sql.length === 0)) {
+                _context.next = 8;
+                break;
+              }
+              throw new Error('sql must be a non-empty string.');
+            case 8:
+              if (!(typeof resultDatasetName !== 'string' || resultDatasetName.length === 0)) {
+                _context.next = 10;
+                break;
+              }
+              throw new Error('resultDatasetName must be a non-empty string.');
+            case 10:
+              visState = ctx.getVisState();
+              datasets = visState.datasets;
+              dataId = Object.keys(datasets).find(function (id) {
+                return id === datasetName || datasets[id].label === datasetName;
+              });
+              if (dataId) {
+                _context.next = 15;
+                break;
+              }
+              throw new Error("Dataset \"".concat(datasetName, "\" not found."));
+            case 15:
+              // Derive the DuckDB table name from the resolved dataset id, not the
+              // user-provided label: different labels can sanitize to the same table
+              // name (e.g. "A-B" vs "A B"), which would clobber another dataset's
+              // temp table inside DuckDB and run the SQL against unintended data.
+              dbTableName = datasetNameToTableName(dataId); // The contract requires the __TABLE__ placeholder — without it the
+              // query would run against whatever table names appear in the SQL (or
+              // return unrelated results), which is especially risky for a
+              // high-risk, confirmation-gated command. Fail fast with an actionable
+              // error instead.
+              if (sql.includes('__TABLE__')) {
+                _context.next = 18;
+                break;
+              }
+              throw new Error('The SQL query must use the __TABLE__ placeholder as the table name, ' + 'e.g. `SELECT * FROM __TABLE__`.');
+            case 18:
+              resolvedSql = sql.replace(/__TABLE__/g, "\"".concat(dbTableName, "\"")); // Dedupe variableNames: duplicate names would silently overwrite
+              // earlier entries in columnData, producing an Arrow table that doesn't
+              // match the requested column list.
+              uniqueVariableNames = _toConsumableArray(new Set(variableNames));
+              columnData = {}; // Object-valued columns (the `_geojson` Feature objects) must not be
+              // round-tripped through Arrow raw: `tableFromArrays` infers ONE Arrow
+              // type per column from the first value, so a dataset mixing Polygon and
+              // MultiPolygon features gets the shallower (Polygon) coordinate nesting
+              // and the MultiPolygon coordinates come back as nulls. Stringify them
+              // for the DuckDB round-trip and restore the objects afterwards.
+              objectColumns = [];
+              _iterator = _createForOfIteratorHelper(uniqueVariableNames);
+              try {
+                for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                  varName = _step.value;
+                  // Pass the user-provided datasetName (label or id) — the documented
+                  // KeplerContext contract — not the resolved id; getValuesFromDataset
+                  // matches by label or id either way.
+                  values = ctx.getValuesFromDataset(datasetName, varName);
+                  if (isObjectColumn(values)) objectColumns.push(varName);
+                  columnData[varName] = stringifyObjectColumn(values);
+                }
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
+              }
+              arrowTable = tableFromArrays(columnData);
+              _context.next = 27;
+              return ctx.getConnector();
+            case 27:
+              db = _context.sent;
+              _context.next = 30;
+              return db.execute("DROP TABLE IF EXISTS \"".concat(dbTableName, "\""));
+            case 30:
+              _context.next = 32;
+              return db.loadArrow(arrowTable, dbTableName);
+            case 32:
+              _context.next = 34;
+              return db.query(resolvedSql);
+            case 34:
+              arrowResult = _context.sent;
+              jsonResult = arrowTableToObjects(arrowResult);
+              restoreObjectColumns(jsonResult, objectColumns);
+              _context.next = 39;
+              return processFileData({
+                content: {
+                  data: jsonResult,
+                  fileName: resultDatasetName
+                },
+                fileCache: []
+              });
+            case 39:
+              parsedData = _context.sent;
+              ctx.dispatch(addDataToMap({
+                datasets: parsedData,
+                // No auto-create — the assistant creates the layer explicitly via
+                // `map.add-layer` to avoid duplicate default layers.
+                options: {
+                  autoCreateLayers: false,
+                  centerMap: true
+                }
+              }));
+
+              // Trimmed, model-facing subset (ported from the old `toModelOutput`).
+              firstFiveRows = jsonResult.slice(0, 5);
+              return _context.abrupt("return", {
+                success: true,
+                commandId: tableCommandId,
+                data: {
+                  details: "Table created as ".concat(resultDatasetName, " (").concat(jsonResult.length, " rows) and added to kepler.gl."),
+                  resultDatasetName: resultDatasetName,
+                  firstFiveRows: firstFiveRows
+                }
+              });
+            case 45:
+              _context.prev = 45;
+              _context.t0 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: tableCommandId,
+                error: _context.t0 instanceof Error ? _context.t0.message : String(_context.t0),
+                data: {
+                  instruction: 'Please explain the error and give a plan to fix it. Then try again with a different query.'
+                }
+              });
+            case 48:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 45]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["z","tableFromArrays","addDataToMap","processFileData","datasetNameToTableName","arrowTableToObjects","isObjectColumn","stringifyObjectColumn","restoreObjectColumns","tableCommandId","getTableCommand","ctx","id","name","group","description","metadata","readOnly","riskLevel","idempotent","requiresConfirmation","inputSchema","object","datasetName","string","describe","variableNames","array","sql","resultDatasetName","execute","_execute","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_execCtx","input","_ref","visState","datasets","dataId","dbTableName","resolvedSql","uniqueVariableNames","columnData","objectColumns","_iterator","_step","varName","values","arrowTable","db","arrowResult","jsonResult","parsedData","firstFiveRows","wrap","_callee$","_context","prev","next","length","Error","Array","isArray","some","v","getVisState","Object","keys","find","label","concat","includes","replace","_toConsumableArray","Set","_createForOfIteratorHelper","s","n","done","value","getValuesFromDataset","push","err","e","f","getConnector","sent","loadArrow","query","content","data","fileName","fileCache","dispatch","options","autoCreateLayers","centerMap","slice","abrupt","success","commandId","details","t0","error","message","String","instruction","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/table-command.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport type {RoomCommand} from './types';\nimport {z} from 'zod';\nimport {tableFromArrays, Table as ArrowTable} from 'apache-arrow';\nimport {addDataToMap} from '@kepler.gl/actions';\nimport {processFileData} from '@kepler.gl/processors';\nimport type {KeplerContext} from './types';\nimport {datasetNameToTableName, arrowTableToObjects} from './utils';\nimport {isObjectColumn, stringifyObjectColumn, restoreObjectColumns} from './utils';\n\nexport const tableCommandId = 'map.create-table' as const;\n\nexport function getTableCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: tableCommandId,\n    name: 'Create map dataset via SQL',\n    group: 'Map',\n    description: `Create a NEW dataset in kepler.gl from a SQL query. The result becomes a SEPARATE new dataset (resultDatasetName); the ORIGINAL dataset and its layers/filters are left untouched. Use it to build a new table with different columns — e.g. add, delete, or rename columns, or change a column's type (CAST(col AS <type>)) — inside the new dataset.\nNOTE: To modify an EXISTING dataset in place, do NOT use this command — use map.add-column instead (add a column that copies an existing one to \"rename\", or casts it via expression to change its type). Only reach for map.create-table when the user wants a NEW, separate dataset.\nPlease note:\n1. Do not use * to select all columns, instead use all the column names in dataset.\n2. List all column names the new table or dataset will have.\nIMPORTANT: Use __TABLE__ as the table name placeholder in SQL. It will be replaced with the actual DuckDB table name at runtime.`,\n    metadata: {readOnly: false, riskLevel: 'high', idempotent: false, requiresConfirmation: true},\n    inputSchema: z.object({\n      datasetName: z.string().describe('The name of the source dataset'),\n      variableNames: z\n        .array(z.string())\n        .describe('Only use variable names that already exist in the dataset.'),\n      sql: z\n        .string()\n        .describe('The SQL query to execute. Use __TABLE__ as the table name placeholder.'),\n      resultDatasetName: z.string().describe('The name for the new dataset')\n    }) as any,\n    execute: async (_execCtx, input) => {\n      const {datasetName, variableNames, sql, resultDatasetName} = (input ?? {}) as {\n        datasetName: string;\n        variableNames: string[];\n        sql: string;\n        resultDatasetName: string;\n      };\n      try {\n        // Runtime guard: the bridge/webMCP call execute without zod parsing, so\n        // missing/wrong-typed inputs must not fall through to TypeErrors (e.g.\n        // `sql.includes` on a non-string) that surface as confusing errors.\n        if (typeof datasetName !== 'string' || datasetName.length === 0) {\n          throw new Error('datasetName must be a non-empty string.');\n        }\n        if (\n          !Array.isArray(variableNames) ||\n          variableNames.length === 0 ||\n          variableNames.some(v => typeof v !== 'string' || v.length === 0)\n        ) {\n          throw new Error('variableNames must be a non-empty array of non-empty strings.');\n        }\n        if (typeof sql !== 'string' || sql.length === 0) {\n          throw new Error('sql must be a non-empty string.');\n        }\n        if (typeof resultDatasetName !== 'string' || resultDatasetName.length === 0) {\n          throw new Error('resultDatasetName must be a non-empty string.');\n        }\n\n        const visState = ctx.getVisState();\n        const datasets = visState.datasets;\n        const dataId = Object.keys(datasets).find(\n          id => id === datasetName || datasets[id].label === datasetName\n        );\n        if (!dataId) {\n          throw new Error(`Dataset \"${datasetName}\" not found.`);\n        }\n        // Derive the DuckDB table name from the resolved dataset id, not the\n        // user-provided label: different labels can sanitize to the same table\n        // name (e.g. \"A-B\" vs \"A B\"), which would clobber another dataset's\n        // temp table inside DuckDB and run the SQL against unintended data.\n        const dbTableName = datasetNameToTableName(dataId);\n        // The contract requires the __TABLE__ placeholder — without it the\n        // query would run against whatever table names appear in the SQL (or\n        // return unrelated results), which is especially risky for a\n        // high-risk, confirmation-gated command. Fail fast with an actionable\n        // error instead.\n        if (!sql.includes('__TABLE__')) {\n          throw new Error(\n            'The SQL query must use the __TABLE__ placeholder as the table name, ' +\n              'e.g. `SELECT * FROM __TABLE__`.'\n          );\n        }\n        const resolvedSql = sql.replace(/__TABLE__/g, `\"${dbTableName}\"`);\n        // Dedupe variableNames: duplicate names would silently overwrite\n        // earlier entries in columnData, producing an Arrow table that doesn't\n        // match the requested column list.\n        const uniqueVariableNames = [...new Set(variableNames)];\n        const columnData: Record<string, unknown[]> = {};\n        // Object-valued columns (the `_geojson` Feature objects) must not be\n        // round-tripped through Arrow raw: `tableFromArrays` infers ONE Arrow\n        // type per column from the first value, so a dataset mixing Polygon and\n        // MultiPolygon features gets the shallower (Polygon) coordinate nesting\n        // and the MultiPolygon coordinates come back as nulls. Stringify them\n        // for the DuckDB round-trip and restore the objects afterwards.\n        const objectColumns: string[] = [];\n        for (const varName of uniqueVariableNames) {\n          // Pass the user-provided datasetName (label or id) — the documented\n          // KeplerContext contract — not the resolved id; getValuesFromDataset\n          // matches by label or id either way.\n          const values = ctx.getValuesFromDataset(datasetName, varName);\n          if (isObjectColumn(values)) objectColumns.push(varName);\n          columnData[varName] = stringifyObjectColumn(values);\n        }\n\n        const arrowTable: ArrowTable = tableFromArrays(columnData);\n        const db = await ctx.getConnector();\n\n        await db.execute(`DROP TABLE IF EXISTS \"${dbTableName}\"`);\n        await db.loadArrow(arrowTable, dbTableName);\n\n        const arrowResult = await db.query(resolvedSql);\n\n        const jsonResult: Record<string, unknown>[] = arrowTableToObjects(arrowResult);\n        restoreObjectColumns(jsonResult, objectColumns);\n\n        const parsedData = await processFileData({\n          content: {data: jsonResult, fileName: resultDatasetName},\n          fileCache: []\n        });\n\n        ctx.dispatch(\n          addDataToMap({\n            datasets: parsedData,\n            // No auto-create — the assistant creates the layer explicitly via\n            // `map.add-layer` to avoid duplicate default layers.\n            options: {autoCreateLayers: false, centerMap: true}\n          })\n        );\n\n        // Trimmed, model-facing subset (ported from the old `toModelOutput`).\n        const firstFiveRows = jsonResult.slice(0, 5);\n        return {\n          success: true,\n          commandId: tableCommandId,\n          data: {\n            details: `Table created as ${resultDatasetName} (${jsonResult.length} rows) and added to kepler.gl.`,\n            resultDatasetName,\n            firstFiveRows\n          }\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: tableCommandId,\n          error: error instanceof Error ? error.message : String(error),\n          data: {\n            instruction:\n              'Please explain the error and give a plan to fix it. Then try again with a different query.'\n          }\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}