@vuu-ui/vuu-data-local 0.13.6 → 0.13.8

package/cjs/index.js

@@ -1,12 +1,1998 @@
 'use strict';
 
-var arrayDataSource = require('./array-data-source/array-data-source.js');
-var JsonDataSource = require('./json-data-source/JsonDataSource.js');
-var TreeDataSource = require('./tree-data-source/TreeDataSource.js');
+var vuuFilterParser = require('@vuu-ui/vuu-filter-parser');
+var vuuUtils = require('@vuu-ui/vuu-utils');
 
+const aggregateData = (aggregations, targetData, groupBy, leafData, columnMap, groupMap) => {
+  const aggType = aggregations[aggregations.length - 1].aggType;
+  const groupIndices = groupBy.map((column) => columnMap[column]);
+  switch (aggType) {
+    case 1:
+      return aggregateSum(
+        groupMap,
+        leafData,
+        columnMap,
+        aggregations,
+        targetData,
+        groupIndices
+      );
+    case 2:
+      return aggregateAverage(
+        groupMap,
+        leafData,
+        columnMap,
+        aggregations,
+        targetData,
+        groupIndices
+      );
+    case 3:
+      return aggregateCount(
+        groupMap,
+        columnMap,
+        aggregations,
+        targetData,
+        groupIndices
+      );
+    case 4:
+      return aggregateHigh(
+        groupMap,
+        leafData,
+        columnMap,
+        aggregations,
+        targetData,
+        groupIndices
+      );
+    case 5:
+      return aggregateLow(
+        groupMap,
+        leafData,
+        columnMap,
+        aggregations,
+        targetData,
+        groupIndices
+      );
+    case 6:
+      return aggregateDistinct(
+        groupMap,
+        leafData,
+        columnMap,
+        aggregations,
+        targetData,
+        groupIndices
+      );
+  }
+};
+function aggregateCount(groupMap, columnMap, aggregations, targetData, groupIndices) {
+  const counts = {};
+  const aggColumn = getAggColumn(columnMap, aggregations);
+  function countRecursive(map) {
+    if (Array.isArray(map)) {
+      return map.length;
+    } else {
+      let count2 = 0;
+      for (const key in map) {
+        count2 += 1 + countRecursive(map[key]);
+      }
+      return count2;
+    }
+  }
+  for (const key in groupMap) {
+    const count2 = countRecursive(groupMap[key]);
+    counts[key] = count2;
+  }
+  for (let index = 0; index < targetData.length; index++) {
+    for (const key in counts) {
+      if (targetData[index][groupIndices[0]] === key) {
+        targetData[index][aggColumn] = counts[key];
+      }
+    }
+  }
+  return counts;
+}
+function getAggColumn(columnMap, aggregations) {
+  const columnName = aggregations[aggregations.length - 1].column;
+  const columnNumber = columnMap[columnName];
+  return columnNumber;
+}
+function aggregateSum(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
+  const sums = {};
+  const aggColumn = getAggColumn(columnMap, aggregations);
+  function sumRecursive(map, leafData2, aggColumn2) {
+    if (Array.isArray(map)) {
+      let sum = 0;
+      for (const key of map) {
+        sum += Number(leafData2[key][aggColumn2]);
+      }
+      return sum;
+    } else {
+      let sum = 0;
+      for (const key in map) {
+        sum += sumRecursive(map[key], leafData2, aggColumn2);
+      }
+      return sum;
+    }
+  }
+  for (const key in groupMap) {
+    const sum = Number(sumRecursive(groupMap[key], leafData, aggColumn));
+    sums[key] = sum;
+  }
+  for (let index = 0; index < targetData.length; index++) {
+    for (const key in sums) {
+      if (targetData[index][groupIndices[0]] === key) {
+        targetData[index][aggColumn] = sums[key];
+      }
+    }
+  }
+  return sums;
+}
+function aggregateAverage(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
+  const averages = {};
+  const aggColumn = getAggColumn(columnMap, aggregations);
+  const count2 = aggregateCount(
+    groupMap,
+    columnMap,
+    aggregations,
+    targetData,
+    groupIndices
+  );
+  const sum = aggregateSum(
+    groupMap,
+    leafData,
+    columnMap,
+    aggregations,
+    targetData,
+    groupIndices
+  );
+  for (const key in count2) {
+    let average = 0;
+    average = sum[key] / count2[key];
+    averages[key] = average;
+  }
+  for (let index = 0; index < targetData.length; index++) {
+    for (const key in averages) {
+      if (targetData[index][groupIndices[0]] === key) {
+        targetData[index][aggColumn] = averages[key];
+      }
+    }
+  }
+  console.log("!!!! targetData", targetData);
+  console.log("!!!! averages", averages);
+  return averages;
+}
+function getLeafColumnData(map, leafData, aggColumn) {
+  const data = [];
+  if (Array.isArray(map)) {
+    for (const key of map) {
+      data.push(leafData[key][aggColumn]);
+    }
+  } else {
+    for (const key in map) {
+      data.push(...getLeafColumnData(map[key], leafData, aggColumn));
+    }
+  }
+  return data;
+}
+function aggregateDistinct(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
+  const distincts = {};
+  const aggColumn = getAggColumn(columnMap, aggregations);
+  for (const key in groupMap) {
+    const leafColumnData = getLeafColumnData(
+      groupMap[key],
+      leafData,
+      aggColumn
+    );
+    const distinct = [...new Set(leafColumnData)];
+    distincts[key] = distinct.length;
+  }
+  for (let index = 0; index < targetData.length; index++) {
+    for (const key in distincts) {
+      if (targetData[index][groupIndices[0]] === key) {
+        targetData[index][aggColumn] = distincts[key];
+      }
+    }
+  }
+  return distincts;
+}
+function aggregateHigh(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
+  const highs = {};
+  const aggColumn = getAggColumn(columnMap, aggregations);
+  for (const key in groupMap) {
+    const leafColumnData = getLeafColumnData(
+      groupMap[key],
+      leafData,
+      aggColumn
+    );
+    const maxNumber = Math.max(...leafColumnData);
+    highs[key] = maxNumber;
+  }
+  for (let index = 0; index < targetData.length; index++) {
+    for (const key in highs) {
+      if (targetData[index][groupIndices[0]] === key) {
+        targetData[index][aggColumn] = highs[key];
+      }
+    }
+  }
+  return highs;
+}
+function aggregateLow(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
+  const mins = {};
+  const aggColumn = getAggColumn(columnMap, aggregations);
+  for (const key in groupMap) {
+    const leafColumnData = getLeafColumnData(
+      groupMap[key],
+      leafData,
+      aggColumn
+    );
+    const minNumber = Math.min(...leafColumnData);
+    mins[key] = minNumber;
+  }
+  for (let index = 0; index < targetData.length; index++) {
+    for (const key in mins) {
+      if (targetData[index][groupIndices[0]] === key) {
+        targetData[index][aggColumn] = mins[key];
+      }
+    }
+  }
+  return mins;
+}
 
+const { RENDER_IDX, SELECTED: SELECTED$2 } = vuuUtils.metadataKeys;
+const toClientRow$2 = (row, keys, selection, dataIndices) => {
+  const [rowIndex] = row;
+  let clientRow;
+  if (dataIndices) {
+    const { count } = vuuUtils.metadataKeys;
+    clientRow = row.slice(0, count).concat(dataIndices.map((idx) => row[idx]));
+  } else {
+    clientRow = row.slice();
+  }
+  clientRow[RENDER_IDX] = keys.keyFor(rowIndex);
+  clientRow[SELECTED$2] = vuuUtils.getSelectionStatus(selection, rowIndex);
+  return clientRow;
+};
+const divergentMaps = (columnMap, dataMap) => {
+  if (dataMap) {
+    const { count: mapOffset } = vuuUtils.metadataKeys;
+    for (const [columnName, index] of Object.entries(columnMap)) {
+      const dataIdx = dataMap[columnName];
+      if (dataIdx === void 0) {
+        throw Error(
+          `ArrayDataSource column ${columnName} is not in underlying data set`
+        );
+      } else if (dataIdx !== index - mapOffset) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+const getDataIndices = (columnMap, dataMap) => {
+  const { count: mapOffset } = vuuUtils.metadataKeys;
+  const result = [];
+  Object.entries(columnMap).forEach(([columnName]) => {
+    result.push(dataMap[columnName] + mapOffset);
+  });
+  return result;
+};
+const buildDataToClientMap = (columnMap, dataMap) => {
+  if (dataMap && divergentMaps(columnMap, dataMap)) {
+    return getDataIndices(columnMap, dataMap);
+  }
+  return void 0;
+};
 
-exports.ArrayDataSource = arrayDataSource.ArrayDataSource;
-exports.JsonDataSource = JsonDataSource.JsonDataSource;
-exports.TreeDataSource = TreeDataSource.TreeDataSource;
+const { DEPTH: DEPTH$2, IS_EXPANDED: IS_EXPANDED$2, KEY: KEY$4 } = vuuUtils.metadataKeys;
+const collapseGroup = (key, groupedRows) => {
+  const rows = [];
+  for (let i = 0, idx = 0, collapsed = false, len = groupedRows.length; i < len; i++) {
+    const row = groupedRows[i];
+    const { [DEPTH$2]: depth, [KEY$4]: rowKey } = row;
+    if (rowKey === key) {
+      const collapsedRow = row.slice();
+      collapsedRow[IS_EXPANDED$2] = false;
+      rows.push(collapsedRow);
+      idx += 1;
+      collapsed = true;
+      while (i < len - 1 && groupedRows[i + 1][DEPTH$2] > depth) {
+        i += 1;
+      }
+    } else if (collapsed) {
+      const newRow = row.slice();
+      newRow[0] = idx;
+      newRow[1] = idx;
+      rows.push(newRow);
+      idx += 1;
+    } else {
+      rows.push(row);
+      idx += 1;
+    }
+  }
+  return rows;
+};
+const expandGroup = (keys, sourceRows, groupBy, columnMap, groupMap, processedData) => {
+  const groupIndices = groupBy.map((column) => columnMap[column]);
+  return dataRowsFromGroups2(
+    groupMap,
+    groupIndices,
+    keys,
+    sourceRows,
+    void 0,
+    void 0,
+    void 0,
+    processedData
+  );
+};
+const dataRowsFromGroups2 = (groupMap, groupIndices, openKeys, sourceRows = [], root = "$root", depth = 1, rows = [], processedData) => {
+  const keys = Object.keys(groupMap).sort();
+  for (const key of keys) {
+    const idx = rows.length;
+    const groupKey = `${root}|${key}`;
+    const row = [
+      idx,
+      idx,
+      false,
+      false,
+      depth,
+      childCount(groupMap[key]),
+      groupKey,
+      0
+    ];
+    row[groupIndices[depth - 1]] = key;
+    rows.push(row);
+    if (openKeys.includes(groupKey)) {
+      row[IS_EXPANDED$2] = true;
+      if (Array.isArray(groupMap[key])) {
+        pushChildren(
+          rows,
+          groupMap[key],
+          sourceRows,
+          groupKey,
+          depth + 1
+        );
+      } else {
+        dataRowsFromGroups2(
+          groupMap[key],
+          groupIndices,
+          openKeys,
+          sourceRows,
+          groupKey,
+          depth + 1,
+          rows,
+          processedData
+        );
+      }
+    }
+  }
+  for (const key in rows) {
+    for (const index in rows) {
+      if (rows[key][2] === false && processedData[index] != void 0) {
+        if (rows[key][groupIndices[0]] === processedData[index][groupIndices[0]]) {
+          rows[key] = rows[key].splice(0, 8).concat(
+            processedData[index].slice(
+              8,
+              // groupIndices[0] + 1,
+              processedData[index].length
+            )
+          );
+          break;
+        }
+      }
+    }
+  }
+  return rows;
+};
+const pushChildren = (rows, tree, sourceRows, parentKey, depth) => {
+  for (const rowIdx of tree) {
+    const idx = rows.length;
+    const sourceRow = sourceRows[rowIdx].slice();
+    sourceRow[0] = idx;
+    sourceRow[1] = idx;
+    sourceRow[DEPTH$2] = depth;
+    sourceRow[KEY$4] = `${parentKey}|${sourceRow[KEY$4]}`;
+    rows.push(sourceRow);
+  }
+};
+const groupRows = (rows, groupBy, columnMap) => {
+  const groupIndices = groupBy.map((column) => columnMap[column]);
+  const groupTree = groupLeafRows(rows, groupIndices);
+  const groupedDataRows = dataRowsFromGroups(groupTree, groupIndices);
+  return [groupedDataRows, groupTree];
+};
+const dataRowsFromGroups = (groupTree, groupIndices) => {
+  const depth = 0;
+  const rows = [];
+  let idx = 0;
+  const keys = Object.keys(groupTree).sort();
+  for (const key of keys) {
+    const row = [
+      idx,
+      idx,
+      false,
+      false,
+      1,
+      childCount(groupTree[key]),
+      `$root|${key}`,
+      0
+    ];
+    row[groupIndices[depth]] = key;
+    rows.push(row);
+    idx += 1;
+  }
+  return rows;
+};
+function childCount(list) {
+  if (Array.isArray(list)) {
+    return list.length;
+  } else {
+    return Object.keys(list).length;
+  }
+}
+function groupLeafRows(leafRows, groupby) {
+  const groups = {};
+  const levels = groupby.length;
+  const lastLevel = levels - 1;
+  for (let i = 0, len = leafRows.length; i < len; i++) {
+    const leafRow = leafRows[i];
+    let target = groups;
+    let targetNode;
+    let key;
+    for (let level = 0; level < levels; level++) {
+      const colIdx = groupby[level];
+      key = leafRow[colIdx].toString();
+      targetNode = target[key];
+      if (targetNode && level === lastLevel) {
+        targetNode.push(i);
+      } else if (targetNode) {
+        target = targetNode;
+      } else if (!targetNode && level < lastLevel) {
+        target = target[key] = {};
+      } else if (!targetNode) {
+        target[key] = [i];
+      }
+    }
+  }
+  return groups;
+}
+
+const defaultSortPredicate = (r1, r2, [i, direction]) => {
+  const val1 = direction === "D" ? r2[i] : r1[i];
+  const val2 = direction === "D" ? r1[i] : r2[i];
+  if (val1 === val2) {
+    return 0;
+  } else if (val2 === null || val1 > val2) {
+    return 1;
+  } else {
+    return -1;
+  }
+};
+const sortComparator = (sortDefs) => {
+  if (sortDefs.length === 1) {
+    return singleColComparator(sortDefs);
+  } else if (sortDefs.length === 2) {
+    return twoColComparator(sortDefs);
+  } else {
+    return multiColComparator(sortDefs);
+  }
+};
+const singleColComparator = ([[i, direction]]) => (r1, r2) => {
+  const v1 = direction === "D" ? r2[i] : r1[i];
+  const v2 = direction === "D" ? r1[i] : r2[i];
+  return v1 > v2 ? 1 : v2 > v1 ? -1 : 0;
+};
+const twoColComparator = ([[idx1, direction1], [idx2, direction2]]) => (r1, r2) => {
+  const v1 = direction1 === "D" ? r2[idx1] : r1[idx1];
+  const v2 = direction1 === "D" ? r1[idx1] : r2[idx1];
+  const v3 = direction2 === "D" ? r2[idx2] : r1[idx2];
+  const v4 = direction2 === "D" ? r1[idx2] : r2[idx2];
+  return v1 > v2 ? 1 : v2 > v1 ? -1 : v3 > v4 ? 1 : v4 > v3 ? -1 : 0;
+};
+const multiColComparator = (sortDefs, test = defaultSortPredicate) => (r1, r2) => {
+  for (const sortDef of sortDefs) {
+    const result = test(r1, r2, sortDef);
+    if (result !== 0) {
+      return result;
+    }
+  }
+  return 0;
+};
+const sortRows = (rows, { sortDefs }, columnMap) => {
+  const indexedSortDefs = sortDefs.map(({ column, sortType }) => [
+    columnMap[column],
+    sortType
+  ]);
+  const comparator = sortComparator(indexedSortDefs);
+  return rows.slice().sort(comparator);
+};
+
+var __defProp$3 = Object.defineProperty;
+var __typeError$3 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck$3 = (obj, member, msg) => member.has(obj) || __typeError$3("Cannot " + msg);
+var __privateGet$3 = (obj, member, getter) => (__accessCheck$3(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$3 = (obj, member, value) => member.has(obj) ? __typeError$3("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$2 = (obj, member, value, setter) => (__accessCheck$3(obj, member, "write to private field"), member.set(obj, value), value);
+var _columnMap, _data$2, _keys, _links, _range$1, _selectedRowsCount$2, _status$2, _title$1;
+const { debug, info } = vuuUtils.logger("ArrayDataSource");
+const { KEY: KEY$3 } = vuuUtils.metadataKeys;
+const toDataSourceRow = (key) => (data, index) => {
+  return [index, index, true, false, 1, 0, String(data[key]), 0, ...data];
+};
+const buildTableSchema = (columns, keyColumn) => {
+  const schema = {
+    columns: columns.map(({ name, serverDataType = "string" }) => ({
+      name,
+      serverDataType
+    })),
+    key: keyColumn ?? columns[0].name,
+    table: { module: "", table: "Array" }
+  };
+  return schema;
+};
+class ArrayDataSource extends vuuUtils.EventEmitter {
+  constructor({
+    aggregations,
+    baseFilterSpec,
+    // different from RemoteDataSource
+    columnDescriptors,
+    data,
+    dataMap,
+    filterSpec,
+    groupBy,
+    keyColumn,
+    rangeChangeRowset = "delta",
+    sort,
+    title,
+    viewport
+  }) {
+    super();
+    __publicField$3(this, "clientCallback");
+    __publicField$3(this, "columnDescriptors");
+    /** sorted offsets of data within raw data, reflecting sort order
+     * of columns specified by client.
+     */
+    __publicField$3(this, "dataIndices");
+    /** Map reflecting positions of data items in raw data */
+    __publicField$3(this, "dataMap");
+    __publicField$3(this, "groupMap");
+    /** the index of key field within raw data row */
+    __publicField$3(this, "key");
+    __publicField$3(this, "lastRangeServed", { from: 0, to: 0 });
+    __publicField$3(this, "rangeChangeRowset");
+    __publicField$3(this, "openTreeNodes", []);
+    /** Map reflecting positions of columns in client data sent to user */
+    __privateAdd$3(this, _columnMap);
+    __publicField$3(this, "_config", vuuUtils.vanillaConfig);
+    __privateAdd$3(this, _data$2);
+    __privateAdd$3(this, _keys, new vuuUtils.KeySet(vuuUtils.NULL_RANGE));
+    __privateAdd$3(this, _links);
+    __privateAdd$3(this, _range$1, vuuUtils.Range(0, 0));
+    __privateAdd$3(this, _selectedRowsCount$2, 0);
+    __privateAdd$3(this, _status$2, "initialising");
+    __privateAdd$3(this, _title$1);
+    __publicField$3(this, "_menu");
+    __publicField$3(this, "selectedRows", []);
+    __publicField$3(this, "tableSchema");
+    __publicField$3(this, "viewport");
+    __publicField$3(this, "processedData");
+    __publicField$3(this, "insert", (row) => {
+      const dataSourceRow = toDataSourceRow(this.key)(row, this.size);
+      __privateGet$3(this, _data$2).push(dataSourceRow);
+      const { from, to } = __privateGet$3(this, _range$1);
+      const [rowIdx] = dataSourceRow;
+      if (rowIdx >= from && rowIdx < to) {
+        this.sendRowsToClient();
+      }
+    });
+    __publicField$3(this, "updateDataItem", (keyValue, columnName, value) => {
+      this.validateDataValue(columnName, value);
+      const colIndex = __privateGet$3(this, _columnMap)[columnName];
+      const dataColIndex = this.dataMap?.[columnName];
+      const dataIndex = this.indexOfRowWithKey(keyValue);
+      if (dataIndex !== -1 && dataColIndex !== void 0) {
+        const dataSourceRow = __privateGet$3(this, _data$2)[dataIndex];
+        dataSourceRow[colIndex] = value;
+        const { from, to } = __privateGet$3(this, _range$1);
+        const [rowIdx] = dataSourceRow;
+        if (rowIdx >= from && rowIdx < to) {
+          this.sendRowsToClient(false, dataSourceRow);
+        }
+      }
+    });
+    __publicField$3(this, "indexOfRowWithKey", (key) => __privateGet$3(this, _data$2).findIndex((row) => row[KEY$3] === key));
+    __publicField$3(this, "update", (row, columnName) => {
+      const keyValue = row[this.key];
+      const dataColIndex = this.dataMap?.[columnName];
+      return this.updateDataItem(keyValue, columnName, row[dataColIndex]);
+    });
+    __publicField$3(this, "updateRow", (row) => {
+      const keyValue = row[this.key];
+      const dataIndex = __privateGet$3(this, _data$2).findIndex((row2) => row2[KEY$3] === keyValue);
+      if (dataIndex !== -1) {
+        const dataSourceRow = toDataSourceRow(this.key)(row, dataIndex);
+        __privateGet$3(this, _data$2)[dataIndex] = dataSourceRow;
+        const { from, to } = __privateGet$3(this, _range$1);
+        if (dataIndex >= from && dataIndex < to) {
+          this.sendRowsToClient(false, dataSourceRow);
+        }
+      }
+    });
+    if (!data || !columnDescriptors) {
+      throw Error(
+        "ArrayDataSource constructor called without data or without columnDescriptors"
+      );
+    }
+    this.columnDescriptors = columnDescriptors;
+    this.dataMap = dataMap;
+    this.key = keyColumn ? this.columnDescriptors.findIndex((col) => col.name === keyColumn) : 0;
+    this.rangeChangeRowset = rangeChangeRowset;
+    this.tableSchema = buildTableSchema(columnDescriptors, keyColumn);
+    this.viewport = viewport || vuuUtils.uuid();
+    __privateSet$2(this, _title$1, title);
+    const columns = columnDescriptors.map((col) => col.name);
+    __privateSet$2(this, _columnMap, vuuUtils.buildColumnMap(columns));
+    this.dataIndices = buildDataToClientMap(__privateGet$3(this, _columnMap), this.dataMap);
+    __privateSet$2(this, _data$2, data.map(toDataSourceRow(this.key)));
+    this.config = {
+      ...this._config,
+      aggregations: aggregations || this._config.aggregations,
+      baseFilterSpec,
+      columns,
+      filterSpec: filterSpec || this._config.filterSpec,
+      groupBy: groupBy || this._config.groupBy,
+      sort: sort || this._config.sort
+    };
+    debug?.(`columnMap: ${JSON.stringify(__privateGet$3(this, _columnMap))}`);
+  }
+  async subscribe({
+    viewport = this.viewport ?? (this.viewport = vuuUtils.uuid()),
+    columns,
+    aggregations,
+    baseFilterSpec,
+    range,
+    selectedIndexValues,
+    selectedKeyValues,
+    sort,
+    groupBy,
+    filterSpec
+  }, callback) {
+    console.log(`%cArrayDataSource subscribe`, "color: red;font-weight:bold;");
+    this.clientCallback = callback;
+    this.viewport = viewport;
+    __privateSet$2(this, _status$2, "subscribed");
+    this.selectedRows = selectedIndexValues ?? this.convertKeysToIndexValues(selectedKeyValues) ?? [];
+    __privateSet$2(this, _selectedRowsCount$2, vuuUtils.selectionCount(this.selectedRows));
+    this.lastRangeServed = { from: 0, to: 0 };
+    let config = this._config;
+    const hasConfigProps = aggregations || columns || filterSpec || groupBy || sort;
+    if (hasConfigProps) {
+      if (range) {
+        this.setRange(range);
+      }
+      config = {
+        ...config,
+        aggregations: aggregations || this._config.aggregations,
+        baseFilterSpec: baseFilterSpec || this._config.baseFilterSpec,
+        columns: columns || this._config.columns,
+        filterSpec: filterSpec || this._config.filterSpec,
+        groupBy: groupBy || this._config.groupBy,
+        sort: sort || this._config.sort
+      };
+    }
+    const subscribedMessage = {
+      ...config,
+      type: "subscribed",
+      clientViewportId: this.viewport,
+      range: __privateGet$3(this, _range$1),
+      tableSchema: this.tableSchema
+    };
+    this.clientCallback?.(subscribedMessage);
+    this.emit("subscribed", subscribedMessage);
+    if (hasConfigProps) {
+      this.config = config;
+    } else {
+      this.clientCallback({
+        clientViewportId: this.viewport,
+        mode: "size-only",
+        type: "viewport-update",
+        size: __privateGet$3(this, _data$2).length
+      });
+      if (range && !__privateGet$3(this, _range$1).equals(range)) {
+        this.range = range;
+      } else if (__privateGet$3(this, _range$1) !== vuuUtils.NULL_RANGE) {
+        this.sendRowsToClient();
+      }
+      if (this.range.to !== 0) {
+        const pageCount = Math.ceil(
+          this.size / (this.range.to - this.range.from)
+        );
+        this.emit("page-count", pageCount);
+      }
+    }
+  }
+  unsubscribe() {
+    __privateSet$2(this, _status$2, "unsubscribed");
+    this.emit("unsubscribed", this.viewport);
+  }
+  suspend() {
+    if (__privateGet$3(this, _status$2) !== "unsubscribed") {
+      info?.(`suspend #${this.viewport}, current status ${__privateGet$3(this, _status$2)}`);
+      __privateSet$2(this, _status$2, "suspended");
+      this.emit("suspended", this.viewport);
+    }
+  }
+  resume(callback) {
+    const isSuspended = __privateGet$3(this, _status$2) === "suspended";
+    info?.(`resume #${this.viewport}, current status ${__privateGet$3(this, _status$2)}`);
+    if (callback) {
+      this.clientCallback = callback;
+    }
+    if (isSuspended) {
+      __privateSet$2(this, _status$2, "subscribed");
+    }
+    this.emit("resumed", this.viewport);
+    this.sendRowsToClient(true);
+  }
+  disable() {
+    this.emit("disabled", this.viewport);
+  }
+  enable() {
+    this.emit("enabled", this.viewport);
+  }
+  select(selected) {
+    __privateSet$2(this, _selectedRowsCount$2, vuuUtils.selectionCount(selected));
+    debug?.(`select ${JSON.stringify(selected)}`);
+    this.selectedRows = selected;
+    this.setRange(__privateGet$3(this, _range$1), true);
+    this.emit("row-selection", selected, __privateGet$3(this, _selectedRowsCount$2));
+  }
+  getRowKey(keyOrIndex) {
+    if (typeof keyOrIndex === "string") {
+      return keyOrIndex;
+    }
+    const row = this.getRowAtIndex(keyOrIndex);
+    if (row === void 0) {
+      throw Error(`row not found at index ${keyOrIndex}`);
+    }
+    return row?.[KEY$3];
+  }
+  openTreeNode(keyOrIndex) {
+    const key = this.getRowKey(keyOrIndex);
+    this.openTreeNodes.push(key);
+    this.processedData = expandGroup(
+      this.openTreeNodes,
+      __privateGet$3(this, _data$2),
+      this._config.groupBy,
+      __privateGet$3(this, _columnMap),
+      this.groupMap,
+      this.processedData
+    );
+    this.setRange(__privateGet$3(this, _range$1).reset, true);
+  }
+  closeTreeNode(keyOrIndex) {
+    const key = this.getRowKey(keyOrIndex);
+    this.openTreeNodes = this.openTreeNodes.filter((value) => value !== key);
+    if (this.processedData) {
+      this.processedData = collapseGroup(key, this.processedData);
+      this.setRange(__privateGet$3(this, _range$1).reset, true);
+    }
+  }
+  get pageSize() {
+    return __privateGet$3(this, _range$1).to - __privateGet$3(this, _range$1).from;
+  }
+  get links() {
+    return __privateGet$3(this, _links);
+  }
+  set links(links) {
+    __privateSet$2(this, _links, links);
+  }
+  get menu() {
+    return this._menu;
+  }
+  get status() {
+    return __privateGet$3(this, _status$2);
+  }
+  get data() {
+    return __privateGet$3(this, _data$2);
+  }
+  // Only used by the UpdateGenerator
+  get currentData() {
+    return this.processedData ?? __privateGet$3(this, _data$2);
+  }
+  get table() {
+    return this.tableSchema.table;
+  }
+  get config() {
+    return this._config;
+  }
+  set config(config) {
+    const configChanges = this.applyConfig(config);
+    if (configChanges) {
+      if (config) {
+        const originalConfig = this._config;
+        const newConfig = config?.filterSpec?.filter && config?.filterSpec.filterStruct === void 0 ? {
+          ...config,
+          filterSpec: {
+            filter: config.filterSpec.filter,
+            filterStruct: vuuFilterParser.parseFilter(config.filterSpec.filter)
+          }
+        } : config;
+        this._config = vuuUtils.withConfigDefaults(newConfig);
+        let processedData;
+        if (vuuUtils.hasFilter(config) || vuuUtils.hasBaseFilter(config)) {
+          const {
+            filterSpec: { filterStruct }
+          } = vuuUtils.combineFilters(this._config);
+          if (filterStruct) {
+            const fn = vuuFilterParser.filterPredicate(__privateGet$3(this, _columnMap), filterStruct);
+            processedData = __privateGet$3(this, _data$2).filter(fn);
+          } else {
+            throw Error("filter must include filterStruct");
+          }
+        }
+        if (vuuUtils.hasSort(config)) {
+          processedData = sortRows(
+            processedData ?? __privateGet$3(this, _data$2),
+            config.sort,
+            __privateGet$3(this, _columnMap)
+          );
+        }
+        if (this.openTreeNodes.length > 0 && vuuUtils.isGroupByChanged(originalConfig, config)) {
+          if (this._config.groupBy.length === 0) {
+            this.openTreeNodes.length = 0;
+          }
+        }
+        if (vuuUtils.hasGroupBy(config)) {
+          const [groupedData, groupMap] = groupRows(
+            processedData ?? __privateGet$3(this, _data$2),
+            config.groupBy,
+            __privateGet$3(this, _columnMap)
+          );
+          this.groupMap = groupMap;
+          processedData = groupedData;
+          if (this.openTreeNodes.length > 0) {
+            processedData = expandGroup(
+              this.openTreeNodes,
+              __privateGet$3(this, _data$2),
+              this._config.groupBy,
+              __privateGet$3(this, _columnMap),
+              this.groupMap,
+              processedData
+            );
+          }
+        }
+        this.processedData = processedData?.map((row, i) => {
+          const dolly = row.slice();
+          dolly[0] = i;
+          dolly[1] = i;
+          return dolly;
+        });
+      }
+      if (__privateGet$3(this, _status$2) === "subscribed") {
+        this.setRange(__privateGet$3(this, _range$1).reset, true);
+        this.emit("config", this._config, this.range, void 0, configChanges);
+      }
+    }
+  }
+  applyConfig(config, preserveExistingConfigAttributes = false) {
+    const { noChanges, ...otherChanges } = vuuUtils.isConfigChanged(
+      this._config,
+      config
+    );
+    if (noChanges !== true) {
+      if (config) {
+        const newConfig = config?.filterSpec?.filter && config?.filterSpec.filterStruct === void 0 ? {
+          ...config,
+          filterSpec: {
+            filter: config.filterSpec.filter,
+            filterStruct: vuuFilterParser.parseFilter(config.filterSpec.filter)
+          }
+        } : config;
+        if (preserveExistingConfigAttributes) {
+          this._config = {
+            ...this._config,
+            ...config
+          };
+        } else {
+          this._config = vuuUtils.withConfigDefaults(newConfig);
+        }
+        return otherChanges;
+      }
+    }
+  }
+  get columnMap() {
+    return __privateGet$3(this, _columnMap);
+  }
+  get selectedRowsCount() {
+    return __privateGet$3(this, _selectedRowsCount$2);
+  }
+  get size() {
+    return this.processedData?.length ?? __privateGet$3(this, _data$2).length;
+  }
+  get range() {
+    return __privateGet$3(this, _range$1);
+  }
+  set range(range) {
+    this.setRange(range);
+  }
+  getRowAtIndex(rowIndex) {
+    return this.processedData?.[rowIndex];
+  }
+  delete(row) {
+    console.log(`delete row ${row.join(",")}`);
+  }
+  validateDataValue(columnName, value) {
+    const columnDescriptor = this.columnDescriptors.find(
+      (col) => col.name === columnName
+    );
+    if (columnDescriptor) {
+      switch (columnDescriptor.serverDataType) {
+        case "int":
+          {
+            if (typeof value === "number") {
+              if (Math.floor(value) !== value) {
+                throw Error(`${columnName} is int but value = ${value}`);
+              }
+            } else if (typeof value === "string") {
+              const numericValue = parseFloat(value);
+              if (Math.floor(numericValue) !== numericValue) {
+                throw Error(`${columnName} is ${value} is not a valid integer`);
+              }
+            }
+          }
+          break;
+      }
+    } else {
+      throw Error(`Unknown column ${columnName}`);
+    }
+  }
+  setRange(range, forceFullRefresh = false) {
+    if (range.from !== __privateGet$3(this, _range$1).from || range.to !== __privateGet$3(this, _range$1).to) {
+      const currentPageCount = Math.ceil(
+        this.size / (__privateGet$3(this, _range$1).to - __privateGet$3(this, _range$1).from)
+      );
+      const newPageCount = Math.ceil(this.size / (range.to - range.from));
+      __privateSet$2(this, _range$1, range);
+      const keysResequenced = __privateGet$3(this, _keys).reset(range);
+      this.sendRowsToClient(forceFullRefresh || keysResequenced);
+      requestAnimationFrame(() => {
+        if (newPageCount !== currentPageCount) {
+          this.emit("page-count", newPageCount);
+        }
+        this.emit("range", range);
+      });
+    } else if (forceFullRefresh) {
+      this.sendRowsToClient(forceFullRefresh);
+    }
+  }
+  sendRowsToClient(forceFullRefresh = false, row) {
+    if (row) {
+      this.clientCallback?.({
+        clientViewportId: this.viewport,
+        mode: "update",
+        rows: [
+          toClientRow$2(row, __privateGet$3(this, _keys), this.selectedRows, this.dataIndices)
+        ],
+        type: "viewport-update"
+      });
+    } else {
+      const rowRange = this.rangeChangeRowset === "delta" && !forceFullRefresh ? vuuUtils.rangeNewItems(this.lastRangeServed, __privateGet$3(this, _range$1)) : __privateGet$3(this, _range$1);
+      const data = this.processedData ?? __privateGet$3(this, _data$2);
+      const rowsWithinViewport = data.slice(rowRange.from, rowRange.to).map(
+        (row2) => toClientRow$2(row2, __privateGet$3(this, _keys), this.selectedRows, this.dataIndices)
+      );
+      this.clientCallback?.({
+        clientViewportId: this.viewport,
+        mode: "batch",
+        range: __privateGet$3(this, _range$1),
+        rows: rowsWithinViewport,
+        size: data.length,
+        type: "viewport-update"
+      });
+      this.lastRangeServed = {
+        from: __privateGet$3(this, _range$1).from,
+        to: __privateGet$3(this, _range$1).to
+        // to: Math.min(
+        //   this.#range.to,
+        //   this.#range.from + rowsWithinViewport.length,
+        // ),
+      };
+    }
+  }
+  get columns() {
+    return this._config.columns;
+  }
+  set columns(columns) {
+    const addedColumns = vuuUtils.getAddedItems(this.config.columns, columns);
+    if (addedColumns.length > 0) {
+      const columnsWithoutDescriptors = vuuUtils.getMissingItems(
+        this.columnDescriptors,
+        addedColumns,
+        (col) => col.name
+      );
+      console.log(`columnsWithoutDescriptors`, {
+        columnsWithoutDescriptors
+      });
+    }
+    __privateSet$2(this, _columnMap, vuuUtils.buildColumnMap(columns));
+    this.dataIndices = buildDataToClientMap(__privateGet$3(this, _columnMap), this.dataMap);
+    this.config = {
+      ...this._config,
+      columns
+    };
+  }
+  get aggregations() {
+    return this._config.aggregations;
+  }
+  set aggregations(aggregations) {
+    this._config = {
+      ...this._config,
+      aggregations
+    };
+    const targetData = this.processedData ?? __privateGet$3(this, _data$2);
+    const leafData = __privateGet$3(this, _data$2);
+    aggregateData(
+      aggregations,
+      targetData,
+      this._config.groupBy,
+      leafData,
+      __privateGet$3(this, _columnMap),
+      this.groupMap
+    );
+    this.setRange(__privateGet$3(this, _range$1).reset, true);
+    this.emit("config", this._config, this.range);
+  }
+  get sort() {
+    return this._config.sort;
+  }
+  set sort(sort) {
+    debug?.(`sort ${JSON.stringify(sort)}`);
+    this.config = {
+      ...this._config,
+      sort
+    };
+  }
+  get baseFilter() {
+    return this._config.baseFilterSpec;
+  }
+  set baseFilter(baseFilter) {
+    debug?.(`baseFilter ${JSON.stringify(baseFilter)}`);
+    this.config = {
+      ...this._config,
+      baseFilterSpec: baseFilter
+    };
+  }
+  get filter() {
+    return this._config.filterSpec;
+  }
+  set filter(filter) {
+    debug?.(`filter ${JSON.stringify(filter)}`);
+    this.config = {
+      ...this._config,
+      filterSpec: filter
+    };
+  }
+  get groupBy() {
+    return this._config.groupBy;
+  }
+  set groupBy(groupBy) {
+    this.config = {
+      ...this._config,
+      groupBy
+    };
+  }
+  get title() {
+    return __privateGet$3(this, _title$1) ?? `${this.table.module} ${this.table.table}`;
+  }
+  set title(title) {
+    __privateSet$2(this, _title$1, title);
+    this.emit("title-changed", this.viewport, title);
+  }
+  get _clientCallback() {
+    return this.clientCallback;
+  }
+  createLink({
+    parentVpId,
+    link: { fromColumn, toColumn }
+  }) {
+    console.log("create link", {
+      parentVpId,
+      fromColumn,
+      toColumn
+    });
+  }
+  removeLink() {
+    console.log("remove link");
+  }
+  applyEdit(rowKey, columnName, value) {
+    console.log(`ArrayDataSource applyEdit ${rowKey} ${columnName} ${value}`);
+    return Promise.resolve(true);
+  }
+  async remoteProcedureCall() {
+    return Promise.reject();
+  }
+  async menuRpcCall(rpcRequest) {
+    return new Promise((resolve) => {
+      if (vuuUtils.isEditCellRequest(rpcRequest)) {
+        const { rowKey, field, value } = rpcRequest;
+        try {
+          this.updateDataItem(rowKey, field, value);
+          resolve({
+            action: {
+              type: "VP_EDIT_SUCCESS"
+            },
+            rpcName: "VP_EDIT_CELL_RPC",
+            type: "VIEW_PORT_MENU_RESP",
+            vpId: this.viewport
+          });
+        } catch (error) {
+          resolve({
+            error: String(error),
+            rpcName: "VP_EDIT_CELL_RPC",
+            type: "VIEW_PORT_MENU_REJ",
+            vpId: this.viewport
+          });
+        }
+      } else {
+        throw Error("menuRpcCall invalid rpcRequest");
+      }
+    });
+  }
+  convertKeysToIndexValues(keys) {
+    if (Array.isArray(keys)) {
+      const indexValues = [];
+      keys.forEach((key) => {
+        const rowIdx = this.indexOfRowWithKey(key);
+        if (rowIdx !== -1) {
+          indexValues.push(rowIdx);
+        }
+      });
+      return indexValues;
+    }
+  }
+}
+_columnMap = new WeakMap();
+_data$2 = new WeakMap();
+_keys = new WeakMap();
+_links = new WeakMap();
+_range$1 = new WeakMap();
+_selectedRowsCount$2 = new WeakMap();
+_status$2 = new WeakMap();
+_title$1 = new WeakMap();
+
+var __defProp$2 = Object.defineProperty;
+var __typeError$2 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck$2 = (obj, member, msg) => member.has(obj) || __typeError$2("Cannot " + msg);
+var __privateGet$2 = (obj, member, getter) => (__accessCheck$2(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$2 = (obj, member, value) => member.has(obj) ? __typeError$2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$1 = (obj, member, value, setter) => (__accessCheck$2(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateWrapper$1 = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet$1(obj, member, value);
+  },
+  get _() {
+    return __privateGet$2(obj, member, getter);
+  }
+});
+var _aggregations$1, _config, _data$1, _filter, _groupBy, _range, _selectedRowsCount$1, _size$1, _sort, _status$1, _title;
+const NULL_SCHEMA$1 = { columns: [], key: "", table: { module: "", table: "" } };
+const { DEPTH: DEPTH$1, IDX: IDX$1, IS_EXPANDED: IS_EXPANDED$1, IS_LEAF: IS_LEAF$1, KEY: KEY$2, SELECTED: SELECTED$1 } = vuuUtils.metadataKeys;
+const toClientRow$1 = (row, keys) => {
+  const [rowIndex] = row;
+  const clientRow = row.slice();
+  clientRow[1] = keys.keyFor(rowIndex);
+  return clientRow;
+};
+class JsonDataSource extends vuuUtils.EventEmitter {
+  constructor({
+    aggregations,
+    data,
+    filterSpec,
+    groupBy,
+    sort,
+    title,
+    viewport
+  }) {
+    super();
+    __publicField$2(this, "columnDescriptors");
+    __publicField$2(this, "clientCallback");
+    __publicField$2(this, "expandedRows", /* @__PURE__ */ new Set());
+    __publicField$2(this, "visibleRows", []);
+    __privateAdd$2(this, _aggregations$1, []);
+    __privateAdd$2(this, _config, vuuUtils.vanillaConfig);
+    __privateAdd$2(this, _data$1);
+    __privateAdd$2(this, _filter, { filter: "" });
+    __privateAdd$2(this, _groupBy, []);
+    __privateAdd$2(this, _range, vuuUtils.Range(0, 0));
+    __privateAdd$2(this, _selectedRowsCount$1, 0);
+    __privateAdd$2(this, _size$1, 0);
+    __privateAdd$2(this, _sort, { sortDefs: [] });
+    __privateAdd$2(this, _status$1, "initialising");
+    __privateAdd$2(this, _title);
+    __publicField$2(this, "rowCount");
+    __publicField$2(this, "viewport");
+    __publicField$2(this, "keys", new vuuUtils.KeySet(__privateGet$2(this, _range)));
+    if (!data) {
+      throw Error("JsonDataSource constructor called without data");
+    }
+    [this.columnDescriptors, __privateWrapper$1(this, _data$1)._] = vuuUtils.jsonToDataSourceRows(data);
+    this.visibleRows = __privateGet$2(this, _data$1).filter((row) => row[DEPTH$1] === 0).map(
+      (row, index) => [index, index].concat(row.slice(2))
+    );
+    this.viewport = viewport || vuuUtils.uuid();
+    if (aggregations) {
+      __privateSet$1(this, _aggregations$1, aggregations);
+    }
+    if (this.columnDescriptors) {
+      __privateSet$1(this, _config, {
+        ...__privateGet$2(this, _config),
+        columns: this.columnDescriptors.map((c) => c.name)
+      });
+    }
+    if (filterSpec) {
+      __privateSet$1(this, _filter, filterSpec);
+    }
+    if (groupBy) {
+      __privateSet$1(this, _groupBy, groupBy);
+    }
+    if (sort) {
+      __privateSet$1(this, _sort, sort);
+    }
+    __privateSet$1(this, _title, title);
+  }
+  async subscribe({
+    viewport = this.viewport ?? vuuUtils.uuid(),
+    columns,
+    aggregations,
+    range,
+    sort,
+    groupBy,
+    filterSpec
+  }, callback) {
+    this.clientCallback = callback;
+    if (aggregations) {
+      __privateSet$1(this, _aggregations$1, aggregations);
+    }
+    if (columns) {
+      __privateSet$1(this, _config, {
+        ...__privateGet$2(this, _config),
+        columns
+      });
+    }
+    if (filterSpec) {
+      __privateSet$1(this, _filter, filterSpec);
+    }
+    if (groupBy) {
+      __privateSet$1(this, _groupBy, groupBy);
+    }
+    if (sort) {
+      __privateSet$1(this, _sort, sort);
+    }
+    if (__privateGet$2(this, _status$1) !== "initialising") {
+      return;
+    }
+    this.viewport = viewport;
+    __privateSet$1(this, _status$1, "subscribed");
+    this.clientCallback?.({
+      aggregations: __privateGet$2(this, _aggregations$1),
+      type: "subscribed",
+      clientViewportId: this.viewport,
+      columns: __privateGet$2(this, _config).columns,
+      filterSpec: __privateGet$2(this, _filter),
+      groupBy: __privateGet$2(this, _groupBy),
+      range: __privateGet$2(this, _range),
+      sort: __privateGet$2(this, _sort),
+      tableSchema: NULL_SCHEMA$1
+    });
+    this.clientCallback({
+      clientViewportId: this.viewport,
+      mode: "size-only",
+      type: "viewport-update",
+      size: this.visibleRows.length
+    });
+    if (range && !__privateGet$2(this, _range).equals(range)) {
+      this.range = range;
+    } else if (__privateGet$2(this, _range) !== vuuUtils.NULL_RANGE) {
+      this.sendRowsToClient();
+    }
+  }
+  unsubscribe() {
+    console.log("noop");
+  }
+  suspend() {
+    console.log("noop");
+    return this;
+  }
+  resume() {
+    console.log("noop");
+    return this;
+  }
+  disable() {
+    console.log("noop");
+    return this;
+  }
+  enable() {
+    console.log("noop");
+    return this;
+  }
+  set data(data) {
+    [this.columnDescriptors, __privateWrapper$1(this, _data$1)._] = vuuUtils.jsonToDataSourceRows(data);
+    this.visibleRows = __privateGet$2(this, _data$1).filter((row) => row[DEPTH$1] === 0).map(
+      (row, index) => [index, index].concat(row.slice(2))
+    );
+    requestAnimationFrame(() => {
+      this.sendRowsToClient();
+    });
+  }
+  select(selected) {
+    const updatedRows = [];
+    for (const row of __privateGet$2(this, _data$1)) {
+      const { [IDX$1]: rowIndex, [SELECTED$1]: sel } = row;
+      const wasSelected = sel === 1;
+      const nowSelected = vuuUtils.isSelected(selected, rowIndex);
+      if (nowSelected !== wasSelected) {
+        const selectedRow = row.slice();
+        selectedRow[SELECTED$1] = nowSelected ? 1 : 0;
+        __privateGet$2(this, _data$1)[rowIndex] = selectedRow;
+        updatedRows.push(selectedRow);
+      }
+    }
+    if (updatedRows.length > 0) {
+      this.clientCallback?.({
+        clientViewportId: this.viewport,
+        mode: "update",
+        type: "viewport-update",
+        rows: updatedRows
+      });
+    }
+  }
+  getRowKey(keyOrIndex) {
+    if (typeof keyOrIndex === "string") {
+      return keyOrIndex;
+    }
+    const row = this.visibleRows[keyOrIndex];
+    if (row === void 0) {
+      throw Error(`row not found at index ${keyOrIndex}`);
+    }
+    return row?.[KEY$2];
+  }
+  openTreeNode(keyOrIndex) {
+    const key = this.getRowKey(keyOrIndex);
+    this.expandedRows.add(key);
+    this.visibleRows = getVisibleRows$1(__privateGet$2(this, _data$1), this.expandedRows);
+    const { from, to } = __privateGet$2(this, _range);
+    this.clientCallback?.({
+      clientViewportId: this.viewport,
+      mode: "batch",
+      rows: this.visibleRows.slice(from, to).map((row) => toClientRow$1(row, this.keys)),
+      size: this.visibleRows.length,
+      type: "viewport-update"
+    });
+  }
+  closeTreeNode(keyOrIndex, cascade = false) {
+    const key = this.getRowKey(keyOrIndex);
+    this.expandedRows.delete(key);
+    if (cascade) {
+      for (const rowKey of this.expandedRows.keys()) {
+        if (rowKey.startsWith(key)) {
+          this.expandedRows.delete(rowKey);
+        }
+      }
+    }
+    this.visibleRows = getVisibleRows$1(__privateGet$2(this, _data$1), this.expandedRows);
+    this.sendRowsToClient();
+  }
+  get status() {
+    return __privateGet$2(this, _status$1);
+  }
+  get config() {
+    return __privateGet$2(this, _config);
+  }
+  applyConfig() {
+    return vuuUtils.NO_CONFIG_CHANGES;
+  }
+  get selectedRowsCount() {
+    return __privateGet$2(this, _selectedRowsCount$1);
+  }
+  get size() {
+    return __privateGet$2(this, _size$1);
+  }
+  get range() {
+    return __privateGet$2(this, _range);
+  }
+  set range(range) {
+    __privateSet$1(this, _range, range);
+    this.keys.reset(range);
+    requestAnimationFrame(() => {
+      this.sendRowsToClient();
+    });
+  }
+  sendRowsToClient() {
+    const { from, to } = __privateGet$2(this, _range);
+    this.clientCallback?.({
+      clientViewportId: this.viewport,
+      mode: "batch",
+      rows: this.visibleRows.slice(from, to).map((row) => toClientRow$1(row, this.keys)),
+      size: this.visibleRows.length,
+      type: "viewport-update"
+    });
+  }
+  get columns() {
+    return __privateGet$2(this, _config).columns;
+  }
+  set columns(columns) {
+    __privateSet$1(this, _config, {
+      ...__privateGet$2(this, _config),
+      columns
+    });
+  }
+  get aggregations() {
+    return __privateGet$2(this, _aggregations$1);
+  }
+  set aggregations(aggregations) {
+    __privateSet$1(this, _aggregations$1, aggregations);
+  }
+  get sort() {
+    return __privateGet$2(this, _sort);
+  }
+  set sort(sort) {
+    __privateSet$1(this, _sort, sort);
+  }
+  get filter() {
+    return __privateGet$2(this, _filter);
+  }
+  set filter(filter) {
+    __privateSet$1(this, _filter, filter);
+  }
+  get groupBy() {
+    return __privateGet$2(this, _groupBy);
+  }
+  set groupBy(groupBy) {
+    __privateSet$1(this, _groupBy, groupBy);
+  }
+  get title() {
+    return __privateGet$2(this, _title) ?? "";
+  }
+  set title(title) {
+    __privateSet$1(this, _title, title);
+  }
+  createLink({
+    parentVpId,
+    link: { fromColumn, toColumn }
+  }) {
+    console.log("create link", {
+      parentVpId,
+      fromColumn,
+      toColumn
+    });
+  }
+  removeLink() {
+    console.log("remove link");
+  }
+  async remoteProcedureCall() {
+    return Promise.reject();
+  }
+  async menuRpcCall(rpcRequest) {
+    console.log("rmenuRpcCall", {
+      rpcRequest
+    });
+    return void 0;
+  }
+  applyEdit(rowKey, columnName, value) {
+    console.log(`ArrayDataSource applyEdit ${rowKey} ${columnName} ${value}`);
+    return Promise.resolve(true);
+  }
+  getChildRows(rowKey) {
+    const parentRow = __privateGet$2(this, _data$1).find((row) => row[KEY$2] === rowKey);
+    if (parentRow) {
+      const { [IDX$1]: parentIdx, [DEPTH$1]: parentDepth } = parentRow;
+      let rowIdx = parentIdx + 1;
+      const childRows = [];
+      do {
+        const { [DEPTH$1]: depth } = __privateGet$2(this, _data$1)[rowIdx];
+        if (depth === parentDepth + 1) {
+          childRows.push(__privateGet$2(this, _data$1)[rowIdx]);
+        } else if (depth <= parentDepth) {
+          break;
+        }
+        rowIdx += 1;
+      } while (rowIdx < __privateGet$2(this, _data$1).length);
+      return childRows;
+    } else {
+      console.warn(
+        `JsonDataSource getChildRows row not found for key ${rowKey}`
+      );
+    }
+    return [];
+  }
+  getRowsAtDepth(depth, visibleOnly = true) {
+    const rows = visibleOnly ? this.visibleRows : __privateGet$2(this, _data$1);
+    return rows.filter((row) => row[DEPTH$1] === depth);
+  }
+}
+_aggregations$1 = new WeakMap();
+_config = new WeakMap();
+_data$1 = new WeakMap();
+_filter = new WeakMap();
+_groupBy = new WeakMap();
+_range = new WeakMap();
+_selectedRowsCount$1 = new WeakMap();
+_size$1 = new WeakMap();
+_sort = new WeakMap();
+_status$1 = new WeakMap();
+_title = new WeakMap();
+function getVisibleRows$1(rows, expandedKeys) {
+  const visibleRows = [];
+  const index = { value: 0 };
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    const { [DEPTH$1]: depth, [KEY$2]: key, [IS_LEAF$1]: isLeaf } = row;
+    const isExpanded = expandedKeys.has(key);
+    visibleRows.push(cloneRow$1(row, index, isExpanded));
+    if (!isLeaf && !isExpanded) {
+      do {
+        i += 1;
+      } while (i < rows.length - 1 && rows[i + 1][DEPTH$1] > depth);
+    }
+  }
+  return visibleRows;
+}
+const cloneRow$1 = (row, index, isExpanded) => {
+  const dolly = row.slice();
+  dolly[0] = index.value;
+  dolly[1] = index.value;
+  if (isExpanded) {
+    dolly[IS_EXPANDED$1] = true;
+  }
+  index.value += 1;
+  return dolly;
+};
+
+var __defProp$1 = Object.defineProperty;
+var __typeError$1 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "" , value);
+var __accessCheck$1 = (obj, member, msg) => member.has(obj) || __typeError$1("Cannot " + msg);
+var __privateGet$1 = (obj, member, getter) => (__accessCheck$1(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$1 = (obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var _iconMap;
+const { KEY: KEY$1 } = vuuUtils.metadataKeys;
+class IconProvider {
+  constructor() {
+    __privateAdd$1(this, _iconMap, {});
+    __publicField$1(this, "getIcon", (row) => {
+      const key = row[KEY$1];
+      return __privateGet$1(this, _iconMap)[key];
+    });
+  }
+  setIcon(key, icon) {
+    __privateGet$1(this, _iconMap)[key] = icon;
+  }
+}
+_iconMap = new WeakMap();
+
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _aggregations, _data, _iconProvider, _selectedRowsCount, _size, _status, _filterSet;
+const NULL_SCHEMA = { columns: [], key: "", table: { module: "", table: "" } };
+const { COUNT, DEPTH, IDX, IS_EXPANDED, IS_LEAF, KEY, SELECTED } = vuuUtils.metadataKeys;
+const toClientRow = (row, keys) => {
+  const [rowIndex] = row;
+  const clientRow = row.slice();
+  clientRow[1] = keys.keyFor(rowIndex);
+  return clientRow;
+};
+class TreeDataSource extends vuuUtils.BaseDataSource {
+  constructor({ data, ...props }) {
+    super(props);
+    __publicField(this, "columnDescriptors");
+    __publicField(this, "clientCallback");
+    __publicField(this, "expandedRows", /* @__PURE__ */ new Set());
+    __publicField(this, "visibleRows", []);
+    __publicField(this, "visibleRowIndex", {});
+    __privateAdd(this, _aggregations, []);
+    __privateAdd(this, _data);
+    __privateAdd(this, _iconProvider);
+    __privateAdd(this, _selectedRowsCount, 0);
+    __privateAdd(this, _size, 0);
+    __privateAdd(this, _status, "initialising");
+    __privateAdd(this, _filterSet);
+    __publicField(this, "rowCount");
+    __publicField(this, "keys", new vuuUtils.KeySet(this._range));
+    __publicField(this, "indexOfRowWithKey", (key) => __privateGet(this, _data).findIndex((row) => row[KEY] === key));
+    if (!data) {
+      throw Error("TreeDataSource constructor called without data");
+    }
+    __privateSet(this, _iconProvider, new IconProvider());
+    [this.columnDescriptors, __privateWrapper(this, _data)._] = vuuUtils.treeToDataSourceRows(
+      data,
+      __privateGet(this, _iconProvider)
+    );
+    if (this.columnDescriptors) {
+      const columns = this.columnDescriptors.map((c) => c.name);
+      this._config = {
+        ...this._config,
+        columns,
+        groupBy: columns.slice(1)
+      };
+    }
+  }
+  async subscribe({
+    aggregations,
+    columns,
+    range,
+    revealSelected,
+    selectedKeyValues,
+    viewport = this.viewport ?? vuuUtils.uuid()
+  }, callback) {
+    this.clientCallback = callback;
+    if (aggregations) {
+      __privateSet(this, _aggregations, aggregations);
+    }
+    if (columns) {
+      this._config = {
+        ...this._config,
+        columns
+      };
+    }
+    if (__privateGet(this, _status) !== "initialising") {
+      return;
+    }
+    this.viewport = viewport;
+    __privateSet(this, _status, "subscribed");
+    __privateSet(this, _selectedRowsCount, selectedKeyValues?.length ?? 0);
+    if (selectedKeyValues) {
+      this.applySelectedKeyValues(selectedKeyValues, revealSelected);
+    }
+    [this.visibleRows, this.visibleRowIndex] = getVisibleRows(
+      __privateGet(this, _data),
+      this.expandedRows
+    );
+    this.clientCallback?.({
+      aggregations: __privateGet(this, _aggregations),
+      type: "subscribed",
+      clientViewportId: this.viewport,
+      columns: this.columns,
+      filterSpec: this.filter,
+      groupBy: this._config.groupBy,
+      range: this.range,
+      sort: this.sort,
+      tableSchema: NULL_SCHEMA
+    });
+    this.clientCallback({
+      clientViewportId: this.viewport,
+      mode: "size-only",
+      type: "viewport-update",
+      size: this.visibleRows.length
+    });
+    if (range && !this._range.equals(range)) {
+      this.range = range;
+    } else if (this._range !== vuuUtils.NULL_RANGE) {
+      this.sendRowsToClient();
+    }
+  }
+  unsubscribe() {
+    console.log("noop");
+  }
+  suspend() {
+    console.log("noop");
+    return this;
+  }
+  resume() {
+    console.log("noop");
+    return this;
+  }
+  disable() {
+    console.log("noop");
+    return this;
+  }
+  enable() {
+    console.log("noop");
+    return this;
+  }
+  set data(data) {
+    [this.columnDescriptors, __privateWrapper(this, _data)._] = vuuUtils.treeToDataSourceRows(data);
+    requestAnimationFrame(() => {
+      this.sendRowsToClient();
+    });
+  }
+  get filter() {
+    return this._config.filterSpec;
+  }
+  set filter(filter) {
+    this._config = {
+      ...this._config,
+      filterSpec: filter
+    };
+    if (filter.filter) {
+      this.applyFilter(filter);
+    } else {
+      __privateSet(this, _filterSet, void 0);
+    }
+    [this.visibleRows, this.visibleRowIndex] = getVisibleRows(
+      __privateGet(this, _data),
+      this.expandedRows,
+      __privateGet(this, _filterSet)
+    );
+    const { from, to } = this.range;
+    this.clientCallback?.({
+      clientViewportId: this.viewport,
+      mode: "batch",
+      rows: this.visibleRows.slice(from, to).map((row) => toClientRow(row, this.keys)),
+      size: this.visibleRows.length,
+      type: "viewport-update"
+    });
+  }
+  applyFilter({ filter: filterQuery, filterStruct }) {
+    const filter = filterStruct ?? vuuFilterParser.parseFilter(filterQuery);
+    if (vuuUtils.isSingleValueFilter(filter)) {
+      const filterSet = [];
+      const regex = new RegExp(`${filter.value}`, "i");
+      for (const row of __privateGet(this, _data)) {
+        const { [KEY]: key, [IDX]: idx } = row;
+        if (regex.test(vuuUtils.lastPathSegment(key, "|"))) {
+          filterSet.push(idx);
+        }
+      }
+      __privateSet(this, _filterSet, filterSet);
+    }
+  }
+  /**
+   * used to apply an initial selection. These may not necessarily be
+   * visible. If revealOnSelect is in force, expand nodes as necessary
+   * to ensure selected nodes are visible
+   */
+  applySelectedKeyValues(keys, revealSelected = false) {
+    keys.forEach((key) => {
+      const rowIdx = this.indexOfRowWithKey(key);
+      const row = __privateGet(this, _data)[rowIdx];
+      row[SELECTED] = 1;
+      if (revealSelected && row[DEPTH] !== 1) {
+        const keys2 = key.slice(6).split("|").slice(0, -1);
+        let path = "$root";
+        do {
+          path = `${path}|${keys2.shift()}`;
+          this.expandedRows.add(path);
+        } while (keys2.length);
+      }
+    });
+  }
+  // Incoming Selection references visibleRow indices
+  select(selected) {
+    const updatedRows = [];
+    for (const row of this.visibleRows) {
+      const { [IDX]: rowIndex, [SELECTED]: sel } = row;
+      const wasSelected = sel === 1;
+      const nowSelected = vuuUtils.isSelected(selected, rowIndex);
+      if (nowSelected !== wasSelected) {
+        const selectedRow = row.slice();
+        const selectedValue = nowSelected ? 1 : 0;
+        selectedRow[SELECTED] = selectedValue;
+        const dataRowIdx = this.visibleRowIndex[rowIndex];
+        this.visibleRows[rowIndex] = selectedRow;
+        __privateGet(this, _data)[dataRowIdx][SELECTED] = selectedValue;
+        updatedRows.push(selectedRow);
+      }
+    }
+    if (updatedRows.length > 0) {
+      this.clientCallback?.({
+        clientViewportId: this.viewport,
+        mode: "update",
+        type: "viewport-update",
+        rows: updatedRows
+      });
+    }
+  }
+  getRowKey(keyOrIndex) {
+    if (typeof keyOrIndex === "string") {
+      return keyOrIndex;
+    }
+    const row = this.getRowAtIndex(keyOrIndex);
+    if (row === void 0) {
+      throw Error(`row not found at index ${keyOrIndex}`);
+    }
+    return row[KEY];
+  }
+  openTreeNode(keyOrIndex) {
+    const key = this.getRowKey(keyOrIndex);
+    this.expandedRows.add(key);
+    [this.visibleRows, this.visibleRowIndex] = getVisibleRows(
+      __privateGet(this, _data),
+      this.expandedRows
+    );
+    const { from, to } = this._range;
+    this.clientCallback?.({
+      clientViewportId: this.viewport,
+      mode: "batch",
+      rows: this.visibleRows.slice(from, to).map((row) => toClientRow(row, this.keys)),
+      size: this.visibleRows.length,
+      type: "viewport-update"
+    });
+  }
+  closeTreeNode(keyOrIndex, cascade = false) {
+    const key = this.getRowKey(keyOrIndex);
+    this.expandedRows.delete(key);
+    if (cascade) {
+      for (const rowKey of this.expandedRows.keys()) {
+        if (rowKey.startsWith(key)) {
+          this.expandedRows.delete(rowKey);
+        }
+      }
+    }
+    [this.visibleRows, this.visibleRowIndex] = getVisibleRows(
+      __privateGet(this, _data),
+      this.expandedRows
+    );
+    this.sendRowsToClient();
+  }
+  get status() {
+    return __privateGet(this, _status);
+  }
+  get selectedRowsCount() {
+    return __privateGet(this, _selectedRowsCount);
+  }
+  get size() {
+    return __privateGet(this, _size);
+  }
+  rangeRequest(range) {
+    this.keys.reset(range);
+    requestAnimationFrame(() => {
+      this.sendRowsToClient();
+    });
+  }
+  sendRowsToClient() {
+    const { from, to } = this._range;
+    this.clientCallback?.({
+      clientViewportId: this.viewport,
+      mode: "batch",
+      rows: this.visibleRows.slice(from, to).map((row) => toClientRow(row, this.keys)),
+      size: this.visibleRows.length,
+      type: "viewport-update"
+    });
+  }
+  createLink({
+    parentVpId,
+    link: { fromColumn, toColumn }
+  }) {
+    console.log("create link", {
+      parentVpId,
+      fromColumn,
+      toColumn
+    });
+  }
+  removeLink() {
+    console.log("remove link");
+  }
+  async remoteProcedureCall() {
+    return Promise.reject();
+  }
+  async menuRpcCall(rpcRequest) {
+    console.log("rmenuRpcCall", {
+      rpcRequest
+    });
+    return void 0;
+  }
+  applyEdit(rowKey, columnName, value) {
+    console.log(`ArrayDataSource applyEdit ${rowKey} ${columnName} ${value}`);
+    return Promise.resolve(true);
+  }
+  getChildRows(rowKey) {
+    const parentRow = __privateGet(this, _data).find((row) => row[KEY] === rowKey);
+    if (parentRow) {
+      const { [IDX]: parentIdx, [DEPTH]: parentDepth } = parentRow;
+      let rowIdx = parentIdx + 1;
+      const childRows = [];
+      do {
+        const { [DEPTH]: depth } = __privateGet(this, _data)[rowIdx];
+        if (depth === parentDepth + 1) {
+          childRows.push(__privateGet(this, _data)[rowIdx]);
+        } else if (depth <= parentDepth) {
+          break;
+        }
+        rowIdx += 1;
+      } while (rowIdx < __privateGet(this, _data).length);
+      return childRows;
+    } else {
+      console.warn(
+        `JsonDataSource getChildRows row not found for key ${rowKey}`
+      );
+    }
+    return [];
+  }
+  getRowsAtDepth(depth, visibleOnly = true) {
+    const rows = visibleOnly ? this.visibleRows : __privateGet(this, _data);
+    return rows.filter((row) => row[DEPTH] === depth);
+  }
+  getRowAtIndex(rowIdx) {
+    return this.visibleRows[rowIdx];
+  }
+}
+_aggregations = new WeakMap();
+_data = new WeakMap();
+_iconProvider = new WeakMap();
+_selectedRowsCount = new WeakMap();
+_size = new WeakMap();
+_status = new WeakMap();
+_filterSet = new WeakMap();
+function getVisibleRows(rows, expandedKeys, filterset) {
+  const visibleRows = [];
+  const visibleRowIndex = {};
+  const data = filterset ?? rows;
+  for (let i = 0, index = 0; i < data.length; i++) {
+    const idx = filterset ? filterset[i] : i;
+    const row = rows[idx];
+    const {
+      [COUNT]: count,
+      [DEPTH]: depth,
+      [KEY]: key,
+      [IS_LEAF]: isLeaf
+    } = row;
+    if (filterset) {
+      const previousRow = visibleRows.at(-1);
+      if (vuuUtils.missingAncestor(row, previousRow)) {
+        let currentRow = row;
+        const missingRows = [];
+        while (currentRow) {
+          currentRow = vuuUtils.getParentRow(rows, currentRow);
+          if (currentRow) {
+            missingRows.unshift(currentRow);
+          }
+        }
+        missingRows.forEach((row2) => {
+          visibleRows.push(cloneRow(row2, index++, true));
+        });
+      }
+      visibleRows.push(cloneRow(row, index++, true));
+      visibleRowIndex[index] = i;
+    } else {
+      const isExpanded = expandedKeys.has(key);
+      visibleRows.push(cloneRow(row, index, isExpanded));
+      visibleRowIndex[index++] = i;
+      const skipNonVisibleRows = !isLeaf && !isExpanded && count > 0;
+      if (skipNonVisibleRows) {
+        do {
+          i += 1;
+        } while (i < rows.length - 1 && rows[i + 1][DEPTH] > depth);
+      }
+    }
+  }
+  return [visibleRows, visibleRowIndex];
+}
+const cloneRow = (row, index, isExpanded) => {
+  const dolly = row.slice();
+  dolly[0] = index;
+  dolly[1] = index;
+  if (isExpanded) {
+    dolly[IS_EXPANDED] = true;
+  }
+  return dolly;
+};
+
+exports.ArrayDataSource = ArrayDataSource;
+exports.JsonDataSource = JsonDataSource;
+exports.TreeDataSource = TreeDataSource;
 //# sourceMappingURL=index.js.map