@revolist/revogrid 3.1.6 → 3.2.4

package/dist/collection/services/column.data.provider.js

@@ -1,188 +0,0 @@
-import reduce from 'lodash/reduce';
-import each from 'lodash/each';
-import find from 'lodash/find';
-import DataStore, { getSourceItem, getSourceItemVirtualIndexByProp, setSourceByVirtualIndex } from '../store/dataSource/data.store';
-import { columnTypes } from '../store/storeTypes';
-import GroupingColumnPlugin from '../plugins/groupingColumn/grouping.col.plugin';
-export default class ColumnDataProvider {
-  constructor() {
-    this.sorting = null;
-    this.dataSources = reduce(columnTypes, (sources, k) => {
-      sources[k] = new DataStore(k);
-      return sources;
-    }, {});
-  }
-  get order() {
-    return reduce(this.sorting, (r, c, prop) => {
-      r[prop] = c.order;
-      return r;
-    }, {});
-  }
-  get stores() {
-    return this.dataSources;
-  }
-  column(c, pin) {
-    return this.getColumn(c, pin || 'rgCol');
-  }
-  getColumn(virtualIndex, type) {
-    return getSourceItem(this.dataSources[type].store, virtualIndex);
-  }
-  getRawColumns() {
-    return reduce(this.dataSources, (result, item, type) => {
-      result[type] = item.store.get('source');
-      return result;
-    }, {
-      rgCol: [],
-      colPinStart: [],
-      colPinEnd: []
-    });
-  }
-  getColumns(type = 'all') {
-    if (type !== 'all') {
-      return this.dataSources[type].store.get('source');
-    }
-    return columnTypes.reduce((r, t) => {
-      r.push(...this.dataSources[t].store.get('source'));
-      return r;
-    }, []);
-  }
-  getColumnIndexByProp(prop, type) {
-    return getSourceItemVirtualIndexByProp(this.dataSources[type].store, prop);
-  }
-  getColumnByProp(prop, type) {
-    const items = this.dataSources[type].store.get('source');
-    return find(items, { prop });
-  }
-  refreshByType(type) {
-    this.dataSources[type].refresh();
-  }
-  setColumns(data) {
-    each(columnTypes, k => {
-      // set columns data
-      this.dataSources[k].updateData(data.columns[k], {
-        // max depth level
-        depth: data.maxLevel,
-        // groups
-        groups: reduce(data.columnGrouping[k], (res, g) => {
-          if (!res[g.level]) {
-            res[g.level] = [];
-          }
-          res[g.level].push(g);
-          return res;
-        }, {}),
-      });
-    });
-    this.sorting = data.sort;
-    return data;
-  }
-  updateColumns(cols) {
-    // collect column by type and propert
-    const columnByKey = cols.reduce((res, c) => {
-      const type = ColumnDataProvider.getColumnType(c);
-      if (!res[type]) {
-        res[type] = {};
-      }
-      res[type][c.prop] = c;
-      return res;
-    }, {});
-    // find indexes in source
-    const colByIndex = {};
-    each(columnByKey, (colsToUpdate, type) => {
-      const items = this.dataSources[type].store.get('source');
-      colByIndex[type] = items.reduce((result, rgCol, index) => {
-        const colToUpdateIfExists = colsToUpdate[rgCol.prop];
-        if (colToUpdateIfExists) {
-          result[index] = colToUpdateIfExists;
-        }
-        return result;
-      }, {});
-    });
-    each(colByIndex, (colsToUpdate, type) => setSourceByVirtualIndex(this.dataSources[type].store, colsToUpdate));
-  }
-  updateColumn(column, index) {
-    const type = ColumnDataProvider.getColumnType(column);
-    setSourceByVirtualIndex(this.dataSources[type].store, { [index]: column });
-  }
-  updateColumnSorting(column, index, sorting, additive) {
-    if (!additive) {
-      this.clearSorting();
-    }
-    column.order = sorting;
-    this.sorting[column.prop] = column;
-    this.updateColumn(column, index);
-    return column;
-  }
-  clearSorting() {
-    const types = reduce(this.sorting, (r, c) => {
-      const k = ColumnDataProvider.getColumnType(c);
-      r[k] = true;
-      return r;
-    }, {});
-    each(types, (_, type) => {
-      const cols = this.dataSources[type].store.get('source');
-      each(cols, (c) => (c.order = undefined));
-      this.dataSources[type].setData({ source: [...cols] });
-    });
-    this.sorting = {};
-  }
-  static getSizes(cols) {
-    return reduce(cols, (res, c, i) => {
-      if (c.size) {
-        res[i] = c.size;
-      }
-      return res;
-    }, {});
-  }
-  static getColumnByProp(columns, prop) {
-    return find(columns, c => {
-      if (GroupingColumnPlugin.isColGrouping(c)) {
-        return ColumnDataProvider.getColumnByProp(c.children, prop);
-      }
-      return c.prop === prop;
-    });
-  }
-  // columns processing
-  static getColumns(columns, level = 0, types) {
-    return reduce(columns, (res, colData) => {
-      /** Grouped column */
-      if (GroupingColumnPlugin.isColGrouping(colData)) {
-        return GroupingColumnPlugin.gatherGroup(res, colData, ColumnDataProvider.getColumns(colData.children, level + 1, types), level);
-      }
-      /** Regular column */
-      const regularColumn = Object.assign(Object.assign({}, (colData.columnType && types && types[colData.columnType])), colData);
-      // not pin
-      if (!regularColumn.pin) {
-        res.columns.rgCol.push(regularColumn);
-        // pin
-      }
-      else {
-        res.columns[regularColumn.pin].push(regularColumn);
-      }
-      if (regularColumn.order) {
-        res.sort[regularColumn.prop] = regularColumn;
-      }
-      // trigger setup hook if present
-      regularColumn.beforeSetup && regularColumn.beforeSetup(regularColumn);
-      return res;
-    }, {
-      columns: {
-        rgCol: [],
-        colPinStart: [],
-        colPinEnd: [],
-      },
-      columnGrouping: {
-        rgCol: [],
-        colPinStart: [],
-        colPinEnd: [],
-      },
-      maxLevel: level,
-      sort: {},
-    });
-  }
-  static getColumnType(rgCol) {
-    if (rgCol.pin) {
-      return rgCol.pin;
-    }
-    return 'rgCol';
-  }
-}

package/dist/collection/services/data.provider.js

@@ -1,47 +0,0 @@
-import reduce from 'lodash/reduce';
-import DataStore, { getSourceItem, getVisibleSourceItem, setSourceByVirtualIndex } from '../store/dataSource/data.store';
-import { isRowType, rowTypes } from '../store/storeTypes';
-export class DataProvider {
-  constructor(dimensionProvider) {
-    this.dimensionProvider = dimensionProvider;
-    this.stores = reduce(rowTypes, (sources, k) => {
-      sources[k] = new DataStore(k);
-      return sources;
-    }, {});
-  }
-  setData(data, type = 'rgRow', grouping, silent = false) {
-    // set rgRow data
-    this.stores[type].updateData([...data], grouping, silent);
-    this.dimensionProvider.setData(data, type, type !== 'rgRow');
-    return data;
-  }
-  getModel(virtualIndex, type = 'rgRow') {
-    const store = this.stores[type].store;
-    return getSourceItem(store, virtualIndex);
-  }
-  setCellData({ type, rowIndex, prop, val }) {
-    const model = this.getModel(rowIndex, type);
-    model[prop] = val;
-    setSourceByVirtualIndex(this.stores[type].store, { [rowIndex]: model });
-  }
-  refresh(type = 'all') {
-    if (isRowType(type)) {
-      this.refreshItems(type);
-    }
-    rowTypes.forEach((t) => this.refreshItems(t));
-  }
-  refreshItems(type = 'rgRow') {
-    const items = this.stores[type].store.get('items');
-    this.stores[type].setData({ items: [...items] });
-  }
-  setGrouping({ depth }, type = 'rgRow') {
-    this.stores[type].setData({ groupingDepth: depth });
-  }
-  setTrimmed(trimmed, type = 'rgRow') {
-    const store = this.stores[type];
-    store.addTrimmed(trimmed);
-    if (type === 'rgRow') {
-      this.dimensionProvider.setData(getVisibleSourceItem(store.store), type);
-    }
-  }
-}

package/dist/collection/services/dimension.provider.js

@@ -1,78 +0,0 @@
-import reduce from 'lodash/reduce';
-import { columnTypes, rowTypes } from '../store/storeTypes';
-import DimensionStore from '../store/dimension/dimension.store';
-import { getItemByIndex } from '../store/dimension/dimension.helpers';
-export default class DimensionProvider {
-  constructor(viewports) {
-    this.viewports = viewports;
-    this.stores = reduce([...rowTypes, ...columnTypes], (sources, k) => {
-      sources[k] = new DimensionStore();
-      return sources;
-    }, {});
-  }
-  setDimensionSize(dimensionType, sizes) {
-    this.stores[dimensionType].setDimensionSize(sizes);
-    this.viewports.stores[dimensionType].setViewPortDimension(sizes);
-  }
-  setRealSize(realCount, type) {
-    this.viewports.stores[type].setViewport({ realCount });
-    this.stores[type].setRealSize(realCount);
-  }
-  /**
-   * Sets dimension data and view port coordinate
-   * @param items - data/column items
-   * @param type - dimension type
-   */
-  setData(items, type, noVirtual = false) {
-    this.setRealSize(items.length, type);
-    if (noVirtual) {
-      this.setNoVirtual(type);
-    }
-    this.setViewPortCoordinate({
-      coordinate: this.viewports.stores[type].store.get('lastCoordinate'),
-      type,
-    });
-  }
-  setNoVirtual(type) {
-    const dimension = this.stores[type].getCurrentState();
-    this.viewports.stores[type].setViewport({ virtualSize: dimension.realSize });
-  }
-  drop() {
-    for (let type of columnTypes) {
-      this.stores[type].drop();
-    }
-  }
-  setColumns(type, sizes, noVirtual = false) {
-    this.stores[type].setDimensionSize(sizes);
-    if (noVirtual) {
-      this.setNoVirtual(type);
-    }
-    this.setViewPortCoordinate({
-      coordinate: this.viewports.stores[type].store.get('lastCoordinate'),
-      type,
-    });
-  }
-  setViewPortCoordinate({ coordinate, type }) {
-    const dimension = this.stores[type].getCurrentState();
-    this.viewports.stores[type].setViewPortCoordinate(coordinate, dimension);
-  }
-  getViewPortPos(e) {
-    const dimension = this.stores[e.dimension].getCurrentState();
-    const item = getItemByIndex(dimension, e.coordinate);
-    return item.start;
-  }
-  setSettings(data, dimensionType) {
-    let stores = [];
-    switch (dimensionType) {
-      case 'rgCol':
-        stores = columnTypes;
-        break;
-      case 'rgRow':
-        stores = rowTypes;
-        break;
-    }
-    for (let s of stores) {
-      this.stores[s].setStore(data);
-    }
-  }
-}

package/dist/collection/services/resizable.directive.js

@@ -1,250 +0,0 @@
-import { h } from '@stencil/core';
-var ResizeEvents;
-(function (ResizeEvents) {
-  ResizeEvents["start"] = "resize:start";
-  ResizeEvents["move"] = "resize:move";
-  ResizeEvents["end"] = "resize:end";
-})(ResizeEvents || (ResizeEvents = {}));
-const RESIZE_MASK = {
-  'resizable-r': { bit: 0b0001, cursor: 'ew-resize' },
-  'resizable-rb': { bit: 0b0011, cursor: 'se-resize' },
-  'resizable-b': { bit: 0b0010, cursor: 's-resize' },
-  'resizable-lb': { bit: 0b0110, cursor: 'sw-resize' },
-  'resizable-l': { bit: 0b0100, cursor: 'w-resize' },
-  'resizable-lt': { bit: 0b1100, cursor: 'nw-resize' },
-  'resizable-t': { bit: 0b1000, cursor: 'n-resize' },
-  'resizable-rt': { bit: 0b1001, cursor: 'ne-resize' },
-};
-const DISABLE_MASK = {
-  l: 0b0001,
-  t: 0b0010,
-  w: 0b0100,
-  h: 0b1000,
-};
-const defaultProps = (props) => {
-  return Object.assign(Object.assign({}, props), { fitParent: props.fitParent || false, active: props.active || [], disableAttributes: props.disableAttributes || [], minWidth: props.minWidth || 0, minHeight: props.minHeight || 0 });
-};
-export class ResizeDirective {
-  constructor(initialProps, $event) {
-    this.initialProps = initialProps;
-    this.$event = $event;
-    this.mouseX = 0;
-    this.mouseY = 0;
-    this.width = 0;
-    this.height = 0;
-    this.changeX = 0;
-    this.changeY = 0;
-    this.disableCalcMap = 0b1111;
-    this.props = defaultProps(initialProps);
-    this.mouseMoveFunc = this.handleMove.bind(this);
-    this.mouseUpFunc = this.handleUp.bind(this);
-    this.minW = this.props.minWidth;
-    this.minH = this.props.minHeight;
-    this.maxW = this.props.maxWidth;
-    this.maxH = this.props.maxHeight;
-    this.parent = { width: 0, height: 0 };
-    this.resizeState = 0;
-  }
-  set($el) {
-    this.$el = $el;
-    this.props.disableAttributes.forEach(attr => {
-      switch (attr) {
-        case 'l':
-          this.disableCalcMap &= ~DISABLE_MASK.l;
-          break;
-        case 't':
-          this.disableCalcMap &= ~DISABLE_MASK.t;
-          break;
-        case 'w':
-          this.disableCalcMap &= ~DISABLE_MASK.w;
-          break;
-        case 'h':
-          this.disableCalcMap &= ~DISABLE_MASK.h;
-      }
-    });
-  }
-  emitEvent(eventName, additionalOptions) {
-    if (!this.$event) {
-      return;
-    }
-    this.$event(Object.assign({ eventName, width: this.width + this.changeX, height: this.height + this.changeY, changedX: this.changeX, changedY: this.changeY }, additionalOptions));
-  }
-  static isTouchEvent(e) {
-    var _a;
-    const event = e;
-    return ((_a = event.touches) === null || _a === void 0 ? void 0 : _a.length) >= 0;
-  }
-  handleMove(event) {
-    if (!this.resizeState) {
-      return;
-    }
-    let eventY, eventX;
-    if (ResizeDirective.isTouchEvent(event)) {
-      eventY = event.touches[0].clientY;
-      eventX = event.touches[0].clientX;
-    }
-    else {
-      eventY = event.clientY;
-      eventX = event.clientX;
-    }
-    let isX = this.resizeState & RESIZE_MASK['resizable-r'].bit || this.resizeState & RESIZE_MASK['resizable-l'].bit;
-    let isY = this.resizeState & RESIZE_MASK['resizable-t'].bit || this.resizeState & RESIZE_MASK['resizable-b'].bit;
-    if (isY && this.disableCalcMap & DISABLE_MASK.h) {
-      let diffY = eventY - this.mouseY;
-      let changedY = this.changeY + diffY;
-      const newHeight = this.height + changedY;
-      // if overcrossed min height
-      if (newHeight < this.minH) {
-        changedY = -(this.height - this.minH);
-      }
-      // if overcrossed max heiht
-      if (this.maxH && newHeight > this.maxH) {
-        changedY = this.maxH - this.height;
-      }
-      this.changeY = changedY;
-      this.mouseY = eventY;
-      if (this.activeResizer) {
-        this.activeResizer.style.bottom = `${-this.changeY}px`;
-      }
-    }
-    if (isX && this.disableCalcMap & DISABLE_MASK.w) {
-      let diffX = eventX - this.mouseX;
-      let changedX = this.changeX + diffX;
-      const newWidth = this.width + changedX;
-      // if overcrossed min width
-      if (newWidth < this.minW) {
-        changedX = -(this.width - this.minW);
-      }
-      // if overcrossed max width
-      if (this.maxW && newWidth > this.maxW) {
-        changedX = this.maxW - this.width;
-      }
-      this.changeX = changedX;
-      this.mouseX = eventX;
-      if (this.activeResizer) {
-        this.activeResizer.style.right = `${-this.changeX}px`;
-      }
-    }
-    this.emitEvent(ResizeEvents.move);
-  }
-  handleDown(event) {
-    if (event.defaultPrevented) {
-      return;
-    }
-    this.dropInitial();
-    for (let elClass in RESIZE_MASK) {
-      const target = event.target;
-      if (this.$el.contains(target) && (target === null || target === void 0 ? void 0 : target.classList.contains(elClass))) {
-        document.body.style.cursor = RESIZE_MASK[elClass].cursor;
-        if (ResizeDirective.isTouchEvent(event)) {
-          this.setInitials(event.touches[0], target);
-        }
-        else {
-          event.preventDefault && event.preventDefault();
-          this.setInitials(event, target);
-        }
-        this.resizeState = RESIZE_MASK[elClass].bit;
-        const eventName = ResizeEvents.start;
-        this.emitEvent(eventName);
-        break;
-      }
-    }
-    this.bindMove();
-  }
-  handleUp(e) {
-    e.preventDefault();
-    if (this.resizeState !== 0) {
-      this.resizeState = 0;
-      document.body.style.cursor = '';
-      const eventName = ResizeEvents.end;
-      this.emitEvent(eventName);
-    }
-    this.dropInitial();
-    this.unbindMove();
-  }
-  setInitials({ clientX, clientY }, target) {
-    const computedStyle = getComputedStyle(this.$el);
-    this.$el.classList.add('active');
-    this.activeResizer = target;
-    if (this.disableCalcMap & DISABLE_MASK.w) {
-      this.mouseX = clientX;
-      this.width = this.$el.clientWidth;
-      this.parent.width = this.$el.parentElement.clientWidth;
-      // min width
-      const minPaddingX = parseFloat(computedStyle.paddingLeft) + parseFloat(computedStyle.paddingRight);
-      this.minW = Math.max(minPaddingX, this.initialProps.minWidth || 0);
-      // max width
-      if (this.initialProps.maxWidth) {
-        this.maxW = Math.max(this.width, this.initialProps.maxWidth);
-      }
-    }
-    if (this.disableCalcMap & DISABLE_MASK.h) {
-      this.mouseY = clientY;
-      this.height = this.$el.clientHeight;
-      this.parent.height = this.$el.parentElement.clientHeight;
-      // min height
-      const minPaddingY = parseFloat(computedStyle.paddingTop) + parseFloat(computedStyle.paddingBottom);
-      this.minH = Math.max(minPaddingY, this.initialProps.minHeight || 0);
-      // max height
-      if (this.initialProps.maxHeight) {
-        this.maxH = Math.max(this.height, this.initialProps.maxHeight);
-      }
-    }
-  }
-  dropInitial() {
-    this.changeX = this.changeY = this.minW = this.minH;
-    this.width = this.height = 0;
-    if (this.activeResizer) {
-      this.activeResizer.removeAttribute('style');
-    }
-    this.$el.classList.remove('active');
-    this.activeResizer = null;
-  }
-  bindMove() {
-    document.documentElement.addEventListener('mouseup', this.mouseUpFunc, true);
-    document.documentElement.addEventListener('touchend', this.mouseUpFunc, true);
-    document.documentElement.addEventListener('mousemove', this.mouseMoveFunc, true);
-    document.documentElement.addEventListener('touchmove', this.mouseMoveFunc, true);
-    document.documentElement.addEventListener('mouseleave', this.mouseUpFunc);
-  }
-  unbindMove() {
-    document.documentElement.removeEventListener('mouseup', this.mouseUpFunc, true);
-    document.documentElement.removeEventListener('touchend', this.mouseUpFunc, true);
-    document.documentElement.removeEventListener('mousemove', this.mouseMoveFunc, true);
-    document.documentElement.removeEventListener('touchmove', this.mouseMoveFunc, true);
-    document.documentElement.removeEventListener('mouseleave', this.mouseUpFunc);
-  }
-}
-export const ResizableElement = (props, children) => {
-  const resizeEls = [];
-  const directive = (props.canResize &&
-    new ResizeDirective(props, e => {
-      if (e.eventName === ResizeEvents.end) {
-        props.onResize && props.onResize(e);
-      }
-    })) ||
-    null;
-  if (props.canResize) {
-    if (props.active) {
-      for (let p in props.active) {
-        resizeEls.push(h("div", { onClick: e => e.preventDefault(), onDblClick: e => {
-            e.preventDefault();
-            props.onDoubleClick && props.onDoubleClick();
-          }, onMouseDown: (e) => directive === null || directive === void 0 ? void 0 : directive.handleDown(e), onTouchStart: (e) => directive === null || directive === void 0 ? void 0 : directive.handleDown(e), class: `resizable resizable-${props.active[p]}` }));
-      }
-    }
-  }
-  else {
-    if (props.active) {
-      for (let p in props.active) {
-        resizeEls.push(h("div", { onClick: e => e.preventDefault(), onDblClick: e => {
-            e.preventDefault();
-            props.onDoubleClick && props.onDoubleClick();
-          }, class: `no-resize resizable resizable-${props.active[p]}` }));
-      }
-    }
-  }
-  return (h("div", Object.assign({}, props, { ref: (e) => directive === null || directive === void 0 ? void 0 : directive.set(e) }),
-    children,
-    resizeEls));
-};