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

package/dist/esm/commands/time-filter-command.js

@@ -0,0 +1,280 @@
+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
+
+import { z } from 'zod';
+import { addFilter, setFilter, setFilterAnimationTime, setFilterAnimationWindow } from '@kepler.gl/actions';
+var MILLIS_SECOND = 1000;
+var MILLIS_MINUTE = 60 * MILLIS_SECOND;
+var MILLIS_HOUR = 60 * MILLIS_MINUTE;
+var MILLIS_DAY = 24 * MILLIS_HOUR;
+var MILLIS_WEEK = 7 * MILLIS_DAY;
+var MILLIS_MONTH = 30 * MILLIS_DAY;
+var MILLIS_3_MONTH = 91 * MILLIS_DAY;
+var MILLIS_YEAR = 365 * MILLIS_DAY;
+export var INTERVAL_MILLIS = {
+  '1-second': MILLIS_SECOND,
+  '1-minute': MILLIS_MINUTE,
+  '1-hour': MILLIS_HOUR,
+  '1-day': MILLIS_DAY,
+  '1-week': MILLIS_WEEK,
+  '1-month': MILLIS_MONTH,
+  '3-month': MILLIS_3_MONTH,
+  '1-year': MILLIS_YEAR
+};
+
+/**
+ * Infer a sensible animation interval from a time filter's domain and (when
+ * available) the actual distinct timestamps in the dataset. Mirrors the logic
+ * used by spatial-agent's `detectIntervalFromDomain` so the skill-path behaves
+ * identically.
+ */
+export function detectIntervalFromDomain(domain, mappedValues) {
+  var span = domain[1] - domain[0];
+  if (span <= 0) return '1-year';
+  var numUniqueSteps;
+  if (mappedValues && mappedValues.length > 0) {
+    var unique = new Set(mappedValues.filter(function (v) {
+      return v != null;
+    }));
+    numUniqueSteps = unique.size;
+  } else {
+    numUniqueSteps = 2;
+  }
+  if (numUniqueSteps <= 1) return '1-year';
+  var avgGap = span / Math.max(numUniqueSteps - 1, 1);
+  if (avgGap >= MILLIS_YEAR * 0.8) return '1-year';
+  if (avgGap >= MILLIS_MONTH * 2.5) return '3-month';
+  if (avgGap >= MILLIS_MONTH * 0.8) return '1-month';
+  if (avgGap >= MILLIS_DAY * 5) return '1-week';
+  if (avgGap >= MILLIS_DAY * 0.8) return '1-day';
+  if (avgGap >= MILLIS_HOUR * 0.8) return '1-hour';
+  if (avgGap >= MILLIS_MINUTE * 0.8) return '1-minute';
+  return '1-second';
+}
+var sleep = function sleep(ms) {
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, ms);
+  });
+};
+export var addTimeFilterCommandId = 'map.add-time-filter';
+export function getAddTimeFilterCommand(ctx) {
+  return {
+    id: addTimeFilterCommandId,
+    name: 'Add time filter',
+    group: 'Map',
+    description: "Add a time-range filter to animate a NON-trip layer over a TIMESTAMP/DATE column. The time controller appears at the bottom of the map.\n\nDO NOT call this for a trip layer \u2014 trips have built-in time animation.\n\nThe dataset and a layer for it must already exist on the map (e.g. from map.add-layer or map.load-data).\n\nPass the datasetName and the dateTimeColumn to animate over. The interval is auto-detected from the data when omitted; pass it explicitly to override.",
+    metadata: {
+      readOnly: false,
+      riskLevel: 'medium',
+      idempotent: false
+    },
+    inputSchema: z.object({
+      datasetName: z.string().describe('The name (label) or id of the dataset to animate.'),
+      dateTimeColumn: z.string().describe('A TIMESTAMP or DATE column in the dataset. Do NOT pass an integer/string epoch column — build a real TIMESTAMP column first.'),
+      interval: z["enum"](['1-second', '1-minute', '1-hour', '1-day', '1-week', '1-month', '3-month', '1-year']).optional().describe('Animation step. Auto-detected from the data span and distinct timestamps when omitted.')
+    }),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_execCtx, input) {
+        var _ref, datasetName, dateTimeColumn, interval, _dataset$fields, _visState$filters, _ctx$getVisState$filt3, _resolvedInterval, visState, datasets, datasetId, dataset, filterField, _dataset$fields2, filters, existingFilterIdx, filterIdx, filterId, attempt, _ctx$getVisState$filt, _ctx$getVisState$filt2, currentFilters, targetFilter, resolvedInterval, _ctx$getVisState$filt5, _dataset$fields$index, _dataset$fields3, mappedValues, fieldIdx, rows, MAX_SAMPLES, step, i, val, ts, datasetBins, _attempt, _ctx$getVisState$filt4, updatedFilter, _timeBins$datasetId, timeBins, bins, finalFilter, _INTERVAL_MILLIS, domainStart, windowSize;
+        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, dateTimeColumn = _ref.dateTimeColumn, interval = _ref.interval;
+              _context.prev = 1;
+              if (!(interval !== undefined && (typeof interval !== 'string' || !Object.prototype.hasOwnProperty.call(INTERVAL_MILLIS, interval)))) {
+                _context.next = 4;
+                break;
+              }
+              throw new Error("Invalid interval \"".concat(String(interval), "\". Must be one of: ").concat(Object.keys(INTERVAL_MILLIS).join(', '), "."));
+            case 4:
+              visState = ctx.getVisState();
+              datasets = visState.datasets;
+              datasetId = Object.keys(datasets).find(function (dataId) {
+                return datasets[dataId].label === datasetName || dataId === datasetName;
+              });
+              if (datasetId) {
+                _context.next = 9;
+                break;
+              }
+              throw new Error("Dataset ".concat(datasetName, " not found."));
+            case 9:
+              dataset = datasets[datasetId];
+              filterField = (_dataset$fields = dataset.fields) === null || _dataset$fields === void 0 ? void 0 : _dataset$fields.find(function (f) {
+                return f.name === dateTimeColumn;
+              });
+              if (filterField) {
+                _context.next = 13;
+                break;
+              }
+              throw new Error("Column ".concat(dateTimeColumn, " not found in dataset ").concat(datasetName, ". Available: ").concat((_dataset$fields2 = dataset.fields) === null || _dataset$fields2 === void 0 ? void 0 : _dataset$fields2.map(function (f) {
+                return f.name;
+              }).join(', ')));
+            case 13:
+              if (!(filterField.type !== 'timestamp' && filterField.type !== 'date')) {
+                _context.next = 15;
+                break;
+              }
+              throw new Error("Column ".concat(dateTimeColumn, " is of type \"").concat(filterField.type, "\", not timestamp/date. Build a real TIMESTAMP column first (Kepler.gl cannot animate on integer/string epochs)."));
+            case 15:
+              // Explicitly typed: `VisState.filters` is untyped (index signature) and
+              // strict consumers (e.g. kepler-assistant, which vendors this module)
+              // would otherwise flag the `.findIndex(f => …)` callback as implicit any.
+              filters = (_visState$filters = visState.filters) !== null && _visState$filters !== void 0 ? _visState$filters : [];
+              existingFilterIdx = filters.findIndex(function (f) {
+                return (Array.isArray(f.dataId) ? f.dataId.includes(datasetId) : f.dataId === datasetId) && (Array.isArray(f.name) ? f.name.includes(dateTimeColumn) : f.name === dateTimeColumn);
+              });
+              if (!(existingFilterIdx >= 0)) {
+                _context.next = 22;
+                break;
+              }
+              filterIdx = existingFilterIdx;
+              filterId = filters[existingFilterIdx].id;
+              _context.next = 36;
+              break;
+            case 22:
+              filterIdx = filters.length;
+              ctx.dispatch(addFilter(datasetId));
+              ctx.dispatch(setFilter(filterIdx, 'name', dateTimeColumn));
+              // Poll for the filter entry to appear instead of a fixed sleep: on
+              // slower devices the filter (and its id) may not be available yet,
+              // and a fixed delay would leave filterId as an empty string, making
+              // the later setFilterAnimationWindow({id: filterId, ...}) behave
+              // unpredictably.
+              filterId = '';
+              attempt = 0;
+            case 27:
+              if (!(attempt < 10 && !filterId)) {
+                _context.next = 34;
+                break;
+              }
+              _context.next = 30;
+              return sleep(100);
+            case 30:
+              filterId = (_ctx$getVisState$filt = (_ctx$getVisState$filt2 = ctx.getVisState().filters) === null || _ctx$getVisState$filt2 === void 0 || (_ctx$getVisState$filt2 = _ctx$getVisState$filt2[filterIdx]) === null || _ctx$getVisState$filt2 === void 0 ? void 0 : _ctx$getVisState$filt2.id) !== null && _ctx$getVisState$filt !== void 0 ? _ctx$getVisState$filt : '';
+            case 31:
+              attempt++;
+              _context.next = 27;
+              break;
+            case 34:
+              if (filterId) {
+                _context.next = 36;
+                break;
+              }
+              throw new Error("Timed out waiting for the time filter on column \"".concat(dateTimeColumn, "\" to be created. Please try again."));
+            case 36:
+              currentFilters = (_ctx$getVisState$filt3 = ctx.getVisState().filters) !== null && _ctx$getVisState$filt3 !== void 0 ? _ctx$getVisState$filt3 : [];
+              targetFilter = currentFilters[filterIdx];
+              resolvedInterval = interval;
+              if (!(targetFilter !== null && targetFilter !== void 0 && targetFilter.domain && targetFilter.domain.length === 2)) {
+                _context.next = 59;
+                break;
+              }
+              if (!resolvedInterval) {
+                fieldIdx = (_dataset$fields$index = (_dataset$fields3 = dataset.fields) === null || _dataset$fields3 === void 0 ? void 0 : _dataset$fields3.indexOf(filterField)) !== null && _dataset$fields$index !== void 0 ? _dataset$fields$index : -1;
+                if (fieldIdx >= 0 && dataset.dataContainer) {
+                  rows = dataset.dataContainer.numRows();
+                  mappedValues = [];
+                  // Sample a bounded number of rows — iterating every row can freeze
+                  // the UI thread on large datasets, and a sample is enough for a
+                  // reasonable interval estimate.
+                  MAX_SAMPLES = 1000;
+                  step = Math.max(1, Math.floor(rows / MAX_SAMPLES));
+                  for (i = 0; i < rows; i += step) {
+                    val = dataset.dataContainer.valueAt(i, fieldIdx);
+                    if (val != null) {
+                      ts = typeof val === 'number' ? val : new Date(val).getTime();
+                      if (!isNaN(ts)) mappedValues.push(ts);
+                    }
+                  }
+                }
+                resolvedInterval = detectIntervalFromDomain(targetFilter.domain, mappedValues);
+              }
+              ctx.dispatch(setFilter(filterIdx, 'plotType', {
+                interval: resolvedInterval
+              }));
+              ctx.dispatch(setFilterAnimationWindow({
+                id: filterId,
+                animationWindow: 'free'
+              }));
+
+              // Poll for timeBins to become available (kepler computes them async).
+              _attempt = 0;
+            case 44:
+              if (!(_attempt < 10)) {
+                _context.next = 57;
+                break;
+              }
+              _context.next = 47;
+              return sleep(200);
+            case 47:
+              updatedFilter = (_ctx$getVisState$filt4 = ctx.getVisState().filters) === null || _ctx$getVisState$filt4 === void 0 ? void 0 : _ctx$getVisState$filt4[filterIdx];
+              if (!(updatedFilter !== null && updatedFilter !== void 0 && updatedFilter.domain && updatedFilter.domain.length === 2)) {
+                _context.next = 54;
+                break;
+              }
+              // timeBins is keyed by dataset id, then by interval:
+              // {[dataId]: {[interval]: bins[]}}. Look up the bins for THIS
+              // filter's dataset — grabbing the first entry via
+              // Object.values(timeBins)[0] would pick the wrong dataset's bins
+              // when multiple datasets/filters exist, animating against the
+              // wrong time window.
+              timeBins = updatedFilter.timeBins;
+              bins = timeBins === null || timeBins === void 0 || (_timeBins$datasetId = timeBins[datasetId]) === null || _timeBins$datasetId === void 0 ? void 0 : _timeBins$datasetId[resolvedInterval];
+              if (!(bins && bins.length > 0)) {
+                _context.next = 54;
+                break;
+              }
+              datasetBins = bins;
+              return _context.abrupt("break", 57);
+            case 54:
+              _attempt++;
+              _context.next = 44;
+              break;
+            case 57:
+              finalFilter = (_ctx$getVisState$filt5 = ctx.getVisState().filters) === null || _ctx$getVisState$filt5 === void 0 ? void 0 : _ctx$getVisState$filt5[filterIdx];
+              if (finalFilter !== null && finalFilter !== void 0 && finalFilter.domain && finalFilter.domain.length === 2) {
+                if (datasetBins && datasetBins.length > 0) {
+                  ctx.dispatch(setFilterAnimationTime(filterIdx, 'value', [datasetBins[0].x0, datasetBins[0].x1]));
+                } else {
+                  domainStart = finalFilter.domain[0];
+                  windowSize = (_INTERVAL_MILLIS = INTERVAL_MILLIS[resolvedInterval]) !== null && _INTERVAL_MILLIS !== void 0 ? _INTERVAL_MILLIS : MILLIS_YEAR;
+                  ctx.dispatch(setFilterAnimationTime(filterIdx, 'value', [domainStart, domainStart + windowSize]));
+                }
+              }
+            case 59:
+              return _context.abrupt("return", {
+                success: true,
+                commandId: addTimeFilterCommandId,
+                data: {
+                  details: "Time filter added on column \"".concat(dateTimeColumn, "\" for dataset \"").concat(datasetName, "\" (interval: ").concat((_resolvedInterval = resolvedInterval) !== null && _resolvedInterval !== void 0 ? _resolvedInterval : 'auto', ", filter index: ").concat(filterIdx, "). The time controller is now visible at the bottom of the map."),
+                  filterIndex: filterIdx,
+                  interval: resolvedInterval
+                }
+              });
+            case 62:
+              _context.prev = 62;
+              _context.t0 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: addTimeFilterCommandId,
+                error: _context.t0 instanceof Error ? _context.t0.message : 'Unknown error',
+                data: {
+                  instruction: 'Check that the dataset exists, the column is a TIMESTAMP/DATE, and a layer for the dataset is already on the map. Do not retry more than once.'
+                }
+              });
+            case 65:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 62]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["z","addFilter","setFilter","setFilterAnimationTime","setFilterAnimationWindow","MILLIS_SECOND","MILLIS_MINUTE","MILLIS_HOUR","MILLIS_DAY","MILLIS_WEEK","MILLIS_MONTH","MILLIS_3_MONTH","MILLIS_YEAR","INTERVAL_MILLIS","detectIntervalFromDomain","domain","mappedValues","span","numUniqueSteps","length","unique","Set","filter","v","size","avgGap","Math","max","sleep","ms","Promise","resolve","setTimeout","addTimeFilterCommandId","getAddTimeFilterCommand","ctx","id","name","group","description","metadata","readOnly","riskLevel","idempotent","inputSchema","object","datasetName","string","describe","dateTimeColumn","interval","optional","execute","_execute","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_execCtx","input","_ref","_dataset$fields","_visState$filters","_ctx$getVisState$filt3","_resolvedInterval","visState","datasets","datasetId","dataset","filterField","_dataset$fields2","filters","existingFilterIdx","filterIdx","filterId","attempt","_ctx$getVisState$filt","_ctx$getVisState$filt2","currentFilters","targetFilter","resolvedInterval","_ctx$getVisState$filt5","_dataset$fields$index","_dataset$fields3","fieldIdx","rows","MAX_SAMPLES","step","i","val","ts","datasetBins","_attempt","_ctx$getVisState$filt4","updatedFilter","_timeBins$datasetId","timeBins","bins","finalFilter","_INTERVAL_MILLIS","domainStart","windowSize","wrap","_callee$","_context","prev","next","undefined","Object","prototype","hasOwnProperty","call","Error","concat","String","keys","join","getVisState","find","dataId","label","fields","f","map","type","findIndex","Array","isArray","includes","dispatch","indexOf","dataContainer","numRows","floor","valueAt","Date","getTime","isNaN","push","animationWindow","abrupt","x0","x1","success","commandId","data","details","filterIndex","t0","error","message","instruction","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/time-filter-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 type KeplerTable from '@kepler.gl/table';\nimport type {Datasets} from '@kepler.gl/table';\nimport {\n  addFilter,\n  setFilter,\n  setFilterAnimationTime,\n  setFilterAnimationWindow\n} from '@kepler.gl/actions';\nimport type {KeplerContext} from './types';\n\nexport type IntervalKey =\n  | '1-second'\n  | '1-minute'\n  | '1-hour'\n  | '1-day'\n  | '1-week'\n  | '1-month'\n  | '3-month'\n  | '1-year';\n\nconst MILLIS_SECOND = 1_000;\nconst MILLIS_MINUTE = 60 * MILLIS_SECOND;\nconst MILLIS_HOUR = 60 * MILLIS_MINUTE;\nconst MILLIS_DAY = 24 * MILLIS_HOUR;\nconst MILLIS_WEEK = 7 * MILLIS_DAY;\nconst MILLIS_MONTH = 30 * MILLIS_DAY;\nconst MILLIS_3_MONTH = 91 * MILLIS_DAY;\nconst MILLIS_YEAR = 365 * MILLIS_DAY;\n\nexport const INTERVAL_MILLIS: Record<IntervalKey, number> = {\n  '1-second': MILLIS_SECOND,\n  '1-minute': MILLIS_MINUTE,\n  '1-hour': MILLIS_HOUR,\n  '1-day': MILLIS_DAY,\n  '1-week': MILLIS_WEEK,\n  '1-month': MILLIS_MONTH,\n  '3-month': MILLIS_3_MONTH,\n  '1-year': MILLIS_YEAR\n};\n\n/**\n * Infer a sensible animation interval from a time filter's domain and (when\n * available) the actual distinct timestamps in the dataset. Mirrors the logic\n * used by spatial-agent's `detectIntervalFromDomain` so the skill-path behaves\n * identically.\n */\nexport function detectIntervalFromDomain(\n  domain: [number, number],\n  mappedValues?: number[]\n): IntervalKey {\n  const span = domain[1] - domain[0];\n  if (span <= 0) return '1-year';\n\n  let numUniqueSteps: number;\n  if (mappedValues && mappedValues.length > 0) {\n    const unique = new Set(mappedValues.filter(v => v != null));\n    numUniqueSteps = unique.size;\n  } else {\n    numUniqueSteps = 2;\n  }\n\n  if (numUniqueSteps <= 1) return '1-year';\n\n  const avgGap = span / Math.max(numUniqueSteps - 1, 1);\n\n  if (avgGap >= MILLIS_YEAR * 0.8) return '1-year';\n  if (avgGap >= MILLIS_MONTH * 2.5) return '3-month';\n  if (avgGap >= MILLIS_MONTH * 0.8) return '1-month';\n  if (avgGap >= MILLIS_DAY * 5) return '1-week';\n  if (avgGap >= MILLIS_DAY * 0.8) return '1-day';\n  if (avgGap >= MILLIS_HOUR * 0.8) return '1-hour';\n  if (avgGap >= MILLIS_MINUTE * 0.8) return '1-minute';\n  return '1-second';\n}\n\nconst sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));\n\nexport const addTimeFilterCommandId = 'map.add-time-filter' as const;\n\nexport function getAddTimeFilterCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: addTimeFilterCommandId,\n    name: 'Add time filter',\n    group: 'Map',\n    description: `Add a time-range filter to animate a NON-trip layer over a TIMESTAMP/DATE column. The time controller appears at the bottom of the map.\n\nDO NOT call this for a trip layer — trips have built-in time animation.\n\nThe dataset and a layer for it must already exist on the map (e.g. from map.add-layer or map.load-data).\n\nPass the datasetName and the dateTimeColumn to animate over. The interval is auto-detected from the data when omitted; pass it explicitly to override.`,\n    metadata: {readOnly: false, riskLevel: 'medium', idempotent: false},\n    inputSchema: z.object({\n      datasetName: z.string().describe('The name (label) or id of the dataset to animate.'),\n      dateTimeColumn: z\n        .string()\n        .describe(\n          'A TIMESTAMP or DATE column in the dataset. Do NOT pass an integer/string epoch column — build a real TIMESTAMP column first.'\n        ),\n      interval: z\n        .enum(['1-second', '1-minute', '1-hour', '1-day', '1-week', '1-month', '3-month', '1-year'])\n        .optional()\n        .describe(\n          'Animation step. Auto-detected from the data span and distinct timestamps when omitted.'\n        )\n    }) as any,\n    execute: async (_execCtx, input) => {\n      const {datasetName, dateTimeColumn, interval} = (input ?? {}) as {\n        datasetName: string;\n        dateTimeColumn: string;\n        interval?: IntervalKey;\n      };\n      try {\n        // Runtime guard: the bridge/webMCP call execute without zod parsing,\n        // so an invalid interval must not be written into kepler filter state\n        // (plotType.interval). Use an own-property check — `in` matches\n        // inherited properties (e.g. \"toString\"), so a crafted interval could\n        // otherwise bypass the guard — and require a string value.\n        if (\n          interval !== undefined &&\n          (typeof interval !== 'string' ||\n            !Object.prototype.hasOwnProperty.call(INTERVAL_MILLIS, interval))\n        ) {\n          throw new Error(\n            `Invalid interval \"${String(interval)}\". Must be one of: ${Object.keys(\n              INTERVAL_MILLIS\n            ).join(', ')}.`\n          );\n        }\n        const visState = ctx.getVisState();\n        const datasets: Datasets = visState.datasets;\n\n        const datasetId = Object.keys(datasets).find(\n          dataId => datasets[dataId].label === datasetName || dataId === datasetName\n        );\n        if (!datasetId) {\n          throw new Error(`Dataset ${datasetName} not found.`);\n        }\n        const dataset = datasets[datasetId] as KeplerTable;\n\n        const filterField = dataset.fields?.find(f => f.name === dateTimeColumn);\n        if (!filterField) {\n          throw new Error(\n            `Column ${dateTimeColumn} not found in dataset ${datasetName}. Available: ${dataset.fields\n              ?.map(f => f.name)\n              .join(', ')}`\n          );\n        }\n        if (filterField.type !== 'timestamp' && filterField.type !== 'date') {\n          throw new Error(\n            `Column ${dateTimeColumn} is of type \"${filterField.type}\", not timestamp/date. Build a real TIMESTAMP column first (Kepler.gl cannot animate on integer/string epochs).`\n          );\n        }\n\n        // Explicitly typed: `VisState.filters` is untyped (index signature) and\n        // strict consumers (e.g. kepler-assistant, which vendors this module)\n        // would otherwise flag the `.findIndex(f => …)` callback as implicit any.\n        const filters: any[] = visState.filters ?? [];\n        const existingFilterIdx = filters.findIndex(\n          f =>\n            (Array.isArray(f.dataId) ? f.dataId.includes(datasetId) : f.dataId === datasetId) &&\n            (Array.isArray(f.name) ? f.name.includes(dateTimeColumn) : f.name === dateTimeColumn)\n        );\n\n        let filterIdx: number;\n        let filterId: string;\n\n        if (existingFilterIdx >= 0) {\n          filterIdx = existingFilterIdx;\n          filterId = filters[existingFilterIdx].id;\n        } else {\n          filterIdx = filters.length;\n          ctx.dispatch(addFilter(datasetId));\n          ctx.dispatch(setFilter(filterIdx, 'name', dateTimeColumn));\n          // Poll for the filter entry to appear instead of a fixed sleep: on\n          // slower devices the filter (and its id) may not be available yet,\n          // and a fixed delay would leave filterId as an empty string, making\n          // the later setFilterAnimationWindow({id: filterId, ...}) behave\n          // unpredictably.\n          filterId = '';\n          for (let attempt = 0; attempt < 10 && !filterId; attempt++) {\n            await sleep(100);\n            filterId = ctx.getVisState().filters?.[filterIdx]?.id ?? '';\n          }\n          if (!filterId) {\n            // Fail fast instead of proceeding with an empty id — the later\n            // setFilterAnimationWindow({id: filterId, ...}) would no-op or\n            // update the wrong filter.\n            throw new Error(\n              `Timed out waiting for the time filter on column \"${dateTimeColumn}\" to be created. Please try again.`\n            );\n          }\n        }\n\n        const currentFilters = ctx.getVisState().filters ?? [];\n        const targetFilter = currentFilters[filterIdx];\n\n        let resolvedInterval: IntervalKey | string | undefined = interval;\n\n        if (targetFilter?.domain && targetFilter.domain.length === 2) {\n          if (!resolvedInterval) {\n            let mappedValues: number[] | undefined;\n            const fieldIdx = dataset.fields?.indexOf(filterField) ?? -1;\n            if (fieldIdx >= 0 && dataset.dataContainer) {\n              const rows = dataset.dataContainer.numRows();\n              mappedValues = [];\n              // Sample a bounded number of rows — iterating every row can freeze\n              // the UI thread on large datasets, and a sample is enough for a\n              // reasonable interval estimate.\n              const MAX_SAMPLES = 1000;\n              const step = Math.max(1, Math.floor(rows / MAX_SAMPLES));\n              for (let i = 0; i < rows; i += step) {\n                const val = dataset.dataContainer.valueAt(i, fieldIdx);\n                if (val != null) {\n                  const ts = typeof val === 'number' ? val : new Date(val as any).getTime();\n                  if (!isNaN(ts)) mappedValues.push(ts);\n                }\n              }\n            }\n            resolvedInterval = detectIntervalFromDomain(\n              targetFilter.domain as [number, number],\n              mappedValues\n            );\n          }\n\n          ctx.dispatch(setFilter(filterIdx, 'plotType', {interval: resolvedInterval}));\n          ctx.dispatch(setFilterAnimationWindow({id: filterId, animationWindow: 'free'}));\n\n          // Poll for timeBins to become available (kepler computes them async).\n          let datasetBins: {x0: number; x1: number}[] | undefined;\n          for (let attempt = 0; attempt < 10; attempt++) {\n            await sleep(200);\n            const updatedFilter = ctx.getVisState().filters?.[filterIdx];\n            if (updatedFilter?.domain && updatedFilter.domain.length === 2) {\n              // timeBins is keyed by dataset id, then by interval:\n              // {[dataId]: {[interval]: bins[]}}. Look up the bins for THIS\n              // filter's dataset — grabbing the first entry via\n              // Object.values(timeBins)[0] would pick the wrong dataset's bins\n              // when multiple datasets/filters exist, animating against the\n              // wrong time window.\n              const timeBins = (updatedFilter as any).timeBins;\n              const bins = timeBins?.[datasetId]?.[resolvedInterval as string];\n              if (bins && bins.length > 0) {\n                datasetBins = bins;\n                break;\n              }\n            }\n          }\n\n          const finalFilter = ctx.getVisState().filters?.[filterIdx];\n          if (finalFilter?.domain && finalFilter.domain.length === 2) {\n            if (datasetBins && datasetBins.length > 0) {\n              ctx.dispatch(\n                setFilterAnimationTime(filterIdx, 'value', [datasetBins[0].x0, datasetBins[0].x1])\n              );\n            } else {\n              const domainStart = (finalFilter.domain as number[])[0];\n              const windowSize = INTERVAL_MILLIS[resolvedInterval as IntervalKey] ?? MILLIS_YEAR;\n              ctx.dispatch(\n                setFilterAnimationTime(filterIdx, 'value', [domainStart, domainStart + windowSize])\n              );\n            }\n          }\n        }\n\n        return {\n          success: true,\n          commandId: addTimeFilterCommandId,\n          data: {\n            details: `Time filter added on column \"${dateTimeColumn}\" for dataset \"${datasetName}\" (interval: ${\n              resolvedInterval ?? 'auto'\n            }, filter index: ${filterIdx}). The time controller is now visible at the bottom of the map.`,\n            filterIndex: filterIdx,\n            interval: resolvedInterval\n          }\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: addTimeFilterCommandId,\n          error: error instanceof Error ? error.message : 'Unknown error',\n          data: {\n            instruction:\n              'Check that the dataset exists, the column is a TIMESTAMP/DATE, and a layer for the dataset is already on the map. Do not retry more than once.'\n          }\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/commands/toggle-time-filter-command.js

@@ -0,0 +1,147 @@
+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
+
+import { z } from 'zod';
+import { setFilterView } from '@kepler.gl/actions';
+export var toggleTimeFilterCommandId = 'map.toggle-time-filter';
+export function getToggleTimeFilterCommand(ctx) {
+  return {
+    id: toggleTimeFilterCommandId,
+    name: 'Toggle time controller',
+    group: 'Map',
+    description: "Show or hide the enlarged time controller at the bottom of the map.\n\nA time filter must already exist on the map (created via map.add-time-filter).\n\n- action: \"show\" \u2014 enlarge the time controller so it is visible at the bottom of the map.\n- action: \"hide\" \u2014 collapse the time controller back to the side panel.",
+    metadata: {
+      readOnly: false,
+      riskLevel: 'low',
+      idempotent: true
+    },
+    inputSchema: z.object({
+      action: z["enum"](['show', 'hide']).describe('"show" enlarges the time controller at the bottom of the map; "hide" collapses it to the side panel.'),
+      filterIndex: z.number().optional().describe('Index of the time filter to toggle. If omitted, the first time-range filter found is used.')
+    }),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_execCtx, input) {
+        var _ref, action, filterIndex, _visState$filters, visState, filters, targetIdx, found, view;
+        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, filterIndex = _ref.filterIndex;
+              _context.prev = 1;
+              if (!(action !== 'show' && action !== 'hide')) {
+                _context.next = 4;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: toggleTimeFilterCommandId,
+                error: "Invalid action \"".concat(String(action), "\". Must be \"show\" or \"hide\"."),
+                data: {
+                  instruction: 'Pass action: "show" to enlarge the time controller, or "hide" to collapse it.'
+                }
+              });
+            case 4:
+              if (!(filterIndex !== undefined && (!Number.isInteger(filterIndex) || filterIndex < 0))) {
+                _context.next = 6;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: toggleTimeFilterCommandId,
+                error: "Invalid filterIndex \"".concat(String(filterIndex), "\". Must be a non-negative integer."),
+                data: {
+                  instruction: 'Pass filterIndex as a non-negative integer, or omit it to auto-detect the first time filter.'
+                }
+              });
+            case 6:
+              visState = ctx.getVisState();
+              filters = (_visState$filters = visState.filters) !== null && _visState$filters !== void 0 ? _visState$filters : [];
+              if (!(filters.length === 0)) {
+                _context.next = 10;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: toggleTimeFilterCommandId,
+                error: 'No filters found on the map. Add a time filter first via map.add-time-filter.',
+                data: {
+                  instruction: 'Call map.add-time-filter before map.toggle-time-filter.'
+                }
+              });
+            case 10:
+              if (!(filterIndex === undefined)) {
+                _context.next = 17;
+                break;
+              }
+              found = filters.findIndex(function (f) {
+                return f.type === 'timeRange' || f.type === 'time';
+              }); // Don't fall back to index 0 when no time filter exists — toggling
+              // the first (non-time) filter would mutate an unrelated filter,
+              // contradicting the "a time filter must already exist" contract.
+              if (!(found < 0)) {
+                _context.next = 14;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: toggleTimeFilterCommandId,
+                error: 'No time filter found on the map. Add a time filter first via map.add-time-filter.',
+                data: {
+                  instruction: 'Call map.add-time-filter before map.toggle-time-filter.'
+                }
+              });
+            case 14:
+              targetIdx = found;
+              _context.next = 18;
+              break;
+            case 17:
+              targetIdx = filterIndex;
+            case 18:
+              if (!(targetIdx < 0 || targetIdx >= filters.length)) {
+                _context.next = 20;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: toggleTimeFilterCommandId,
+                error: "Filter index ".concat(targetIdx, " is out of range. There are ").concat(filters.length, " filter(s)."),
+                data: {
+                  instruction: "Use a filterIndex between 0 and ".concat(filters.length - 1, ".")
+                }
+              });
+            case 20:
+              view = action === 'show' ? 'enlarged' : 'side';
+              ctx.dispatch(setFilterView(targetIdx, view));
+              return _context.abrupt("return", {
+                success: true,
+                commandId: toggleTimeFilterCommandId,
+                data: {
+                  details: action === 'show' ? "Time filter at index ".concat(targetIdx, " is now enlarged. The time controller is visible at the bottom of the map.") : "Time filter at index ".concat(targetIdx, " has been collapsed back to the side panel.")
+                }
+              });
+            case 25:
+              _context.prev = 25;
+              _context.t0 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: toggleTimeFilterCommandId,
+                error: _context.t0 instanceof Error ? _context.t0.message : 'Unknown error',
+                data: {
+                  instruction: 'Check that a time filter exists. If the error persists, ask the user to try with different parameters.'
+                }
+              });
+            case 28:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 25]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["z","setFilterView","toggleTimeFilterCommandId","getToggleTimeFilterCommand","ctx","id","name","group","description","metadata","readOnly","riskLevel","idempotent","inputSchema","object","action","describe","filterIndex","number","optional","execute","_execute","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_execCtx","input","_ref","_visState$filters","visState","filters","targetIdx","found","view","wrap","_callee$","_context","prev","next","abrupt","success","commandId","error","concat","String","data","instruction","undefined","Number","isInteger","getVisState","length","findIndex","f","type","dispatch","details","t0","Error","message","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/toggle-time-filter-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 {setFilterView} from '@kepler.gl/actions';\nimport type {KeplerContext} from './types';\n\nexport const toggleTimeFilterCommandId = 'map.toggle-time-filter' as const;\n\nexport function getToggleTimeFilterCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: toggleTimeFilterCommandId,\n    name: 'Toggle time controller',\n    group: 'Map',\n    description: `Show or hide the enlarged time controller at the bottom of the map.\n\nA time filter must already exist on the map (created via map.add-time-filter).\n\n- action: \"show\" — enlarge the time controller so it is visible at the bottom of the map.\n- action: \"hide\" — collapse the time controller back to the side panel.`,\n    metadata: {readOnly: false, riskLevel: 'low', idempotent: true},\n    inputSchema: z.object({\n      action: z\n        .enum(['show', 'hide'])\n        .describe(\n          '\"show\" enlarges the time controller at the bottom of the map; \"hide\" collapses it to the side panel.'\n        ),\n      filterIndex: z\n        .number()\n        .optional()\n        .describe(\n          'Index of the time filter to toggle. If omitted, the first time-range filter found is used.'\n        )\n    }) as any,\n    execute: async (_execCtx, input) => {\n      const {action, filterIndex} = (input ?? {}) as {\n        action: 'show' | 'hide';\n        filterIndex?: number;\n      };\n      try {\n        // Runtime guard: the bridge/webMCP call execute directly without zod\n        // parsing, so a missing/invalid action must not silently fall back to\n        // 'side' (which would hide the controller — a surprising mutation).\n        if (action !== 'show' && action !== 'hide') {\n          return {\n            success: false,\n            commandId: toggleTimeFilterCommandId,\n            error: `Invalid action \"${String(action)}\". Must be \"show\" or \"hide\".`,\n            data: {\n              instruction:\n                'Pass action: \"show\" to enlarge the time controller, or \"hide\" to collapse it.'\n            }\n          };\n        }\n        // Runtime guard: the bridge/webMCP call execute without zod parsing, so\n        // a string/float filterIndex must not slip through and be dispatched\n        // into setFilterView (breaking reducer logic / toggling the wrong\n        // filter). Reject anything that isn't a non-negative integer.\n        if (filterIndex !== undefined && (!Number.isInteger(filterIndex) || filterIndex < 0)) {\n          return {\n            success: false,\n            commandId: toggleTimeFilterCommandId,\n            error: `Invalid filterIndex \"${String(filterIndex)}\". Must be a non-negative integer.`,\n            data: {\n              instruction:\n                'Pass filterIndex as a non-negative integer, or omit it to auto-detect the first time filter.'\n            }\n          };\n        }\n\n        const visState = ctx.getVisState();\n        const filters = visState.filters ?? [];\n\n        if (filters.length === 0) {\n          return {\n            success: false,\n            commandId: toggleTimeFilterCommandId,\n            error: 'No filters found on the map. Add a time filter first via map.add-time-filter.',\n            data: {instruction: 'Call map.add-time-filter before map.toggle-time-filter.'}\n          };\n        }\n\n        let targetIdx: number;\n        if (filterIndex === undefined) {\n          const found = filters.findIndex((f: any) => f.type === 'timeRange' || f.type === 'time');\n          // Don't fall back to index 0 when no time filter exists — toggling\n          // the first (non-time) filter would mutate an unrelated filter,\n          // contradicting the \"a time filter must already exist\" contract.\n          if (found < 0) {\n            return {\n              success: false,\n              commandId: toggleTimeFilterCommandId,\n              error:\n                'No time filter found on the map. Add a time filter first via map.add-time-filter.',\n              data: {instruction: 'Call map.add-time-filter before map.toggle-time-filter.'}\n            };\n          }\n          targetIdx = found;\n        } else {\n          targetIdx = filterIndex;\n        }\n\n        if (targetIdx < 0 || targetIdx >= filters.length) {\n          return {\n            success: false,\n            commandId: toggleTimeFilterCommandId,\n            error: `Filter index ${targetIdx} is out of range. There are ${filters.length} filter(s).`,\n            data: {instruction: `Use a filterIndex between 0 and ${filters.length - 1}.`}\n          };\n        }\n\n        const view = action === 'show' ? 'enlarged' : 'side';\n        ctx.dispatch(setFilterView(targetIdx, view as any));\n\n        return {\n          success: true,\n          commandId: toggleTimeFilterCommandId,\n          data: {\n            details:\n              action === 'show'\n                ? `Time filter at index ${targetIdx} is now enlarged. The time controller is visible at the bottom of the map.`\n                : `Time filter at index ${targetIdx} has been collapsed back to the side panel.`\n          }\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: toggleTimeFilterCommandId,\n          error: error instanceof Error ? error.message : 'Unknown error',\n          data: {\n            instruction:\n              'Check that a time filter exists. If the error persists, ask the user to try with different parameters.'\n          }\n        };\n      }\n    }\n  };\n}\n"],"mappings":";;AAAA;AACA;;AAGA,SAAQA,CAAC,QAAO,KAAK;AACrB,SAAQC,aAAa,QAAO,oBAAoB;AAGhD,OAAO,IAAMC,yBAAyB,GAAG,wBAAiC;AAE1E,OAAO,SAASC,0BAA0BA,CAACC,GAAkB,EAAe;EAC1E,OAAO;IACLC,EAAE,EAAEH,yBAAyB;IAC7BI,IAAI,EAAE,wBAAwB;IAC9BC,KAAK,EAAE,KAAK;IACZC,WAAW,6UAKyD;IACpEC,QAAQ,EAAE;MAACC,QAAQ,EAAE,KAAK;MAAEC,SAAS,EAAE,KAAK;MAAEC,UAAU,EAAE;IAAI,CAAC;IAC/DC,WAAW,EAAEb,CAAC,CAACc,MAAM,CAAC;MACpBC,MAAM,EAAEf,CAAC,QACF,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CACtBgB,QAAQ,CACP,sGACF,CAAC;MACHC,WAAW,EAAEjB,CAAC,CACXkB,MAAM,CAAC,CAAC,CACRC,QAAQ,CAAC,CAAC,CACVH,QAAQ,CACP,4FACF;IACJ,CAAC,CAAQ;IACTI,OAAO;MAAA,IAAAC,QAAA,GAAAC,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAC,QAAOC,QAAQ,EAAEC,KAAK;QAAA,IAAAC,IAAA,EAAAb,MAAA,EAAAE,WAAA,EAAAY,iBAAA,EAAAC,QAAA,EAAAC,OAAA,EAAAC,SAAA,EAAAC,KAAA,EAAAC,IAAA;QAAA,OAAAX,mBAAA,CAAAY,IAAA,UAAAC,SAAAC,QAAA;UAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;YAAA;cAAAX,IAAA,GACED,KAAK,aAALA,KAAK,cAALA,KAAK,GAAI,CAAC,CAAC,EAAnCZ,MAAM,GAAAa,IAAA,CAANb,MAAM,EAAEE,WAAW,GAAAW,IAAA,CAAXX,WAAW;cAAAoB,QAAA,CAAAC,IAAA;cAAA,MAQpBvB,MAAM,KAAK,MAAM,IAAIA,MAAM,KAAK,MAAM;gBAAAsB,QAAA,CAAAE,IAAA;gBAAA;cAAA;cAAA,OAAAF,QAAA,CAAAG,MAAA,WACjC;gBACLC,OAAO,EAAE,KAAK;gBACdC,SAAS,EAAExC,yBAAyB;gBACpCyC,KAAK,sBAAAC,MAAA,CAAqBC,MAAM,CAAC9B,MAAM,CAAC,sCAA8B;gBACtE+B,IAAI,EAAE;kBACJC,WAAW,EACT;gBACJ;cACF,CAAC;YAAA;cAAA,MAMC9B,WAAW,KAAK+B,SAAS,KAAK,CAACC,MAAM,CAACC,SAAS,CAACjC,WAAW,CAAC,IAAIA,WAAW,GAAG,CAAC,CAAC;gBAAAoB,QAAA,CAAAE,IAAA;gBAAA;cAAA;cAAA,OAAAF,QAAA,CAAAG,MAAA,WAC3E;gBACLC,OAAO,EAAE,KAAK;gBACdC,SAAS,EAAExC,yBAAyB;gBACpCyC,KAAK,2BAAAC,MAAA,CAA0BC,MAAM,CAAC5B,WAAW,CAAC,wCAAoC;gBACtF6B,IAAI,EAAE;kBACJC,WAAW,EACT;gBACJ;cACF,CAAC;YAAA;cAGGjB,QAAQ,GAAG1B,GAAG,CAAC+C,WAAW,CAAC,CAAC;cAC5BpB,OAAO,IAAAF,iBAAA,GAAGC,QAAQ,CAACC,OAAO,cAAAF,iBAAA,cAAAA,iBAAA,GAAI,EAAE;cAAA,MAElCE,OAAO,CAACqB,MAAM,KAAK,CAAC;gBAAAf,QAAA,CAAAE,IAAA;gBAAA;cAAA;cAAA,OAAAF,QAAA,CAAAG,MAAA,WACf;gBACLC,OAAO,EAAE,KAAK;gBACdC,SAAS,EAAExC,yBAAyB;gBACpCyC,KAAK,EAAE,+EAA+E;gBACtFG,IAAI,EAAE;kBAACC,WAAW,EAAE;gBAAyD;cAC/E,CAAC;YAAA;cAAA,MAIC9B,WAAW,KAAK+B,SAAS;gBAAAX,QAAA,CAAAE,IAAA;gBAAA;cAAA;cACrBN,KAAK,GAAGF,OAAO,CAACsB,SAAS,CAAC,UAACC,CAAM;gBAAA,OAAKA,CAAC,CAACC,IAAI,KAAK,WAAW,IAAID,CAAC,CAACC,IAAI,KAAK,MAAM;cAAA,EAAC,EACxF;cACA;cACA;cAAA,MACItB,KAAK,GAAG,CAAC;gBAAAI,QAAA,CAAAE,IAAA;gBAAA;cAAA;cAAA,OAAAF,QAAA,CAAAG,MAAA,WACJ;gBACLC,OAAO,EAAE,KAAK;gBACdC,SAAS,EAAExC,yBAAyB;gBACpCyC,KAAK,EACH,mFAAmF;gBACrFG,IAAI,EAAE;kBAACC,WAAW,EAAE;gBAAyD;cAC/E,CAAC;YAAA;cAEHf,SAAS,GAAGC,KAAK;cAACI,QAAA,CAAAE,IAAA;cAAA;YAAA;cAElBP,SAAS,GAAGf,WAAW;YAAC;cAAA,MAGtBe,SAAS,GAAG,CAAC,IAAIA,SAAS,IAAID,OAAO,CAACqB,MAAM;gBAAAf,QAAA,CAAAE,IAAA;gBAAA;cAAA;cAAA,OAAAF,QAAA,CAAAG,MAAA,WACvC;gBACLC,OAAO,EAAE,KAAK;gBACdC,SAAS,EAAExC,yBAAyB;gBACpCyC,KAAK,kBAAAC,MAAA,CAAkBZ,SAAS,kCAAAY,MAAA,CAA+Bb,OAAO,CAACqB,MAAM,gBAAa;gBAC1FN,IAAI,EAAE;kBAACC,WAAW,qCAAAH,MAAA,CAAqCb,OAAO,CAACqB,MAAM,GAAG,CAAC;gBAAG;cAC9E,CAAC;YAAA;cAGGlB,IAAI,GAAGnB,MAAM,KAAK,MAAM,GAAG,UAAU,GAAG,MAAM;cACpDX,GAAG,CAACoD,QAAQ,CAACvD,aAAa,CAAC+B,SAAS,EAAEE,IAAW,CAAC,CAAC;cAAC,OAAAG,QAAA,CAAAG,MAAA,WAE7C;gBACLC,OAAO,EAAE,IAAI;gBACbC,SAAS,EAAExC,yBAAyB;gBACpC4C,IAAI,EAAE;kBACJW,OAAO,EACL1C,MAAM,KAAK,MAAM,2BAAA6B,MAAA,CACWZ,SAAS,0GAAAY,MAAA,CACTZ,SAAS;gBACzC;cACF,CAAC;YAAA;cAAAK,QAAA,CAAAC,IAAA;cAAAD,QAAA,CAAAqB,EAAA,GAAArB,QAAA;cAAA,OAAAA,QAAA,CAAAG,MAAA,WAEM;gBACLC,OAAO,EAAE,KAAK;gBACdC,SAAS,EAAExC,yBAAyB;gBACpCyC,KAAK,EAAEN,QAAA,CAAAqB,EAAA,YAAiBC,KAAK,GAAGtB,QAAA,CAAAqB,EAAA,CAAME,OAAO,GAAG,eAAe;gBAC/Dd,IAAI,EAAE;kBACJC,WAAW,EACT;gBACJ;cACF,CAAC;YAAA;YAAA;cAAA,OAAAV,QAAA,CAAAwB,IAAA;UAAA;QAAA,GAAApC,OAAA;MAAA,CAEJ;MAAA,SArGDL,OAAOA,CAAA0C,EAAA,EAAAC,GAAA;QAAA,OAAA1C,QAAA,CAAA2C,KAAA,OAAAC,SAAA;MAAA;MAAA,OAAP7C,OAAO;IAAA;EAsGT,CAAC;AACH","ignoreList":[]}

package/dist/esm/commands/types.js

@@ -0,0 +1,3 @@
+export {};
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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