@revolist/revogrid 3.1.6 → 3.2.4

package/dist/collection/plugins/groupingRow/grouping.row.renderer.js

@@ -1,29 +0,0 @@
-import { h } from '@stencil/core';
-import RowRenderer from '../../components/data/rowRenderer';
-import { GROUP_DEPTH, GROUP_EXPANDED, GROUP_EXPAND_BTN, GROUP_EXPAND_EVENT, PSEUDO_GROUP_ITEM } from './grouping.const';
-function expandEvent(e, model, virtualIndex) {
-  const event = new CustomEvent(GROUP_EXPAND_EVENT, {
-    detail: {
-      model,
-      virtualIndex,
-    },
-    cancelable: true,
-    bubbles: true,
-  });
-  e.target.dispatchEvent(event);
-}
-const GroupingRowRenderer = (props) => {
-  const { model, itemIndex, hasExpand } = props;
-  const name = model[PSEUDO_GROUP_ITEM];
-  const expanded = model[GROUP_EXPANDED];
-  const depth = parseInt(model[GROUP_DEPTH], 10) || 0;
-  if (!hasExpand) {
-    return h(RowRenderer, Object.assign({}, props, { rowClass: "groupingRow", depth: depth }));
-  }
-  return (h(RowRenderer, Object.assign({}, props, { rowClass: "groupingRow", depth: depth }),
-    h("button", { class: { [GROUP_EXPAND_BTN]: true }, onClick: e => expandEvent(e, model, itemIndex) },
-      h("svg", { "aria-hidden": "true", style: { transform: `rotate(${!expanded ? -90 : 0}deg)` }, focusable: "false", viewBox: "0 0 448 512" },
-        h("path", { fill: "currentColor", d: "M207.029 381.476L12.686 187.132c-9.373-9.373-9.373-24.569 0-33.941l22.667-22.667c9.357-9.357 24.522-9.375 33.901-.04L224 284.505l154.745-154.021c9.379-9.335 24.544-9.317 33.901.04l22.667 22.667c9.373 9.373 9.373 24.569 0 33.941L240.971 381.476c-9.373 9.372-24.569 9.372-33.942 0z" }))),
-    name));
-};
-export default GroupingRowRenderer;

package/dist/collection/plugins/groupingRow/grouping.row.types.js

@@ -1 +0,0 @@
-export {};

package/dist/collection/plugins/groupingRow/grouping.service.js

@@ -1,155 +0,0 @@
-import { GROUP_DEPTH, GROUP_EXPANDED, PSEUDO_GROUP_COLUMN, PSEUDO_GROUP_ITEM, PSEUDO_GROUP_ITEM_ID, PSEUDO_GROUP_ITEM_VALUE } from './grouping.const';
-/**
- * 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
- */
-export 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,
-  };
-}
-export function getGroupingName(rgRow) {
-  return rgRow && rgRow[PSEUDO_GROUP_ITEM];
-}
-export function isGrouping(rgRow) {
-  return rgRow && typeof rgRow[PSEUDO_GROUP_ITEM] !== 'undefined';
-}
-export function isGroupingColumn(column) {
-  return column && typeof column[PSEUDO_GROUP_COLUMN] !== 'undefined';
-}
-export function isArray(data) {
-  return typeof data.push !== 'undefined';
-}
-export function measureEqualDepth(groupA, groupB) {
-  const ln = groupA.length;
-  let i = 0;
-  for (; i < ln; i++) {
-    if (groupA[i] !== groupB[i]) {
-      return i;
-    }
-  }
-  return i;
-}
-export 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
-export 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;
-}

package/dist/collection/plugins/groupingRow/grouping.trimmed.service.js

@@ -1,57 +0,0 @@
-import { gatherTrimmedItems } from '../trimmed/trimmed.plugin';
-export const TRIMMED_GROUPING = 'grouping';
-/**
- * Prepare trimming updated indexes for grouping
- * @param initiallyTrimed
- * @param firstLevelMap
- * @param secondLevelMap
- */
-export function processDoubleConversionTrimmed(initiallyTrimed, firstLevelMap, secondLevelMap) {
-  const trimemedOptionsToUpgrade = {};
-  /**
-   * go through all groups except grouping
-   */
-  for (let type in initiallyTrimed) {
-    if (type === TRIMMED_GROUPING) {
-      continue;
-    }
-    const items = initiallyTrimed[type];
-    const newItems = {};
-    for (let initialIndex in items) {
-      /**
-       * if item exists we find it in collection
-       * we support 2 level of conversions
-       */
-      let newConversionIndex = firstLevelMap[initialIndex];
-      if (secondLevelMap) {
-        newConversionIndex = secondLevelMap[newConversionIndex];
-      }
-      /**
-       * if item was trimmed previously
-       * trimming makes sense to apply
-       */
-      if (items[initialIndex]) {
-        newItems[newConversionIndex] = true;
-        /**
-         * If changes present apply changes to new source
-         */
-        if (newConversionIndex !== parseInt(initialIndex, 10)) {
-          trimemedOptionsToUpgrade[type] = newItems;
-        }
-      }
-    }
-  }
-  return trimemedOptionsToUpgrade;
-}
-export function filterOutEmptyGroups(allTrimmedGroups, childrenByGroup = {}) {
-  const trimmedGroup = {};
-  const allTrimmed = gatherTrimmedItems(allTrimmedGroups);
-  // find is groups are filled
-  for (let groupIndex in childrenByGroup) {
-    const hasChidlren = childrenByGroup[groupIndex].filter(childIndex => !allTrimmed[childIndex]).length > 0;
-    if (!hasChidlren) {
-      trimmedGroup[groupIndex] = true;
-    }
-  }
-  return trimmedGroup;
-}

package/dist/collection/plugins/sorting/sorting.plugin.js

@@ -1,181 +0,0 @@
-import size from 'lodash/size';
-import { setStore } from '../../utils/store.utils';
-import ColumnDataProvider from '../../services/column.data.provider';
-import BasePlugin from '../basePlugin';
-/**
- * lifecycle
- * 1) @event beforesorting - sorting just started, nothing happened yet
- * 2) @metod updateColumnSorting - column sorting icon applied to grid and column get updated, data still untiuched
- * 3) @event beforesortingapply - before we applied sorting data to data source, you can prevent data apply from here
- * 4) @event afterSortingApply - sorting applied, just finished event
- *
- * If you prevent event it'll not reach farther steps
- */
-export default class SortingPlugin extends BasePlugin {
-  constructor(revogrid) {
-    super(revogrid);
-    this.revogrid = revogrid;
-    this.sorting = null;
-    this.sortingFunc = null;
-    const beforesourceset = ({ detail }) => {
-      if (this.hasSorting) {
-        // is sorting allowed
-        const event = this.emit('beforesourcesortingapply');
-        // sorting prevented
-        if (event.defaultPrevented) {
-          return;
-        }
-      }
-      const data = this.setData(detail.source, detail.type);
-      if (data) {
-        detail.source = data;
-      }
-    };
-    const aftercolumnsset = async ({ detail: { order } }) => {
-      const columns = await this.revogrid.getColumns();
-      const sortingFunc = {};
-      for (let prop in order) {
-        const column = ColumnDataProvider.getColumnByProp(columns, prop);
-        const cmp = (column === null || column === void 0 ? void 0 : column.cellCompare) || this.defaultCellCompare;
-        sortingFunc[prop] = order[prop] == 'desc' ? this.descCellCompare(cmp) : cmp;
-      }
-      this.sort(order, sortingFunc);
-    };
-    const headerclick = async (e) => {
-      var _a, _b;
-      if (e.defaultPrevented) {
-        return;
-      }
-      if (!e.detail.column.sortable) {
-        return;
-      }
-      this.headerclick(e.detail.column, e.detail.index, (_b = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.originalEvent) === null || _b === void 0 ? void 0 : _b.shiftKey);
-    };
-    this.addEventListener('beforesourceset', beforesourceset);
-    this.addEventListener('aftercolumnsset', aftercolumnsset);
-    this.addEventListener('initialHeaderClick', headerclick);
-  }
-  get hasSorting() {
-    return !!this.sorting;
-  }
-  async headerclick(column, index, additive) {
-    let order = this.getNextOrder(column.order);
-    const beforeEvent = this.emit('beforesorting', { column, order, additive });
-    if (beforeEvent.defaultPrevented) {
-      return;
-    }
-    order = beforeEvent.detail.order;
-    const newCol = await this.revogrid.updateColumnSorting(beforeEvent.detail.column, index, order, additive);
-    // apply sort data
-    const beforeApplyEvent = this.emit('beforesortingapply', { column: newCol, order, additive });
-    if (beforeApplyEvent.defaultPrevented) {
-      return;
-    }
-    order = beforeApplyEvent.detail.order;
-    const cellCmp = (column === null || column === void 0 ? void 0 : column.cellCompare) || this.defaultCellCompare;
-    const cmp = order == 'asc' ? cellCmp : order == 'desc' ? this.descCellCompare(cellCmp) : undefined;
-    if (additive && this.sorting) {
-      const sorting = {};
-      const sortingFunc = {};
-      Object.assign(sorting, this.sorting);
-      Object.assign(sortingFunc, this.sortingFunc);
-      if (column.prop in sorting && size(sorting) > 1 && order === undefined) {
-        delete sorting[column.prop];
-        delete sortingFunc[column.prop];
-      }
-      else {
-        sorting[column.prop] = order;
-        sortingFunc[column.prop] = cmp;
-      }
-      this.sort(sorting, sortingFunc);
-    }
-    else {
-      this.sort({ [column.prop]: order }, { [column.prop]: cmp });
-    }
-  }
-  setData(data, type) {
-    // sorting available for rgRow type only
-    if (type === 'rgRow' && this.sortingFunc) {
-      return this.sortItems(data, this.sortingFunc);
-    }
-  }
-  /**
-   * Sorting apply, available for rgRow type only
-   * @param sorting - per column sorting
-   * @param data - this.stores['rgRow'].store.get('source')
-   */
-  async sort(sorting, sortingFunc) {
-    if (!size(sorting)) {
-      this.sorting = null;
-      this.sortingFunc = null;
-      return;
-    }
-    this.sorting = sorting;
-    this.sortingFunc = sortingFunc;
-    const store = await this.revogrid.getSourceStore();
-    const source = store.get('source');
-    const proxyItems = this.sortIndexByItems([...store.get('proxyItems')], source, this.sortingFunc);
-    setStore(store, {
-      proxyItems,
-      source: [...source],
-    });
-    this.emit('afterSortingApply');
-  }
-  defaultCellCompare(prop, a, b) {
-    var _a, _b;
-    const av = (_a = a[prop]) === null || _a === void 0 ? void 0 : _a.toString().toLowerCase();
-    const bv = (_b = b[prop]) === null || _b === void 0 ? void 0 : _b.toString().toLowerCase();
-    return av == bv ? 0 : av > bv ? 1 : -1;
-  }
-  descCellCompare(cmp) {
-    return (prop, a, b) => { return -1 * cmp(prop, a, b); };
-  }
-  sortIndexByItems(indexes, source, sortingFunc) {
-    // TODO - is there a situation where multiple kvps in the `sorting` object would cause this to break?
-    for (let prop in sortingFunc) {
-      if (typeof sortingFunc[prop] === 'undefined') {
-        // Unsort indexes
-        return [...Array(indexes.length).keys()];
-      }
-    }
-    return indexes.sort((a, b) => {
-      let sorted = 0;
-      for (let prop in sortingFunc) {
-        const cmp = sortingFunc[prop];
-        const itemA = source[a];
-        const itemB = source[b];
-        sorted = cmp(prop, itemA, itemB);
-        if (sorted) {
-          break;
-        }
-      }
-      return sorted;
-    });
-  }
-  sortItems(source, sortingFunc) {
-    return source.sort((a, b) => {
-      let sorted = 0;
-      for (let prop in sortingFunc) {
-        const cmp = sortingFunc[prop];
-        if (!cmp) {
-          continue;
-        }
-        sorted = cmp(prop, a, b);
-        if (sorted) {
-          break;
-        }
-      }
-      return sorted;
-    });
-  }
-  getNextOrder(currentOrder) {
-    switch (currentOrder) {
-      case undefined:
-        return 'asc';
-      case 'asc':
-        return 'desc';
-      case 'desc':
-        return undefined;
-    }
-  }
-}

package/dist/collection/plugins/sorting/sorting.sign.js

@@ -1,6 +0,0 @@
-import { h } from '@stencil/core';
-export const FILTER_BUTTON_CLASS = 'rv-filter';
-export const FILTER_BUTTON_ACTIVE = 'active';
-export const SortingSign = ({ column }) => {
-  return h("i", { class: column.order });
-};

package/dist/collection/plugins/stretchPlugin.js

@@ -1,68 +0,0 @@
-import { each } from 'lodash';
-import { getScrollbarWidth } from '../utils/utils';
-import BasePlugin from './basePlugin';
-export default class StretchColumn extends BasePlugin {
-  constructor(revogrid, dimensionProvider) {
-    super(revogrid);
-    this.dimensionProvider = dimensionProvider;
-    this.stretchedColumn = null;
-    this.scrollSize = getScrollbarWidth(document);
-    const beforecolumnapplied = ({ detail: { columns } }) => this.applyStretch(columns);
-    this.addEventListener('beforecolumnapplied', beforecolumnapplied);
-  }
-  setScroll({ type, hasScroll }) {
-    var _a;
-    if (type === 'rgRow' && this.stretchedColumn && ((_a = this.stretchedColumn) === null || _a === void 0 ? void 0 : _a.initialSize) === this.stretchedColumn.size) {
-      if (hasScroll) {
-        this.stretchedColumn.size -= this.scrollSize;
-        this.apply();
-        this.dropChanges();
-      }
-    }
-  }
-  activateChanges() {
-    const setScroll = ({ detail }) => this.setScroll(detail);
-    this.addEventListener('scrollchange', setScroll);
-  }
-  dropChanges() {
-    this.stretchedColumn = null;
-    this.removeEventListener('scrollchange');
-  }
-  apply() {
-    if (!this.stretchedColumn) {
-      return;
-    }
-    const type = 'rgCol';
-    this.dimensionProvider.setDimensionSize(type, { [this.stretchedColumn.index]: this.stretchedColumn.size });
-  }
-  applyStretch(columns) {
-    this.dropChanges();
-    let sizeDifference = this.revogrid.clientWidth - 1;
-    each(columns, (_c, type) => {
-      const realSize = this.dimensionProvider.stores[type].store.get('realSize');
-      sizeDifference -= realSize;
-    });
-    if (sizeDifference > 0) {
-      // currently plugin accepts last column
-      const index = columns.rgCol.length - 1;
-      const last = columns.rgCol[index];
-      // has column
-      // no auto size applied
-      // size for column shouldn't be defined
-      const colSize = (last === null || last === void 0 ? void 0 : last.size) || this.revogrid.colSize || 0;
-      const size = sizeDifference + colSize - 1;
-      if (last && !last.autoSize && (colSize < size)) {
-        this.stretchedColumn = {
-          initialSize: size,
-          index,
-          size
-        };
-        this.apply();
-        this.activateChanges();
-      }
-    }
-  }
-}
-export function isStretchPlugin(plugin) {
-  return !!plugin.applyStretch;
-}

package/dist/collection/plugins/trimmed/trimmed.plugin.js

@@ -1,32 +0,0 @@
-/**
- * Hide items from main collection
- * But keep them in store
- */
-export const trimmedPlugin = (store) => ({
-  set(k, newVal) {
-    switch (k) {
-      case 'trimmed':
-        const proxy = store.get('proxyItems');
-        const trimmed = gatherTrimmedItems(newVal);
-        const newItems = proxy.reduce((result, v) => {
-          // check if present in new trimmed remove from items (filter)
-          if (!trimmed[v]) {
-            result.push(v);
-          }
-          return result;
-        }, []);
-        store.set('items', newItems);
-        break;
-    }
-  },
-});
-export function gatherTrimmedItems(trimmedItems) {
-  const trimmed = {};
-  for (let trimmedKey in trimmedItems) {
-    // trimmed overweight not trimmed
-    for (let t in trimmedItems[trimmedKey]) {
-      trimmed[t] = trimmed[t] || trimmedItems[trimmedKey][t];
-    }
-  }
-  return trimmed;
-}

package/dist/collection/services/cell.helpers.js

@@ -1,7 +0,0 @@
-import { DATA_COL, DATA_ROW } from '../utils/consts';
-export function getCell(cell) {
-  return {
-    x: parseInt(cell.getAttribute(DATA_COL), 10),
-    y: parseInt(cell.getAttribute(DATA_ROW), 10),
-  };
-}