@revolist/revogrid 3.2.4 → 3.2.7

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

@@ -0,0 +1,110 @@
+/*!
+ * Built by Revolist
+ */
+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

@@ -0,0 +1,62 @@
+/*!
+ * Built by Revolist
+ */
+/**
+ * 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

@@ -0,0 +1,56 @@
+/*!
+ * Built by Revolist
+ */
+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

@@ -0,0 +1,71 @@
+/*!
+ * Built by Revolist
+ */
+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();
+  }
+}

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

@@ -0,0 +1,38 @@
+/*!
+ * Built by Revolist
+ */
+import { getRange } from './selection.helpers';
+export default class SelectionStoreService {
+  constructor(store, config) {
+    this.store = store;
+    this.config = config;
+    this.store = store;
+  }
+  get edited() {
+    return this.store.get('edit');
+  }
+  get focused() {
+    return this.store.get('focus');
+  }
+  get ranged() {
+    return this.store.get('range');
+  }
+  changeRange(range) {
+    return this.config.changeRange(range);
+  }
+  focus(cell, isMulti = false) {
+    if (!cell) {
+      return false;
+    }
+    let end = cell;
+    // range edit
+    if (isMulti) {
+      let start = this.store.get('focus');
+      if (start) {
+        return this.config.changeRange(getRange(start, end));
+      }
+    }
+    // single focus
+    return this.config.focus(cell, end);
+  }
+}

package/dist/collection/store/storeTypes.js

@@ -0,0 +1,8 @@
+/*!
+ * Built by Revolist
+ */
+export const rowTypes = ['rowPinStart', 'rgRow', 'rowPinEnd'];
+export const columnTypes = ['colPinStart', 'rgCol', 'colPinEnd'];
+export function isRowType(type) {
+  return rowTypes.indexOf(type) > -1;
+}

package/dist/{revo-grid/viewport.store-ffaaab6d.js → collection/store/viewPort/viewport.helpers.js}

@@ -1,15 +1,13 @@
 /*!
  * Built by Revolist
  */
-import { c as createStore, d as setStore } from './data.store-3263fff9.js';
-import { a as getItemByPosition } from './dimension.helpers-a7944fc4.js';
-
+import { getItemByPosition } from '../dimension/dimension.helpers';
 /**
  * Update items based on new scroll position
  * If viewport wasn't changed fully simple recombination of positions
  * Otherwise rebuild viewport items
  */
-function getUpdatedItemsByPosition(pos, items, realCount, virtualSize, dimension) {
+export function getUpdatedItemsByPosition(pos, items, realCount, virtualSize, dimension) {
   const activeItem = getItemByPosition(dimension, pos);
   const firstItem = getFirstItem(items);
   let toUpdate;
@@ -50,7 +48,7 @@ function getUpdatedItemsByPosition(pos, items, realCount, virtualSize, dimension
   }
   return toUpdate;
 }
-function updateMissingAndRange(items, missing, range) {
+export function updateMissingAndRange(items, missing, range) {
   items.splice(range.end + 1, 0, ...missing);
   // update range if start larger after recombination
   if (range.start >= range.end && !(range.start === range.end && range.start === 0)) {
@@ -59,7 +57,7 @@ function updateMissingAndRange(items, missing, range) {
   range.end += missing.length;
 }
 // if partial replacement add items if revo-viewport has some space left
-function addMissingItems(firstItem, realCount, virtualSize, existingCollection, dimension) {
+export function addMissingItems(firstItem, realCount, virtualSize, existingCollection, dimension) {
   const lastItem = getLastItem(existingCollection);
   const items = getItems({
     sizes: dimension.sizes,
@@ -72,7 +70,7 @@ function addMissingItems(firstItem, realCount, virtualSize, existingCollection,
   return items;
 }
 // get revo-viewport items parameters, caching position and calculating items count in revo-viewport
-function getItems(opt, currentSize = 0) {
+export function getItems(opt, currentSize = 0) {
   const items = [];
   let index = opt.startIndex;
   let size = currentSize;
@@ -93,7 +91,7 @@ function getItems(opt, currentSize = 0) {
  * Do batch items recombination
  * If items not overlapped with existing viewport returns null
  */
-function recombineByOffset(offset, data) {
+export function recombineByOffset(offset, data) {
   const newItems = [...data.items];
   const itemsCount = newItems.length;
   let newRange = {
@@ -174,133 +172,12 @@ function getItemSize(index, sizes, origSize = 0) {
   }
   return origSize;
 }
-function isActiveRange(pos, item) {
+export function isActiveRange(pos, item) {
   return item && pos >= item.start && pos <= item.end;
 }
-function getFirstItem(s) {
+export function getFirstItem(s) {
   return s.items[s.start];
 }
-function getLastItem(s) {
+export function getLastItem(s) {
   return s.items[s.end];
 }
-
-/**
- * Store is responsible for visible
- * Viewport information for each dimension
- * Redraw items during scrolling
- */
-function initialState() {
-  return {
-    // virtual item information per rendered item
-    items: [],
-    // virtual dom item order to render
-    start: 0,
-    end: 0,
-    // size of viewport in px
-    virtualSize: 0,
-    // total number of items
-    realCount: 0,
-    // last coordinate for store position restore
-    lastCoordinate: 0,
-  };
-}
-class ViewportStore {
-  constructor() {
-    this.store = createStore(initialState());
-    this.store.onChange('realCount', () => this.clear());
-  }
-  /** Render viewport based on coordinate, this is main method for draw */
-  setViewPortCoordinate(position, dimension) {
-    let virtualSize = this.store.get('virtualSize');
-    // no visible data to calculate
-    if (!virtualSize) {
-      return;
-    }
-    const frameOffset = dimension.frameOffset;
-    const outsize = frameOffset * 2 * dimension.originItemSize;
-    virtualSize += outsize;
-    let maxCoordinate = virtualSize;
-    if (dimension.realSize > virtualSize) {
-      maxCoordinate = dimension.realSize - virtualSize;
-    }
-    let toUpdate = {
-      lastCoordinate: position,
-    };
-    let pos = position;
-    pos -= frameOffset * dimension.originItemSize;
-    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate;
-    const firstItem = getFirstItem(this.getItems());
-    const lastItem = getLastItem(this.getItems());
-    // left position changed
-    if (!isActiveRange(pos, firstItem)) {
-      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, this.getItems(), this.store.get('realCount'), virtualSize, dimension));
-      setStore(this.store, Object.assign({}, toUpdate));
-      // right position changed
-    }
-    else if (firstItem && this.store.get('virtualSize') + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end)) {
-      // check is any item missing for full fill content
-      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, this.getItems(), dimension);
-      if (missing.length) {
-        const items = [...this.store.get('items')];
-        const range = {
-          start: this.store.get('start'),
-          end: this.store.get('end'),
-        };
-        updateMissingAndRange(items, missing, range);
-        toUpdate = Object.assign(Object.assign(Object.assign({}, toUpdate), { items: [...items] }), range);
-        setStore(this.store, Object.assign({}, toUpdate));
-      }
-    }
-  }
-  /** Update viewport sizes */
-  setViewPortDimension(sizes) {
-    const items = this.store.get('items');
-    const count = items.length;
-    // viewport not inited
-    if (!count) {
-      return;
-    }
-    let changedCoordinate = 0;
-    let i = 0;
-    let start = this.store.get('start');
-    // loop through array from initial item after recombination
-    while (i < count) {
-      const item = items[start];
-      // change pos if size change present before
-      if (changedCoordinate) {
-        item.start += changedCoordinate;
-        item.end += changedCoordinate;
-      }
-      // change size
-      const size = sizes[item.itemIndex];
-      if (size) {
-        const changedSize = size - item.size;
-        changedCoordinate += changedSize;
-        item.size = size;
-        item.end = item.start + size;
-      }
-      // loop by start index
-      start++;
-      i++;
-      if (start === count) {
-        start = 0;
-      }
-    }
-    setStore(this.store, { items: [...items] });
-  }
-  getItems() {
-    return {
-      items: this.store.get('items'),
-      start: this.store.get('start'),
-      end: this.store.get('end'),
-    };
-  }
-  setViewport(data) {
-    setStore(this.store, data);
-  }
-  clear() {
-    this.store.set('items', []);
-  }
-}
-
-export { ViewportStore as V };

package/dist/collection/store/viewPort/viewport.store.js

@@ -0,0 +1,124 @@
+/*!
+ * Built by Revolist
+ */
+/**
+ * Store is responsible for visible
+ * Viewport information for each dimension
+ * Redraw items during scrolling
+ */
+import { createStore } from '@stencil/store';
+import { addMissingItems, getFirstItem, getLastItem, getUpdatedItemsByPosition, isActiveRange, updateMissingAndRange } from './viewport.helpers';
+import { setStore } from '../../utils/store.utils';
+function initialState() {
+  return {
+    // virtual item information per rendered item
+    items: [],
+    // virtual dom item order to render
+    start: 0,
+    end: 0,
+    // size of viewport in px
+    virtualSize: 0,
+    // total number of items
+    realCount: 0,
+    // last coordinate for store position restore
+    lastCoordinate: 0,
+  };
+}
+export default class ViewportStore {
+  constructor() {
+    this.store = createStore(initialState());
+    this.store.onChange('realCount', () => this.clear());
+  }
+  /** Render viewport based on coordinate, this is main method for draw */
+  setViewPortCoordinate(position, dimension) {
+    let virtualSize = this.store.get('virtualSize');
+    // no visible data to calculate
+    if (!virtualSize) {
+      return;
+    }
+    const frameOffset = dimension.frameOffset;
+    const outsize = frameOffset * 2 * dimension.originItemSize;
+    virtualSize += outsize;
+    let maxCoordinate = virtualSize;
+    if (dimension.realSize > virtualSize) {
+      maxCoordinate = dimension.realSize - virtualSize;
+    }
+    let toUpdate = {
+      lastCoordinate: position,
+    };
+    let pos = position;
+    pos -= frameOffset * dimension.originItemSize;
+    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate;
+    const firstItem = getFirstItem(this.getItems());
+    const lastItem = getLastItem(this.getItems());
+    // left position changed
+    if (!isActiveRange(pos, firstItem)) {
+      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, this.getItems(), this.store.get('realCount'), virtualSize, dimension));
+      setStore(this.store, Object.assign({}, toUpdate));
+      // right position changed
+    }
+    else if (firstItem && this.store.get('virtualSize') + pos > (lastItem === null || lastItem === void 0 ? void 0 : lastItem.end)) {
+      // check is any item missing for full fill content
+      const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, this.getItems(), dimension);
+      if (missing.length) {
+        const items = [...this.store.get('items')];
+        const range = {
+          start: this.store.get('start'),
+          end: this.store.get('end'),
+        };
+        updateMissingAndRange(items, missing, range);
+        toUpdate = Object.assign(Object.assign(Object.assign({}, toUpdate), { items: [...items] }), range);
+        setStore(this.store, Object.assign({}, toUpdate));
+      }
+    }
+  }
+  /** Update viewport sizes */
+  setViewPortDimension(sizes) {
+    const items = this.store.get('items');
+    const count = items.length;
+    // viewport not inited
+    if (!count) {
+      return;
+    }
+    let changedCoordinate = 0;
+    let i = 0;
+    let start = this.store.get('start');
+    // loop through array from initial item after recombination
+    while (i < count) {
+      const item = items[start];
+      // change pos if size change present before
+      if (changedCoordinate) {
+        item.start += changedCoordinate;
+        item.end += changedCoordinate;
+      }
+      // change size
+      const size = sizes[item.itemIndex];
+      if (size) {
+        const changedSize = size - item.size;
+        changedCoordinate += changedSize;
+        item.size = size;
+        item.end = item.start + size;
+      }
+      // loop by start index
+      start++;
+      i++;
+      if (start === count) {
+        start = 0;
+      }
+    }
+    setStore(this.store, { items: [...items] });
+  }
+  getItems() {
+    return {
+      items: this.store.get('items'),
+      start: this.store.get('start'),
+      end: this.store.get('end'),
+    };
+  }
+  setViewport(data) {
+    setStore(this.store, data);
+  }
+  clear() {
+    this.store.set('items', []);
+  }
+}

package/dist/collection/themeManager/theme.compact.js

@@ -0,0 +1,8 @@
+/*!
+ * Built by Revolist
+ */
+export default class ThemeCompact {
+  constructor() {
+    this.defaultRowSize = 32;
+  }
+}

package/dist/collection/themeManager/theme.default.js

@@ -0,0 +1,8 @@
+/*!
+ * Built by Revolist
+ */
+export default class ThemeDefault {
+  constructor() {
+    this.defaultRowSize = 27;
+  }
+}

package/dist/collection/themeManager/theme.material.js

@@ -0,0 +1,8 @@
+/*!
+ * Built by Revolist
+ */
+export default class ThemeMaterial {
+  constructor() {
+    this.defaultRowSize = 42;
+  }
+}