@revolist/revogrid 3.2.0 → 3.2.4

package/dist/collection/services/selection.store.connector.js

@@ -1,213 +0,0 @@
-import { cropCellToMax, isHiddenStore, nextCell } from '../store/selection/selection.helpers';
-import { SelectionStore } from '../store/selection/selection.store';
-export const EMPTY_INDEX = -1;
-export default 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;
-  }
-}

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

@@ -1,14 +0,0 @@
-import reduce from 'lodash/reduce';
-import { columnTypes, rowTypes } from '../store/storeTypes';
-import ViewportStore from '../store/viewPort/viewport.store';
-export default class ViewportProvider {
-  constructor() {
-    this.stores = reduce([...rowTypes, ...columnTypes], (sources, k) => {
-      sources[k] = new ViewportStore();
-      return sources;
-    }, {});
-  }
-  setViewport(dimensionType, data) {
-    this.stores[dimensionType].setViewport(data);
-  }
-}

package/dist/collection/store/dataSource/data.proxy.js

@@ -1,34 +0,0 @@
-/**
- * All items
- * Used as proxy for sorting
- * Keep order but do not modify final source
- */
-export const proxyPlugin = (store) => ({
-  set(k, newVal) {
-    if (!isProxy(k)) {
-      return;
-    }
-    /**
-     * Getting existing collection of items
-     * Mark indexes as visible
-     */
-    const oldItems = store.get('items').reduce((r, v) => {
-      r[v] = true;
-      return r;
-    }, {});
-    /**
-     * Check if new values where present in items
-     * Filter item collection according presense
-     */
-    const newItems = newVal.reduce((r, i) => {
-      if (oldItems[i]) {
-        r.push(i);
-      }
-      return r;
-    }, []);
-    store.set('items', newItems);
-  },
-});
-function isProxy(k) {
-  return k === 'proxyItems';
-}

package/dist/collection/store/dataSource/data.store.js

@@ -1,127 +0,0 @@
-import { createStore } from '@stencil/store';
-import findIndex from 'lodash/findIndex';
-import range from 'lodash/range';
-import { trimmedPlugin } from '../../plugins/trimmed/trimmed.plugin';
-import { setStore } from '../../utils/store.utils';
-import { proxyPlugin } from './data.proxy';
-export default class DataStore {
-  constructor(type) {
-    const store = (this.dataStore = createStore({
-      items: [],
-      proxyItems: [],
-      source: [],
-      groupingDepth: 0,
-      groups: {},
-      type,
-      trimmed: {},
-    }));
-    store.use(proxyPlugin(store));
-    store.use(trimmedPlugin(store));
-  }
-  get store() {
-    return this.dataStore;
-  }
-  /**
-   * full data source update
-   * @param source - data column/rgRow source
-   * @param grouping - grouping information if present
-   */
-  updateData(source, grouping, silent = false) {
-    // during full update we do drop trim
-    if (!silent) {
-      this.store.set('trimmed', {});
-    }
-    // clear items
-    this.store.set('items', []);
-    const items = range(0, (source === null || source === void 0 ? void 0 : source.length) || 0);
-    // set proxy first
-    setStore(this.store, {
-      source,
-      proxyItems: [...items],
-    });
-    // update data items
-    this.store.set('items', items);
-    // apply grooping if present
-    if (grouping) {
-      setStore(this.store, {
-        groupingDepth: grouping.depth,
-        groups: grouping.groups,
-      });
-    }
-  }
-  addTrimmed(some) {
-    let trimmed = this.store.get('trimmed');
-    trimmed = Object.assign(Object.assign({}, trimmed), some);
-    setStore(this.store, { trimmed });
-  }
-  // local data update
-  setData(input) {
-    const data = Object.assign({}, input);
-    setStore(this.store, data);
-  }
-  refresh() {
-    const source = this.store.get('source');
-    this.store.set('source', [...source]);
-  }
-}
-/**
- * get physical index by virtual
- * @param store - store to process
- */
-export function getPhysical(store, virtualIndex) {
-  const items = store.get('items');
-  return items[virtualIndex];
-}
-/**
- * get all visible items
- * @param store - store to process
- */
-export function getVisibleSourceItem(store) {
-  const source = store.get('source');
-  return store.get('items').map(v => source[v]);
-}
-/**
- * get mapped item from source
- * @param store - store to process
- * @param virtualIndex - virtual index to process
- */
-export function getSourceItem(store, virtualIndex) {
-  const items = store.get('items');
-  const source = store.get('source');
-  return source[items[virtualIndex]];
-}
-/**
- * set item to source
- * @param store  - store to process
- * @param modelByIndex - collection of rows with virtual indexes to setup
- */
-export function setSourceByVirtualIndex(store, modelByIndex) {
-  const items = store.get('items');
-  const source = store.get('source');
-  for (let virtualIndex in modelByIndex) {
-    const realIndex = items[virtualIndex];
-    source[realIndex] = modelByIndex[virtualIndex];
-  }
-  store.set('source', [...source]);
-}
-/**
- * set item to source
- * @param store  - store to process
- * @param modelByIndex - collection of rows with physical indexes to setup
- */
-export function setSourceByPhysicalIndex(store, modelByIndex) {
-  const source = store.get('source');
-  for (let index in modelByIndex) {
-    source[index] = modelByIndex[index];
-  }
-  store.set('source', [...source]);
-}
-export function setItems(store, items) {
-  store.set('items', items);
-}
-export function getSourceItemVirtualIndexByProp(store, prop) {
-  const items = store.get('items');
-  const source = store.get('source');
-  const physicalIndex = findIndex(source, { prop });
-  return items.indexOf(physicalIndex);
-}

package/dist/collection/store/dimension/dimension.helpers.js

@@ -1,107 +0,0 @@
-import each from 'lodash/each';
-import sortedIndex from 'lodash/sortedIndex';
-import reduce from 'lodash/reduce';
-import { mergeSortedArray } from '../../utils/utils';
-/**
- * Pre-calculation
- * Dimension sizes for each cell
- */
-export function calculateDimensionData(state, newSizes) {
-  let positionIndexes = [];
-  const positionIndexToItem = {};
-  const indexToItem = {};
-  // to compare how real width changed
-  let newTotal = 0;
-  // combine all sizes
-  const sizes = Object.assign(Object.assign({}, state.sizes), newSizes);
-  // prepare order sorted new sizes and calculate changed real size
-  let newIndexes = [];
-  each(newSizes, (size, index) => {
-    // if first introduced custom size
-    if (!state.sizes[index]) {
-      newTotal += size - (state.realSize ? state.originItemSize : 0);
-      newIndexes.splice(sortedIndex(newIndexes, parseInt(index, 10)), 0, parseInt(index, 10));
-    }
-    else {
-      newTotal += size - state.sizes[index];
-    }
-  });
-  // add order to cached order collection for faster linking
-  const updatedIndexesCache = mergeSortedArray(state.indexes, newIndexes);
-  // fill new coordinates
-  reduce(updatedIndexesCache, (previous, itemIndex, i) => {
-    const newItem = {
-      itemIndex,
-      start: 0,
-      end: 0,
-    };
-    if (previous) {
-      newItem.start = (itemIndex - previous.itemIndex - 1) * state.originItemSize + previous.end;
-    }
-    else {
-      newItem.start = itemIndex * state.originItemSize;
-    }
-    newItem.end = newItem.start + sizes[itemIndex];
-    positionIndexes.push(newItem.start);
-    indexToItem[itemIndex] = positionIndexToItem[i] = newItem;
-    return newItem;
-  }, undefined);
-  return {
-    indexes: updatedIndexesCache,
-    positionIndexes: [...positionIndexes],
-    positionIndexToItem: Object.assign({}, positionIndexToItem),
-    indexToItem,
-    realSize: state.realSize + newTotal,
-    sizes,
-  };
-}
-export function getItemByPosition({ indexes, positionIndexes, originItemSize, positionIndexToItem }, pos) {
-  const item = {
-    itemIndex: 0,
-    start: 0,
-    end: 0,
-  };
-  const currentPlace = indexes.length ? sortedIndex(positionIndexes, pos) : 0;
-  // not found or first index
-  if (!currentPlace) {
-    item.itemIndex = Math.floor(pos / originItemSize);
-    item.start = item.itemIndex * originItemSize;
-    item.end = item.start + originItemSize;
-    return item;
-  }
-  const positionItem = positionIndexToItem[currentPlace - 1];
-  // if item has specified size
-  if (positionItem.end > pos) {
-    return positionItem;
-  }
-  // special size item was present before
-  const relativePos = pos - positionItem.end;
-  const relativeIndex = Math.floor(relativePos / originItemSize);
-  item.itemIndex = positionItem.itemIndex + 1 + relativeIndex;
-  item.start = positionItem.end + relativeIndex * originItemSize;
-  item.end = item.start + originItemSize;
-  return item;
-}
-export function getItemByIndex(dimension, index) {
-  let item = {
-    itemIndex: index,
-    start: 0,
-    end: 0,
-  };
-  // if item has specified size
-  if (dimension.indexToItem[index]) {
-    return dimension.indexToItem[index];
-  }
-  const currentPlace = dimension.indexes.length ? sortedIndex(dimension.indexes, index) : 0;
-  // not found or first index
-  if (!currentPlace) {
-    item.start = item.itemIndex * dimension.originItemSize;
-    item.end = item.start + dimension.originItemSize;
-    return item;
-  }
-  // special size item was present before
-  const positionItem = dimension.indexToItem[dimension.indexes[currentPlace - 1]];
-  item.start = positionItem.end + (index - positionItem.itemIndex - 1) * dimension.originItemSize;
-  item.end = item.start + dimension.originItemSize;
-  return item;
-}

package/dist/collection/store/dimension/dimension.store.js

@@ -1,59 +0,0 @@
-/**
- * Storing pre-calculated
- * Dimension information and sizes
- */
-import { createStore } from '@stencil/store';
-import reduce from 'lodash/reduce';
-import { setStore } from '../../utils/store.utils';
-import { calculateDimensionData } from './dimension.helpers';
-function initialBase() {
-  return {
-    indexes: [],
-    // item index to size
-    sizes: {},
-    // order in indexes[] to coordinate
-    positionIndexToItem: {},
-    // initial element to coordinate ^
-    indexToItem: {},
-    positionIndexes: []
-  };
-}
-function initialState() {
-  return Object.assign(Object.assign({}, initialBase()), { 
-    // size which all items can take
-    realSize: 0, 
-    // initial item size if it wasn't changed
-    originItemSize: 0, frameOffset: 0 });
-}
-export default class DimensionStore {
-  constructor() {
-    this.store = createStore(initialState());
-  }
-  getCurrentState() {
-    const state = initialState();
-    const keys = Object.keys(state);
-    return reduce(keys, (r, k) => {
-      const data = this.store.get(k);
-      r[k] = data;
-      return r;
-    }, state);
-  }
-  setRealSize(count) {
-    let realSize = 0;
-    for (let i = 0; i < count; i++) {
-      realSize += this.store.get('sizes')[i] || this.store.get('originItemSize');
-    }
-    setStore(this.store, { realSize });
-  }
-  setStore(data) {
-    setStore(this.store, data);
-  }
-  drop() {
-    setStore(this.store, initialBase());
-  }
-  setDimensionSize(sizes) {
-    const dimensionData = calculateDimensionData(this.getCurrentState(), sizes);
-    setStore(this.store, dimensionData);
-    return dimensionData;
-  }
-}

package/dist/collection/store/selection/selection.helpers.js

@@ -1,53 +0,0 @@
-import { EMPTY_INDEX } from '../../services/selection.store.connector';
-export function isHiddenStore(pos) {
-  return pos === EMPTY_INDEX;
-}
-export 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;
-}
-export 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;
-}
-export 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;
-}
-export function isRangeSingleCell(a) {
-  return a.x === a.x1 && a.y === a.y1;
-}

package/dist/collection/store/selection/selection.store.js

@@ -1,68 +0,0 @@
-import { createStore } from '@stencil/store';
-import { setStore } from '../../utils/store.utils';
-import { getRange } from './selection.helpers';
-function defaultState() {
-  return {
-    range: null,
-    tempRange: null,
-    tempRangeType: null,
-    focus: null,
-    edit: null,
-    lastCell: null,
-  };
-}
-export 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();
-  }
-}