@revolist/revogrid 3.1.6 → 3.2.4

package/dist/revo-grid/selection.store.connector-2b613fd0.js

@@ -0,0 +1,503 @@
+/*!
+ * Built by Revolist
+ */
+import { G as GRID_INTERNALS } from './consts-ef824e6f.js';
+import { c as createStore, d as setStore } from './data.store-3263fff9.js';
+
+const GROUP_DEPTH = `${GRID_INTERNALS}-depth`;
+const PSEUDO_GROUP_ITEM = `${GRID_INTERNALS}-name`;
+const PSEUDO_GROUP_ITEM_ID = `${GRID_INTERNALS}-id`;
+const PSEUDO_GROUP_ITEM_VALUE = `${GRID_INTERNALS}-value`;
+const PSEUDO_GROUP_COLUMN = `${GRID_INTERNALS}-column`;
+const GROUP_EXPANDED = `${GRID_INTERNALS}-expanded`;
+const GROUP_EXPAND_BTN = `group-expand`;
+const GROUP_EXPAND_EVENT = `groupExpandClick`;
+const GROUPING_ROW_TYPE = 'rgRow';
+
+/**
+ * Do actual grouping
+ * @param array - items to group
+ * @param f - function responsible for grouping, returns property to group by
+ */
+function groupBy(array, f) {
+  const groupsOrder = [];
+  const itemsByGroup = {};
+  array.forEach((item, i) => {
+    // get grouping values
+    const groupKeys = JSON.stringify(f(item));
+    // new group identification
+    if (!itemsByGroup[groupKeys]) {
+      itemsByGroup[groupKeys] = new Map();
+      // create group parents
+      groupsOrder.push({
+        children: itemsByGroup[groupKeys],
+        id: groupKeys,
+      });
+    }
+    // save to group with previous index
+    itemsByGroup[groupKeys].set(i, item);
+  });
+  return groupsOrder;
+}
+/**
+ * Gather data for grouping
+ * @param array - flat data array
+ * @param mapFunc - mapping function for stringify
+ * @param expanded - potentially expanded items if present
+ */
+function gatherGrouping(array, mapFunc, { prevExpanded, expandedAll }) {
+  // build groups
+  const groupsOrder = groupBy(array, mapFunc);
+  const itemsMirror = []; // grouped source
+  const pseudoGroupTest = {}; // check if group header exists
+  // item index in source
+  let itemIndex = 0;
+  // to save max group depth
+  let groupingDepth = 0;
+  // collapse all groups in the beginning
+  const trimmed = {};
+  // index mapping
+  const oldNewIndexMap = {};
+  // go through groups
+  groupsOrder.forEach(group => {
+    const parseGroup = getParsedGroup(group.id);
+    // extra precaution and type safe guard
+    if (!parseGroup) {
+      return;
+    }
+    let depth = 0;
+    let skipTrim = !!expandedAll;
+    let isExpanded = skipTrim;
+    const children = [];
+    // add group headers
+    parseGroup.reduce((prevVal, groupValue) => {
+      prevVal.push(groupValue);
+      const newVal = prevVal.join(',');
+      // if header not added, add new header
+      if (!pseudoGroupTest[newVal]) {
+        isExpanded = expandedAll || (prevExpanded && prevExpanded[newVal]);
+        itemsMirror.push(getPseudoGroup(groupValue, newVal, depth, group.id, isExpanded));
+        // if not first level auto collapse
+        if (depth && !isExpanded && !skipTrim) {
+          // check if parent expanded, expand this layer too
+          const parent = prevVal.slice(0, prevVal.length - 1);
+          if (!(prevExpanded && parent.length && prevExpanded[parent.join(',')])) {
+            trimmed[itemIndex] = true;
+          }
+        }
+        itemIndex++;
+        pseudoGroupTest[newVal] = children;
+      }
+      // calculate depth
+      depth++;
+      groupingDepth = depth;
+      return prevVal;
+    }, []);
+    // add regular items
+    group.children.forEach((item, oldIndex) => {
+      // hide items if group colapsed
+      if (!isExpanded && !skipTrim) {
+        // collapse rgRow
+        trimmed[itemIndex] = true;
+      }
+      // add items to new source
+      itemsMirror.push(item);
+      oldNewIndexMap[oldIndex] = itemIndex;
+      children.push(itemIndex);
+      itemIndex++;
+    });
+  });
+  return {
+    // updates source mirror
+    sourceWithGroups: itemsMirror,
+    // largest depth for grouping
+    depth: groupingDepth,
+    // used for expand/collapse grouping values
+    trimmed,
+    // used for mapping old values to new
+    oldNewIndexMap,
+    // used to get child items in group
+    childrenByGroup: pseudoGroupTest,
+  };
+}
+function getPseudoGroup(groupValue, value, depth, id, isExpanded = false) {
+  return {
+    [PSEUDO_GROUP_ITEM]: groupValue,
+    [GROUP_DEPTH]: depth,
+    [PSEUDO_GROUP_ITEM_ID]: id,
+    [PSEUDO_GROUP_ITEM_VALUE]: value,
+    [GROUP_EXPANDED]: isExpanded,
+  };
+}
+function getGroupingName(rgRow) {
+  return rgRow && rgRow[PSEUDO_GROUP_ITEM];
+}
+function isGrouping(rgRow) {
+  return rgRow && typeof rgRow[PSEUDO_GROUP_ITEM] !== 'undefined';
+}
+function isGroupingColumn(column) {
+  return column && typeof column[PSEUDO_GROUP_COLUMN] !== 'undefined';
+}
+function isArray(data) {
+  return typeof data.push !== 'undefined';
+}
+function measureEqualDepth(groupA, groupB) {
+  const ln = groupA.length;
+  let i = 0;
+  for (; i < ln; i++) {
+    if (groupA[i] !== groupB[i]) {
+      return i;
+    }
+  }
+  return i;
+}
+function getParsedGroup(id) {
+  const parseGroup = JSON.parse(id);
+  // extra precaution and type safe guard
+  if (!isArray(parseGroup)) {
+    return null;
+  }
+  return parseGroup;
+}
+// check if items is child of current clicked group
+function isSameGroup(currentGroup, currentModel, nextModel) {
+  const nextGroup = getParsedGroup(nextModel[PSEUDO_GROUP_ITEM_ID]);
+  if (!nextGroup) {
+    return false;
+  }
+  const depth = measureEqualDepth(currentGroup, nextGroup);
+  return currentModel[GROUP_DEPTH] < depth;
+}
+
+function isHiddenStore(pos) {
+  return pos === EMPTY_INDEX;
+}
+function nextCell(cell, lastCell) {
+  const nextItem = {};
+  let types = ['x', 'y'];
+  // previous item check
+  for (let t of types) {
+    if (cell[t] < 0) {
+      nextItem[t] = cell[t];
+      return nextItem;
+    }
+  }
+  // next item check
+  for (let t of types) {
+    if (cell[t] >= lastCell[t]) {
+      nextItem[t] = cell[t] - lastCell[t];
+      return nextItem;
+    }
+  }
+  return null;
+}
+function cropCellToMax(cell, lastCell) {
+  const newCell = Object.assign({}, cell);
+  let types = ['x', 'y'];
+  // previous item check
+  for (let t of types) {
+    if (cell[t] < 0) {
+      newCell[t] = 0;
+    }
+  }
+  // next item check
+  for (let t of types) {
+    if (cell[t] >= lastCell[t]) {
+      newCell[t] = lastCell[t] - 1;
+    }
+  }
+  return newCell;
+}
+function getRange(start, end) {
+  return start && end
+    ? {
+      x: Math.min(start.x, end.x),
+      y: Math.min(start.y, end.y),
+      x1: Math.max(start.x, end.x),
+      y1: Math.max(start.y, end.y),
+    }
+    : null;
+}
+function isRangeSingleCell(a) {
+  return a.x === a.x1 && a.y === a.y1;
+}
+
+function defaultState() {
+  return {
+    range: null,
+    tempRange: null,
+    tempRangeType: null,
+    focus: null,
+    edit: null,
+    lastCell: null,
+  };
+}
+class SelectionStore {
+  constructor() {
+    this.unsubscribe = [];
+    this.store = createStore(defaultState());
+    this.store.on('set', (key, newVal) => {
+      if (key === 'tempRange' && !newVal) {
+        this.store.set('tempRangeType', null);
+      }
+    });
+  }
+  onChange(propName, cb) {
+    this.unsubscribe.push(this.store.onChange(propName, cb));
+  }
+  clearFocus() {
+    setStore(this.store, { focus: null, range: null, edit: null, tempRange: null });
+  }
+  setFocus(focus, end) {
+    setStore(this.store, {
+      focus,
+      range: getRange(focus, end),
+      edit: null,
+      tempRange: null,
+    });
+  }
+  setTempArea(range) {
+    setStore(this.store, { tempRange: range === null || range === void 0 ? void 0 : range.area, tempRangeType: range === null || range === void 0 ? void 0 : range.type, edit: null });
+  }
+  clearTemp() {
+    setStore(this.store, { tempRange: null });
+  }
+  /** Can be applied from selection change or from simple keyboard change clicks */
+  setRangeArea(range) {
+    setStore(this.store, { range, edit: null, tempRange: null });
+  }
+  setRange(start, end) {
+    this.setRangeArea(getRange(start, end));
+  }
+  setLastCell(lastCell) {
+    setStore(this.store, { lastCell });
+  }
+  setEdit(val) {
+    const focus = this.store.get('focus');
+    if (focus && typeof val === 'string') {
+      setStore(this.store, {
+        edit: { x: focus.x, y: focus.y, val },
+      });
+      return;
+    }
+    setStore(this.store, { edit: null });
+  }
+  dispose() {
+    this.unsubscribe.forEach(f => f());
+    this.store.dispose();
+  }
+}
+
+const EMPTY_INDEX = -1;
+class SelectionStoreConnector {
+  constructor() {
+    // dirty flag required to cleanup whole store in case visibility of panels changed
+    this.dirty = false;
+    this.stores = {};
+    this.columnStores = {};
+    this.rowStores = {};
+    this.sections = [];
+  }
+  get focusedStore() {
+    var _a;
+    for (let y in this.stores) {
+      for (let x in this.stores[y]) {
+        const focused = (_a = this.stores[y][x]) === null || _a === void 0 ? void 0 : _a.store.get('focus');
+        if (focused) {
+          return {
+            entity: this.stores[y][x],
+            cell: focused,
+            position: {
+              x: parseInt(x, 10),
+              y: parseInt(y, 10)
+            }
+          };
+        }
+      }
+    }
+    return null;
+  }
+  get edit() {
+    var _a;
+    return (_a = this.focusedStore) === null || _a === void 0 ? void 0 : _a.entity.store.get('edit');
+  }
+  get focused() {
+    var _a;
+    return (_a = this.focusedStore) === null || _a === void 0 ? void 0 : _a.entity.store.get('focus');
+  }
+  get selectedRange() {
+    var _a;
+    return (_a = this.focusedStore) === null || _a === void 0 ? void 0 : _a.entity.store.get('range');
+  }
+  registerSection(e) {
+    if (!e) {
+      this.sections.length = 0;
+      // some elements removed, rebuild stores
+      this.dirty = true;
+      return;
+    }
+    if (this.sections.indexOf(e) === -1) {
+      this.sections.push(e);
+    }
+  }
+  // check if require to cleanup all stores
+  beforeUpdate() {
+    if (this.dirty) {
+      for (let y in this.stores) {
+        for (let x in this.stores[y]) {
+          this.stores[y][x].dispose();
+        }
+      }
+      this.dirty = false;
+    }
+  }
+  registerColumn(x) {
+    // if hidden just create store
+    if (isHiddenStore(x)) {
+      return new SelectionStore();
+    }
+    if (this.columnStores[x]) {
+      return this.columnStores[x];
+    }
+    this.columnStores[x] = new SelectionStore();
+    return this.columnStores[x];
+  }
+  registerRow(y) {
+    // if hidden just create store
+    if (isHiddenStore(y)) {
+      return new SelectionStore();
+    }
+    if (this.rowStores[y]) {
+      return this.rowStores[y];
+    }
+    this.rowStores[y] = new SelectionStore();
+    return this.rowStores[y];
+  }
+  /**
+   * Cross store proxy, based on multiple dimensions
+   */
+  register({ x, y }) {
+    var _a, _b;
+    // if hidden just create store
+    if (isHiddenStore(x) || isHiddenStore(y)) {
+      return new SelectionStore();
+    }
+    if (!this.stores[y]) {
+      this.stores[y] = {};
+    }
+    if (this.stores[y][x]) {
+      // Store already registered. Do not register twice
+      return this.stores[y][x];
+    }
+    this.stores[y][x] = new SelectionStore();
+    // proxy update
+    (_a = this.stores[y][x]) === null || _a === void 0 ? void 0 : _a.onChange('range', c => {
+      this.columnStores[x].setRangeArea(c);
+      this.rowStores[y].setRangeArea(c);
+    });
+    // clean up on remove
+    (_b = this.stores[y][x]) === null || _b === void 0 ? void 0 : _b.store.on('dispose', () => {
+      var _a, _b;
+      (_a = this.columnStores[x]) === null || _a === void 0 ? void 0 : _a.dispose();
+      (_b = this.rowStores[y]) === null || _b === void 0 ? void 0 : _b.dispose();
+      delete this.rowStores[y];
+      delete this.columnStores[x];
+      if (this.stores[y]) {
+        delete this.stores[y][x];
+      }
+      // clear empty rows
+      if (!Object.keys(this.stores[y] || {}).length) {
+        delete this.stores[y];
+      }
+    });
+    return this.stores[y][x];
+  }
+  setEditByCell({ x, y }, editCell) {
+    const store = this.stores[y][x];
+    this.focus(store, { focus: editCell, end: editCell });
+    this.setEdit('');
+  }
+  focus(store, { focus, end }) {
+    let currentStorePointer;
+    // clear all stores focus leave only active one
+    for (let y in this.stores) {
+      for (let x in this.stores[y]) {
+        const s = this.stores[y][x];
+        // clear other stores, only one area can be selected
+        if (s !== store) {
+          s.clearFocus();
+        }
+        else {
+          currentStorePointer = { x: parseInt(x, 10), y: parseInt(y, 10) };
+        }
+      }
+    }
+    if (!currentStorePointer) {
+      return;
+    }
+    // check is focus in next store
+    const lastCell = store.store.get('lastCell');
+    // item in new store
+    const nextItem = nextCell(focus, lastCell);
+    let nextStore;
+    if (nextItem) {
+      for (let i in nextItem) {
+        let type = i;
+        let stores;
+        switch (type) {
+          case 'x':
+            stores = this.getXStores(currentStorePointer.y);
+            break;
+          case 'y':
+            stores = this.getYStores(currentStorePointer.x);
+            break;
+        }
+        if (nextItem[type] >= 0) {
+          nextStore = stores[++currentStorePointer[type]];
+        }
+        else {
+          nextStore = stores[--currentStorePointer[type]];
+          const nextLastCell = nextStore === null || nextStore === void 0 ? void 0 : nextStore.store.get('lastCell');
+          if (nextLastCell) {
+            nextItem[type] = nextLastCell[type] + nextItem[type];
+          }
+        }
+      }
+    }
+    // if next store present - update
+    if (nextStore) {
+      let item = Object.assign(Object.assign({}, focus), nextItem);
+      this.focus(nextStore, { focus: item, end: item });
+      return;
+    }
+    focus = cropCellToMax(focus, lastCell);
+    end = cropCellToMax(focus, lastCell);
+    store.setFocus(focus, end);
+  }
+  clearAll() {
+    var _a;
+    for (let y in this.stores) {
+      for (let x in this.stores[y]) {
+        (_a = this.stores[y][x]) === null || _a === void 0 ? void 0 : _a.clearFocus();
+      }
+    }
+  }
+  setEdit(val) {
+    if (!this.focusedStore) {
+      return;
+    }
+    this.focusedStore.entity.setEdit(val);
+  }
+  getXStores(y) {
+    return this.stores[y];
+  }
+  getYStores(x) {
+    const stores = {};
+    for (let i in this.stores) {
+      stores[i] = this.stores[i][x];
+    }
+    return stores;
+  }
+}
+
+export { EMPTY_INDEX as E, GROUP_EXPANDED as G, PSEUDO_GROUP_ITEM_ID as P, SelectionStoreConnector as S, getParsedGroup as a, isSameGroup as b, GROUP_DEPTH as c, GROUPING_ROW_TYPE as d, PSEUDO_GROUP_ITEM_VALUE as e, PSEUDO_GROUP_COLUMN as f, getGroupingName as g, GROUP_EXPAND_EVENT as h, isGrouping as i, gatherGrouping as j, isGroupingColumn as k, getRange as l, isRangeSingleCell as m, PSEUDO_GROUP_ITEM as n, GROUP_EXPAND_BTN as o };

package/dist/{collection/components/overlay/selection.utils.js → revo-grid/selection.utils-a9932db6.js}

@@ -1,6 +1,10 @@
-import { getItemByIndex, getItemByPosition } from '../../store/dimension/dimension.helpers';
+/*!
+ * Built by Revolist
+ */
+import { a as getItemByPosition, g as getItemByIndex } from './dimension.helpers-a7944fc4.js';
+
 /** Calculate cell based on x, y position */
-export function getCurrentCell({ x, y }, { el, rows, cols }) {
+function getCurrentCell({ x, y }, { el, rows, cols }) {
   const { top, left, height, width } = el.getBoundingClientRect();
   let cellY = y - top;
   // limit to element height
@@ -24,7 +28,7 @@ export function getCurrentCell({ x, y }, { el, rows, cols }) {
   }
   return { x: rgCol.itemIndex, y: rgRow.itemIndex };
 }
-export function getCoordinate(range, focus, changes, isMulti = false) {
+function getCoordinate(range, focus, changes, isMulti = false) {
   const updateCoordinate = (c) => {
     const start = { x: range.x, y: range.y };
     const end = isMulti ? { x: range.x1, y: range.y1 } : start;
@@ -41,15 +45,15 @@ export function getCoordinate(range, focus, changes, isMulti = false) {
   return null;
 }
 /** check if out of range */
-export function isAfterLast({ x, y }, { lastCell }) {
+function isAfterLast({ x, y }, { lastCell }) {
   return x >= lastCell.x || y >= lastCell.y;
 }
 /** check if out of range */
-export function isBeforeFirst({ x, y }) {
+function isBeforeFirst({ x, y }) {
   return x < 0 || y < 0;
 }
 /** Compare cells, only 1 coordinate difference is possible */
-export function getDirectionCoordinate(initial, last) {
+function getDirectionCoordinate(initial, last) {
   const c = ['x', 'y'];
   for (let k of c) {
     if (initial[k] !== last[k]) {
@@ -58,7 +62,7 @@ export function getDirectionCoordinate(initial, last) {
   }
   return null;
 }
-export function getLargestAxis(initial, last) {
+function getLargestAxis(initial, last) {
   const cell = {};
   const c = ['x', 'y'];
   for (let k of c) {
@@ -80,7 +84,7 @@ function styleByCellProps(styles) {
     height: `${styles.height}px`,
   };
 }
-export function getCell({ x, y, x1, y1 }, dimensionRow, dimensionCol) {
+function getCell({ x, y, x1, y1 }, dimensionRow, dimensionCol) {
   const top = getItemByIndex(dimensionRow, y).start;
   const left = getItemByIndex(dimensionCol, x).start;
   const bottom = getItemByIndex(dimensionRow, y1).end;
@@ -94,7 +98,9 @@ export function getCell({ x, y, x1, y1 }, dimensionRow, dimensionCol) {
     height: bottom - top,
   };
 }
-export function getElStyle(range, dimensionRow, dimensionCol) {
+function getElStyle(range, dimensionRow, dimensionCol) {
   const styles = getCell(range, dimensionRow, dimensionCol);
   return styleByCellProps(styles);
 }
+
+export { getCoordinate as a, isBeforeFirst as b, getCell as c, getCurrentCell as d, getDirectionCoordinate as e, getLargestAxis as f, getElStyle as g, isAfterLast as i };