@vuu-ui/vuu-utils 0.6.13-debug → 0.6.14-debug

package/cjs/index.js

@@ -16,21 +16,34 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   AggregationType: () => AggregationType,
-  ConsoleLogger: () => ConsoleLogger,
   DOWN1: () => DOWN1,
   DOWN2: () => DOWN2,
   DataWindow: () => DataWindow,
   EventEmitter: () => EventEmitter,
+  KeySet: () => KeySet,
+  RangeMonitor: () => RangeMonitor,
   UP1: () => UP1,
   UP2: () => UP2,
   WindowRange: () => WindowRange,
   addGroupColumn: () => addGroupColumn,
-  addRowsToIndex: () => addRowsToIndex,
   addSortColumn: () => addSortColumn,
   applyFilterToColumns: () => applyFilterToColumns,
   applyGroupByToColumns: () => applyGroupByToColumns,
@@ -38,11 +51,13 @@ __export(src_exports, {
   applySortToColumns: () => applySortToColumns,
   buildColumnMap: () => buildColumnMap,
   createEl: () => createEl,
+  debounce: () => debounce,
   defaultValueFormatter: () => defaultValueFormatter,
   deselectItem: () => deselectItem,
   expandSelection: () => expandSelection,
   extractFilterForColumn: () => extractFilterForColumn,
   extractGroupColumn: () => extractGroupColumn,
+  findColumn: () => findColumn,
   flattenColumnGroup: () => flattenColumnGroup,
   formatDate: () => formatDate,
   fromServerDataType: () => fromServerDataType,
@@ -50,7 +65,10 @@ __export(src_exports, {
   getCellRenderer: () => getCellRenderer,
   getColumnName: () => getColumnName,
   getColumnPinStyle: () => getColumnPinStyle,
+  getColumnsInViewport: () => getColumnsInViewport,
+  getCookieValue: () => getCookieValue,
   getFullRange: () => getFullRange,
+  getLoggingConfig: () => getLoggingConfig,
   getMovingValueDirection: () => getMovingValueDirection,
   getRegisteredCellRenderers: () => getRegisteredCellRenderers,
   getRowRecord: () => getRowRecord,
@@ -58,14 +76,16 @@ __export(src_exports, {
   getUniqueId: () => getUniqueId,
   getValueFormatter: () => getValueFormatter,
   hasHeadings: () => hasHeadings,
-  indexRows: () => indexRows,
   invariant: () => invariant,
   isAndFilter: () => isAndFilter,
   isCharacterKey: () => isCharacterKey,
-  isEmptyRow: () => isEmptyRow,
+  isDataLoading: () => isDataLoading,
   isFilterClause: () => isFilterClause,
   isGroupColumn: () => isGroupColumn,
   isInFilter: () => isInFilter,
+  isJsonAttribute: () => isJsonAttribute,
+  isJsonColumn: () => isJsonColumn,
+  isJsonGroup: () => isJsonGroup,
   isKeyedColumn: () => isKeyedColumn,
   isMultiClauseFilter: () => isMultiClauseFilter,
   isMultiValueFilter: () => isMultiValueFilter,
@@ -80,6 +100,7 @@ __export(src_exports, {
   isTypeDescriptor: () => isTypeDescriptor,
   isValidNumber: () => isValidNumber,
   itemsChanged: () => itemsChanged,
+  jsonToDataSourceRows: () => jsonToDataSourceRows,
   lastWord: () => lastWord,
   logger: () => logger,
   mapSortCriteria: () => mapSortCriteria,
@@ -96,9 +117,9 @@ __export(src_exports, {
   setAggregations: () => setAggregations,
   setSortColumn: () => setSortColumn,
   sortPinnedColumns: () => sortPinnedColumns,
+  throttle: () => throttle,
   toColumnDescriptor: () => toColumnDescriptor,
   toDataSourceColumns: () => toDataSourceColumns,
-  update: () => update,
   uuid: () => uuid,
   withinRange: () => withinRange
 });
@@ -293,7 +314,7 @@ var flattenColumnGroup = (columns) => {
     return columns;
   }
 };
-function extractGroupColumn(columns, groupBy) {
+function extractGroupColumn(columns, groupBy, confirmed = true) {
   if (groupBy && groupBy.length > 0) {
     const flattenedColumns = flattenColumnGroup(columns);
     const [groupedColumns, rest] = flattenedColumns.reduce(
@@ -334,6 +355,7 @@ function extractGroupColumn(columns, groupBy) {
       heading: ["group-col"],
       isGroup: true,
       columns: groupCols,
+      groupConfirmed: confirmed,
       width: groupCols.map((c) => c.width).reduce((a, b) => a + b) + 100
     };
     return [groupCol, rest];
@@ -341,6 +363,15 @@ function extractGroupColumn(columns, groupBy) {
   return [null, flattenColumnGroup(columns)];
 }
 var isGroupColumn = (column) => column.isGroup === true;
+var isJsonAttribute = (value) => typeof value === "string" && value.endsWith("+");
+var isJsonGroup = (column, row) => {
+  var _a;
+  return ((_a = column.type) == null ? void 0 : _a.name) === "json" && isJsonAttribute(row[column.key]);
+};
+var isJsonColumn = (column) => {
+  var _a;
+  return ((_a = column.type) == null ? void 0 : _a.name) === "json";
+};
 var sortPinnedColumns = (columns) => {
   const leftPinnedColumns = [];
   const rightPinnedColumns = [];
@@ -451,12 +482,13 @@ var collectFiltersForColumn = (filter, columnName) => {
     filters: results
   };
 };
-var applyGroupByToColumns = (columns, groupBy) => {
+var applyGroupByToColumns = (columns, groupBy, confirmed = true) => {
   var _a;
   if (groupBy.length) {
     const [groupColumn, nonGroupedColumns] = extractGroupColumn(
       columns,
-      groupBy
+      groupBy,
+      confirmed
     );
     if (groupColumn) {
       return [groupColumn].concat(nonGroupedColumns);
@@ -512,6 +544,19 @@ var getColumnName = (name) => {
     return name.slice(0, pos);
   }
 };
+var findColumn = (columns, columnName) => {
+  const column = columns.find((col) => col.name === columnName);
+  if (column) {
+    return column;
+  } else {
+    const groupColumn = columns.find(
+      (col) => col.isGroup
+    );
+    if (groupColumn) {
+      return findColumn(groupColumn.columns, columnName);
+    }
+  }
+};
 var toDataSourceColumns = (column) => column.expression ? `${column.name}:${column.serverDataType}:${column.expression}` : column.name;
 var getRowRecord = (row, columnMap) => {
   return Object.entries(columnMap).reduce(
@@ -522,6 +567,33 @@ var getRowRecord = (row, columnMap) => {
     {}
   );
 };
+var isDataLoading = (columns) => {
+  return isGroupColumn(columns[0]) && columns[0].groupConfirmed === false;
+};
+var getColumnsInViewport = (columns, vpStart, vpEnd) => {
+  var _a;
+  const visibleColumns = [];
+  let preSpan = 0;
+  for (let offset = 0, i = 0; i < columns.length; i++) {
+    const column = columns[i];
+    if (column.hidden) {
+      continue;
+    } else if (offset + column.width < vpStart) {
+      if (offset + column.width + ((_a = columns[i + 1]) == null ? void 0 : _a.width) > vpStart) {
+        visibleColumns.push(column);
+      } else {
+        preSpan += 1;
+      }
+    } else if (offset > vpEnd) {
+      visibleColumns.push(column);
+      break;
+    } else {
+      visibleColumns.push(column);
+    }
+    offset += column.width;
+  }
+  return [visibleColumns, preSpan];
+};
 
 // src/component-registry.ts
 var cellRenderersMap = /* @__PURE__ */ new Map();
@@ -539,7 +611,6 @@ var isTypeCompatible = (rendererType, serverDataType) => {
 var isCellRenderer = (type, component) => type === "cell-renderer";
 var isCellConfigPanel = (type, component) => type === "cell-config-panel";
 function registerComponent(componentName, component, type = "cell-renderer", options) {
-  console.log("registre component");
   if (isCellRenderer(type, component)) {
     cellRenderersMap.set(componentName, component);
   } else if (isCellConfigPanel(type, component)) {
@@ -575,7 +646,11 @@ function getCellConfigPanelRenderer(name) {
 // src/range-utils.ts
 function getFullRange({ from, to }, bufferSize = 0, rowCount = Number.MAX_SAFE_INTEGER) {
   if (bufferSize === 0) {
-    return { from, to: Math.min(to, rowCount) };
+    if (rowCount < from) {
+      return { from: 0, to: 0 };
+    } else {
+      return { from, to: Math.min(to, rowCount) };
+    }
   } else if (from === 0) {
     return { from, to: Math.min(to + bufferSize, rowCount) };
   } else {
@@ -734,6 +809,76 @@ var formatDate = (date, format) => {
   return date.toUTCString();
 };
 
+// src/cookie-utils.ts
+var getCookieValue = (name) => {
+  var _a, _b;
+  if (((_a = globalThis.document) == null ? void 0 : _a.cookie) !== void 0) {
+    return (_b = globalThis.document.cookie.split("; ").find((row) => row.startsWith(`${name}=`))) == null ? void 0 : _b.split("=")[1];
+  }
+};
+
+// src/logging-utils.ts
+var NO_OP = () => void 0;
+var DEFAULT_DEBUG_LEVEL = false ? "error" : "info";
+var { loggingLevel = DEFAULT_DEBUG_LEVEL } = typeof loggingSettings !== "undefined" ? loggingSettings : {};
+var logger = (category) => {
+  const debugEnabled2 = loggingLevel === "debug";
+  const infoEnabled = debugEnabled2 || loggingLevel === "info";
+  const warnEnabled = infoEnabled || loggingLevel === "warn";
+  const errorEnabled = warnEnabled || loggingLevel === "error";
+  const info = infoEnabled ? (message) => console.info(`[${category}] ${message}`) : NO_OP;
+  const warn = warnEnabled ? (message) => console.warn(`[${category}] ${message}`) : NO_OP;
+  const debug2 = debugEnabled2 ? (message) => console.debug(`[${category}] ${message}`) : NO_OP;
+  const error = errorEnabled ? (message) => console.error(`[${category}] ${message}`) : NO_OP;
+  if (false) {
+    return {
+      errorEnabled,
+      error
+    };
+  } else {
+    return {
+      debugEnabled: debugEnabled2,
+      infoEnabled,
+      warnEnabled,
+      errorEnabled,
+      info,
+      warn,
+      debug: debug2,
+      error
+    };
+  }
+};
+var getLoggingConfig = () => {
+  const loggingLevel2 = getCookieValue("vuu-logging-level");
+  return `const loggingSettings = { loggingLevel: "${loggingLevel2}"};`;
+};
+
+// src/debug-utils.ts
+var { debug, debugEnabled } = logger("range-monitor");
+var RangeMonitor = class {
+  constructor(source) {
+    this.source = source;
+    this.range = { from: 0, to: 0 };
+    this.timestamp = 0;
+  }
+  isSet() {
+    return this.timestamp !== 0;
+  }
+  set({ from, to }) {
+    const { timestamp } = this;
+    this.range.from = from;
+    this.range.to = to;
+    this.timestamp = performance.now();
+    if (timestamp) {
+      debugEnabled && debug(
+        `<${this.source}> [${from}-${to}], ${(this.timestamp - timestamp).toFixed(0)} ms elapsed`
+      );
+    } else {
+      return 0;
+    }
+  }
+};
+
 // src/html-utils.ts
 var createEl = (elementType, className, textContent) => {
   const el = document.createElement(elementType);
@@ -753,31 +898,29 @@ function isArrayOfListeners(listeners) {
 function isOnlyListener(listeners) {
   return !Array.isArray(listeners);
 }
+var _events;
 var EventEmitter = class {
   constructor() {
-    this._events = {};
+    __privateAdd(this, _events, /* @__PURE__ */ new Map());
   }
-  addListener(type, listener) {
-    if (!this._events) {
-      this._events = {};
-    }
-    const listeners = this._events[type];
+  addListener(event, listener) {
+    const listeners = __privateGet(this, _events).get(event);
     if (!listeners) {
-      this._events[type] = listener;
+      __privateGet(this, _events).set(event, listener);
     } else if (isArrayOfListeners(listeners)) {
       listeners.push(listener);
     } else if (isOnlyListener(listeners)) {
-      this._events[type] = [listeners, listener];
+      __privateGet(this, _events).set(event, [listeners, listener]);
     }
   }
-  removeListener(type, listener) {
-    if (!this._events || !this._events[type]) {
+  removeListener(event, listener) {
+    if (!__privateGet(this, _events).has(event)) {
       return;
     }
-    const listenerOrListeners = this._events[type];
+    const listenerOrListeners = __privateGet(this, _events).get(event);
     let position = -1;
     if (listenerOrListeners === listener) {
-      delete this._events[type];
+      __privateGet(this, _events).delete(event);
     } else if (Array.isArray(listenerOrListeners)) {
       for (let i = length; i-- > 0; ) {
         if (listenerOrListeners[i] === listener) {
@@ -790,63 +933,58 @@ var EventEmitter = class {
       }
       if (listenerOrListeners.length === 1) {
         listenerOrListeners.length = 0;
-        delete this._events[type];
+        __privateGet(this, _events).delete(event);
       } else {
         listenerOrListeners.splice(position, 1);
       }
     }
   }
-  removeAllListeners(type) {
-    if (!this._events) {
-      return;
-    } else if (type === void 0) {
-      delete this._events;
-    } else {
-      delete this._events[type];
+  removeAllListeners(event) {
+    if (event && __privateGet(this, _events).has(event)) {
+      __privateGet(this, _events).delete(event);
+    } else if (event === void 0) {
+      __privateGet(this, _events).clear();
     }
   }
-  emit(type, ...args) {
-    if (this._events) {
-      const handler = this._events[type];
+  emit(event, ...args) {
+    if (__privateGet(this, _events)) {
+      const handler = __privateGet(this, _events).get(event);
       if (handler) {
-        invokeHandler(handler, type, args);
-      }
-      const wildcardHandler = this._events["*"];
-      if (wildcardHandler) {
-        invokeHandler(wildcardHandler, type, args);
+        this.invokeHandler(handler, args);
       }
     }
   }
-  once(type, listener) {
-    const handler = (evtName, message) => {
-      this.removeListener(evtName, handler);
-      listener(evtName, message);
+  once(event, listener) {
+    const handler = (...args) => {
+      this.removeListener(event, handler);
+      listener(...args);
     };
-    this.on(type, handler);
+    this.on(event, handler);
   }
-  on(type, listener) {
-    return this.addListener(type, listener);
+  on(event, listener) {
+    this.addListener(event, listener);
   }
-};
-function invokeHandler(handler, type, args) {
-  if (isArrayOfListeners(handler)) {
-    handler.slice().forEach((listener) => invokeHandler(listener, type, args));
-  } else {
-    switch (args.length) {
-      case 0:
-        handler(type);
-        break;
-      case 1:
-        handler(type, args[0]);
-        break;
-      case 2:
-        handler(type, args[0], args[1]);
-        break;
-      default:
-        handler.call(null, type, ...args);
+  invokeHandler(handler, args) {
+    if (isArrayOfListeners(handler)) {
+      handler.slice().forEach((listener) => this.invokeHandler(listener, args));
+    } else {
+      switch (args.length) {
+        case 0:
+          handler();
+          break;
+        case 1:
+          handler(args[0]);
+          break;
+        case 2:
+          handler(args[0], args[1]);
+          break;
+        default:
+          handler.call(null, ...args);
+      }
     }
   }
-}
+};
+_events = new WeakMap();
 
 // src/round-decimal.ts
 var PUNCTUATION_STR = String.fromCharCode(8200);
@@ -1034,6 +1172,136 @@ function invariant(condition, message) {
   }
 }
 
+// src/json-utils.ts
+var { COUNT } = metadataKeys;
+var isJsonData = (value) => typeof value === "object" && value !== null;
+var vuuRowDataItemTypes = ["boolean", "number", "string"];
+var isVuuRowDataItem = (value) => vuuRowDataItemTypes.includes(typeof value);
+var typeofVuuDataItem = (value) => typeof value === "boolean" ? "boolean" : typeof value === "number" ? "number" : "string";
+var getCellValue = (attribute, attributeValue) => {
+  if (isJsonData(attributeValue)) {
+    return { attribute: `${attribute}+`, attributeValue: "", type: "json" };
+  } else if (isVuuRowDataItem(attributeValue)) {
+    return {
+      attribute,
+      attributeValue,
+      type: typeofVuuDataItem(attributeValue)
+    };
+  } else {
+    throw Error(`unsupported type ${typeof attributeValue} in JSON`);
+  }
+};
+var jsonColumnType = {
+  name: "json",
+  renderer: {
+    name: "json"
+  }
+};
+var jsonToDataSourceRows = (json) => {
+  const cols = [];
+  cols.push(
+    {
+      name: "col 1",
+      type: jsonColumnType
+    },
+    {
+      name: "col 2",
+      type: jsonColumnType
+    }
+  );
+  const rows = [];
+  addChildValues(rows, json, cols);
+  return [cols, rows];
+};
+var addChildValues = (rows, json, cols, index = { value: 0 }, keyBase = "$root", depth = 0) => {
+  let leafCount = 0;
+  let rowCount = 0;
+  if (depth === cols.length - 1) {
+    cols.push({
+      name: `col ${cols.length + 1}`,
+      hidden: true,
+      type: jsonColumnType
+    });
+  }
+  const columnEntries = Object.entries(json);
+  for (let i = 0; i < columnEntries.length; i++, index.value += 1) {
+    const [key, value] = columnEntries[i];
+    const { attribute, attributeValue, type } = getCellValue(key, value);
+    const isLeaf = type !== "json";
+    const blanks = Array(depth).fill("");
+    const fullKey = `${keyBase}|${key}`;
+    const row = [index.value, index.value, isLeaf, false, depth, 0, fullKey, 0, ...blanks, attribute, attributeValue];
+    rows.push(row);
+    rowCount += 1;
+    if (isJsonData(value)) {
+      const [nestedLeafCount, nestedRowCount] = addChildValues(
+        rows,
+        value,
+        cols,
+        { value: index.value + 1 },
+        fullKey,
+        depth + 1
+      );
+      row[COUNT] = nestedLeafCount;
+      leafCount += nestedLeafCount;
+      rowCount += nestedRowCount;
+      index.value += nestedRowCount;
+    } else {
+      leafCount += 1;
+    }
+  }
+  return [leafCount, rowCount];
+};
+
+// src/keyset.ts
+var KeySet = class {
+  constructor(range) {
+    this.keys = /* @__PURE__ */ new Map();
+    this.free = [];
+    this.nextKeyValue = 0;
+    this.reset(range);
+  }
+  next() {
+    if (this.free.length > 0) {
+      return this.free.pop();
+    } else {
+      return this.nextKeyValue++;
+    }
+  }
+  reset({ from, to }) {
+    this.keys.forEach((keyValue, rowIndex) => {
+      if (rowIndex < from || rowIndex >= to) {
+        this.free.push(keyValue);
+        this.keys.delete(rowIndex);
+      }
+    });
+    const size = to - from;
+    if (this.keys.size + this.free.length > size) {
+      this.free.length = size - this.keys.size;
+    }
+    for (let rowIndex = from; rowIndex < to; rowIndex++) {
+      if (!this.keys.has(rowIndex)) {
+        const nextKeyValue = this.next();
+        this.keys.set(rowIndex, nextKeyValue);
+      }
+    }
+  }
+  keyFor(rowIndex) {
+    const key = this.keys.get(rowIndex);
+    if (key === void 0) {
+      console.log(`key not found
+        keys: ${this.toDebugString()}
+        free : ${this.free.join(",")}  
+      `);
+      throw Error(`KeySet, no key found for rowIndex ${rowIndex}`);
+    }
+    return key;
+  }
+  toDebugString() {
+    return Array.from(this.keys.entries()).map((k, v) => `${k}=>${v}`).join(",");
+  }
+};
+
 // src/nanoid/index.ts
 var uuid = (size = 21) => {
   let id = "";
@@ -1053,35 +1321,35 @@ var uuid = (size = 21) => {
   return id;
 };
 
-// src/row-utils.ts
-function addRowsToIndex(rows, index, indexField) {
-  for (let idx = 0, len = rows.length; idx < len; idx++) {
-    index[rows[idx][indexField]] = idx;
-  }
-  return index;
-}
-function indexRows(rows, indexField) {
-  return addRowsToIndex(rows, {}, indexField);
-}
-function isEmptyRow(row) {
-  return row[0] === void 0;
+// src/perf-utils.ts
+function debounce(callback, timeInterval) {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = window.setTimeout(() => callback(...args), timeInterval);
+  };
 }
-function update(rows, updates) {
-  const results = rows.slice();
-  const [[offsetIdx]] = rows;
-  for (let i = 0; i < updates.length; i++) {
-    const idx = updates[i][0] - offsetIdx;
-    if (rows[idx]) {
-      const row = rows[idx].slice();
-      for (let j = 1; j < updates[i].length; j += 3) {
-        row[updates[i][j]] = updates[i][j + 2];
-      }
-      results[idx] = row;
+function throttle(callback, limit) {
+  let wait = false;
+  let lastArgs = void 0;
+  function checkLastArgs() {
+    if (lastArgs == void 0) {
+      wait = false;
     } else {
-      console.log(`row not found in rows`);
+      callback(...lastArgs);
+      lastArgs = void 0;
+      setTimeout(checkLastArgs, limit);
     }
   }
-  return results;
+  return (...args) => {
+    if (wait) {
+      lastArgs = args;
+    } else {
+      callback(...args);
+      wait = true;
+      setTimeout(checkLastArgs, limit);
+    }
+  };
 }
 
 // src/selection-utils.ts
@@ -1106,7 +1374,9 @@ var selectItem = (selectionModel, selected, itemIndex, rangeSelect, keepExisting
   const singleSelect = selectionModel === "single";
   const multiSelect = selectionModel === "extended" || selectionModel === "checkbox";
   const actsLikeSingleSelect = singleSelect || multiSelect && !keepExistingSelection && !rangeSelect;
-  if (actsLikeSingleSelect) {
+  if (selectionModel === "none") {
+    return NO_SELECTION;
+  } else if (actsLikeSingleSelect) {
     return [itemIndex];
   } else if (rangeSelect) {
     if (selected.length === 0) {
@@ -1274,39 +1544,4 @@ var lastWord = (text) => {
     return trimmedText.slice(pos + 1);
   }
 };
-
-// src/logging-utils.ts
-var NO_OP = () => {
-};
-var ConsoleLogger = class {
-  constructor(options, level) {
-    const { buildEnv } = options || {};
-    if (buildEnv === "production") {
-      this.log = NO_OP;
-      this.warn = NO_OP;
-      this.error = NO_OP;
-      this.group = NO_OP;
-      this.groupCollapsed = NO_OP;
-      this.groupEnd = NO_OP;
-      this.assert = NO_OP;
-      this.trace = NO_OP;
-      this.debug = NO_OP;
-      this.info = NO_OP;
-      this.table = NO_OP;
-      return;
-    }
-    this.log = console.log.bind(console);
-    this.warn = console.warn.bind(console);
-    this.error = console.error.bind(console);
-    this.group = console.group.bind(console);
-    this.groupEnd = console.groupEnd.bind(console);
-    this.groupCollapsed = console.groupCollapsed.bind(console);
-    this.assert = console.assert.bind(console);
-    this.trace = console.trace.bind(console);
-    this.debug = console.debug.bind(console);
-    this.info = console.info.bind(console);
-    this.table = console.table.bind(console);
-  }
-};
-var logger = new ConsoleLogger({ buildEnv: "development" });
 //# sourceMappingURL=index.js.map