@dlh.io/bideux 0.1.0

package/dist/element/chunk-H5IFOSQP.js

@@ -0,0 +1,346 @@
+import { createStore, setStore, getItemByPosition } from './chunk-AOKCBPMV.js';
+
+// ../../node_modules/.pnpm/@revolist+revogrid@4.25.2/node_modules/@revolist/revogrid/dist/esm/viewport.store-BSXmsiZc.js
+var LETTER_BLOCK_SIZE = 10;
+var calculateRowHeaderSize = (itemsLength, rowHeaderColumn, minWidth = 50) => {
+  return (rowHeaderColumn === null || rowHeaderColumn === void 0 ? void 0 : rowHeaderColumn.size) || Math.max((itemsLength.toString().length + 1) * LETTER_BLOCK_SIZE, minWidth);
+};
+function getViewportMaxCoordinate(dimension, viewportSize, frameOffset = 1) {
+  if (!viewportSize || dimension.realSize <= viewportSize) {
+    return 0;
+  }
+  return Math.max(0, dimension.realSize - viewportSize - dimension.originItemSize * frameOffset);
+}
+function clampViewportCoordinate(coordinate, dimension, viewportSize, frameOffset = 1) {
+  return Math.min(Math.max(0, coordinate), getViewportMaxCoordinate(dimension, viewportSize, frameOffset));
+}
+function getUpdatedItemsByPosition(pos, items, realCount, virtualSize, dimension) {
+  const activeItem = getItemByPosition(dimension, pos);
+  const firstItem = getFirstItem(items);
+  let toUpdate;
+  if (firstItem) {
+    let changedOffsetStart = activeItem.itemIndex - (firstItem.itemIndex || 0);
+    if (changedOffsetStart) {
+      toUpdate = recombineByOffset(Math.abs(changedOffsetStart), Object.assign(Object.assign({ positiveDirection: changedOffsetStart > -1 }, dimension), items));
+    }
+  }
+  const maxSizeVirtualSize = getMaxVirtualSize(virtualSize, dimension.realSize, activeItem);
+  if (toUpdate) {
+    const extra = addMissingItems(activeItem, realCount, maxSizeVirtualSize, toUpdate, dimension);
+    if (extra.length) {
+      updateMissingAndRange(toUpdate.items, extra, toUpdate);
+    }
+  }
+  if (!toUpdate) {
+    const items2 = getItems({
+      firstItemStart: activeItem.start,
+      firstItemIndex: activeItem.itemIndex,
+      origSize: dimension.originItemSize,
+      maxSize: maxSizeVirtualSize,
+      maxCount: realCount,
+      sizes: dimension.sizes
+    });
+    toUpdate = {
+      items: items2,
+      start: 0,
+      end: items2.length - 1
+    };
+  }
+  return toUpdate;
+}
+function getMaxVirtualSize(virtualSize, realSize, activeItem) {
+  return Math.min(virtualSize + (activeItem.end - activeItem.start), realSize);
+}
+function updateMissingAndRange(items, missing, range) {
+  items.splice(range.end + 1, 0, ...missing);
+  if (range.start >= range.end && !(range.start === range.end && range.start === 0)) {
+    range.start += missing.length;
+  }
+  range.end += missing.length;
+}
+function addMissingItems(firstItem, realCount, virtualSize, existingCollection, dimension) {
+  const lastItem = getLastItem(existingCollection);
+  const items = getItems({
+    sizes: dimension.sizes,
+    firstItemStart: lastItem.end,
+    firstItemIndex: lastItem.itemIndex + 1,
+    origSize: dimension.originItemSize,
+    maxSize: virtualSize - (lastItem.end - firstItem.start),
+    maxCount: realCount
+  });
+  return items;
+}
+function getItems(opt, currentSize = 0) {
+  const items = [];
+  let index = opt.firstItemIndex;
+  let size = currentSize;
+  while (size <= opt.maxSize && index < opt.maxCount) {
+    const newSize = getItemSize(index, opt.sizes, opt.origSize);
+    items.push({
+      start: opt.firstItemStart + size,
+      end: opt.firstItemStart + size + newSize,
+      itemIndex: index,
+      size: newSize
+    });
+    size += newSize;
+    index++;
+  }
+  return items;
+}
+function recombineByOffset(offset, data) {
+  var _a, _b;
+  const newItems = [...data.items];
+  const itemsCount = newItems.length;
+  let newRange = {
+    start: data.start,
+    end: data.end
+  };
+  if (offset > itemsCount) {
+    return void 0;
+  }
+  if (data.positiveDirection) {
+    let lastItem = getLastItem(data);
+    let i = newRange.start;
+    const length = i + offset;
+    for (; i < length; i++) {
+      const newIndex = lastItem.itemIndex + 1;
+      const size = getItemSize(newIndex, data.sizes, data.originItemSize);
+      if (lastItem.end + size > data.realSize) {
+        break;
+      }
+      let newEnd = i % itemsCount;
+      if (!newItems[newEnd]) {
+        throw new Error("incorrect index");
+      }
+      newItems[newEnd] = lastItem = {
+        start: lastItem.end,
+        end: lastItem.end + size,
+        itemIndex: newIndex,
+        size
+      };
+      newRange.start++;
+      newRange.end = newEnd;
+    }
+  } else {
+    let firstItem = getFirstItem(data);
+    const end = newRange.end;
+    for (let i = 0; i < offset; i++) {
+      const newIndex = ((_a = firstItem === null || firstItem === void 0 ? void 0 : firstItem.itemIndex) !== null && _a !== void 0 ? _a : 0) - 1;
+      const size = getItemSize(newIndex, data.sizes, data.originItemSize);
+      let newStart = end - i;
+      newStart = (newStart < 0 ? itemsCount + newStart : newStart) % itemsCount;
+      if (!newItems[newStart]) {
+        console.error("incorrect index");
+        break;
+      }
+      const firstItemStart = (_b = firstItem === null || firstItem === void 0 ? void 0 : firstItem.start) !== null && _b !== void 0 ? _b : 0;
+      newItems[newStart] = firstItem = {
+        start: firstItemStart - size,
+        end: firstItemStart,
+        itemIndex: newIndex,
+        size
+      };
+      newRange.start = newStart;
+      newRange.end--;
+    }
+  }
+  const range = {
+    start: (newRange.start < 0 ? itemsCount + newRange.start : newRange.start) % itemsCount,
+    end: (newRange.end < 0 ? itemsCount + newRange.end : newRange.end) % itemsCount
+  };
+  return Object.assign({ items: newItems }, range);
+}
+function getItemSize(index, sizes, origSize = 0) {
+  if (typeof (sizes === null || sizes === void 0 ? void 0 : sizes[index]) === "number") {
+    return sizes[index];
+  }
+  return origSize;
+}
+function isActiveRange(pos, realSize, first, last) {
+  if (!first || !last) {
+    return false;
+  }
+  return pos >= first.start && pos <= first.end || pos > first.end && last.end === realSize;
+}
+function isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem) {
+  var _a;
+  if (!firstItem) {
+    return false;
+  }
+  return virtualSize + pos > ((_a = lastItem === null || lastItem === void 0 ? void 0 : lastItem.end) !== null && _a !== void 0 ? _a : 0);
+}
+function getFirstItem(s) {
+  return s.items[s.start];
+}
+function getLastItem(s) {
+  return s.items[s.end];
+}
+function setItemSizes(vpItems, initialIndex, size, lastCoordinate) {
+  const items = [...vpItems];
+  const count = items.length;
+  let pos = lastCoordinate;
+  let i = 0;
+  let start = initialIndex;
+  if (!count) {
+    return [];
+  }
+  while (i < count) {
+    const item = items[start];
+    item.start = pos;
+    item.size = size;
+    item.end = item.start + size;
+    pos = item.end;
+    start++;
+    i++;
+    if (start === count) {
+      start = 0;
+    }
+  }
+  return items;
+}
+function initialState() {
+  return {
+    // virtual item information per rendered item
+    items: [],
+    // virtual dom item order to render
+    start: 0,
+    end: 0,
+    // size of virtual viewport in px
+    virtualSize: 0,
+    // total number of items
+    realCount: 0,
+    // size of viewport in px
+    clientSize: 0,
+    // logical-to-physical render offset used when scroll space is compressed
+    renderOffset: 0
+  };
+}
+var ViewportStore = class {
+  get lastCoordinate() {
+    return this.lastKnownScroll;
+  }
+  set lastCoordinate(value) {
+    this.lastKnownScroll = value;
+  }
+  constructor(type) {
+    this.type = type;
+    this.lastKnownScroll = 0;
+    this.store = createStore(initialState());
+  }
+  /**
+   * Render viewport based on coordinate
+   * It's the main method for draw
+   * Use force if you want to re-render viewport
+   */
+  setViewPortCoordinate(position, dimension, force = false) {
+    const viewportSize = this.store.get("virtualSize");
+    if (!viewportSize) {
+      return;
+    }
+    const frameOffset = 1;
+    const singleOffsetInPx = dimension.originItemSize * frameOffset;
+    const outsize = singleOffsetInPx * 2;
+    const virtualSize = viewportSize + outsize;
+    const maxCoordinate = getViewportMaxCoordinate(dimension, viewportSize, frameOffset);
+    let pos = clampViewportCoordinate(position, dimension, viewportSize, frameOffset);
+    this.lastCoordinate = pos;
+    pos -= singleOffsetInPx;
+    pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate;
+    let allItems;
+    if (force) {
+      allItems = {
+        items: [],
+        start: 0,
+        end: 0
+      };
+    } else {
+      allItems = this.getItems();
+    }
+    const firstItem = getFirstItem(allItems);
+    const lastItem = getLastItem(allItems);
+    let toUpdate = {};
+    if (!isActiveRange(pos, dimension.realSize, firstItem, lastItem)) {
+      toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, allItems, this.store.get("realCount"), virtualSize, dimension));
+      this.setViewport(Object.assign({}, toUpdate));
+    } else if (isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem)) {
+      const items = [...allItems.items];
+      const missing = addMissingItems(firstItem, this.store.get("realCount"), virtualSize + pos - firstItem.start, allItems, {
+        sizes: dimension.sizes,
+        originItemSize: dimension.originItemSize
+      });
+      if (missing.length) {
+        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);
+        this.setViewport(Object.assign({}, toUpdate));
+      }
+    }
+  }
+  /**
+   * Set sizes for existing items
+   */
+  setOriginalSizes(size) {
+    const items = this.store.get("items");
+    const count = items.length;
+    if (!count) {
+      return;
+    }
+    setStore(this.store, {
+      items: setItemSizes(items, this.store.get("start"), size, this.lastCoordinate)
+    });
+  }
+  getItems() {
+    return {
+      items: this.store.get("items"),
+      start: this.store.get("start"),
+      end: this.store.get("end")
+    };
+  }
+  setViewport(data) {
+    if (typeof data.realCount === "number" || typeof data.virtualSize === "number") {
+      data = Object.assign(Object.assign({}, data), { items: data.items || [] });
+    }
+    setStore(this.store, data);
+  }
+};
+
+// ../../node_modules/.pnpm/@revolist+revogrid@4.25.2/node_modules/@revolist/revogrid/dist/esm/events-BvSmBueA.js
+function isTouch(e) {
+  return !!e.touches;
+}
+function verifyTouchTarget(touchEvent, focusClass) {
+  if (focusClass && touchEvent) {
+    if (!(touchEvent.target instanceof Element && touchEvent.target.classList.contains(focusClass))) {
+      return false;
+    }
+  }
+  return true;
+}
+function getPropertyFromEvent(e, prop, focusClass) {
+  if (isTouch(e)) {
+    if (e.touches.length > 0) {
+      const touchEvent = e.touches[0];
+      if (!verifyTouchTarget(touchEvent, focusClass)) {
+        return null;
+      }
+      return touchEvent[prop] || 0;
+    }
+    return null;
+  }
+  return e[prop] || 0;
+}
+/*! Bundled license information:
+
+@revolist/revogrid/dist/esm/viewport.store-BSXmsiZc.js:
+@revolist/revogrid/dist/esm/events-BvSmBueA.js:
+  (*!
+   * Built by Revolist OU ❤️
+   *)
+*/
+
+export { ViewportStore, calculateRowHeaderSize, getPropertyFromEvent, verifyTouchTarget };
+//# sourceMappingURL=chunk-H5IFOSQP.js.map
+//# sourceMappingURL=chunk-H5IFOSQP.js.map

package/dist/element/chunk-H5IFOSQP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../node_modules/.pnpm/@revolist+revogrid@4.25.2/node_modules/@revolist/revogrid/dist/esm/viewport.store-BSXmsiZc.js","../../../../node_modules/.pnpm/@revolist+revogrid@4.25.2/node_modules/@revolist/revogrid/dist/esm/events-BvSmBueA.js"],"names":["items"],"mappings":"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","file":"chunk-H5IFOSQP.js","sourcesContent":["/*!\n * Built by Revolist OU ❤️\n */\nimport { j as getItemByPosition, K as createStore, l as setStore } from './dimension.helpers-fl4HSSK9.js';\n\nconst LETTER_BLOCK_SIZE = 10;\nconst calculateRowHeaderSize = (itemsLength, rowHeaderColumn, minWidth = 50) => {\n    return ((rowHeaderColumn === null || rowHeaderColumn === void 0 ? void 0 : rowHeaderColumn.size) ||\n        Math.max((itemsLength.toString().length + 1) * LETTER_BLOCK_SIZE, minWidth));\n};\n\nfunction getViewportMaxCoordinate(dimension, viewportSize, frameOffset = 1) {\n    if (!viewportSize || dimension.realSize <= viewportSize) {\n        return 0;\n    }\n    return Math.max(0, dimension.realSize - viewportSize - dimension.originItemSize * frameOffset);\n}\n/**\n * Clamp the viewport coordinate within the valid range.\n * Given a scroll position, pick a safe starting point for rendering visible items.\n *\n * Do not use it when you need the exact scroll position for positioning math.\n *\n * It does two things:\n * 1. If the coordinate is below 0, use 0.\n * 2. If the coordinate is too close to the very end, pull it back a bit.\n *\n * Example:\n *\n * content height: 1000px\n * viewport height: 200px\n * row height: 30px\n * The real max scroll is:\n *\n * 1000 - 200 = 800\n * But clampViewportCoordinate may clamp to:\n *\n * 1000 - 200 - 30 = 770\n * Ask for 800 -> it returns 770.\n */\nfunction clampViewportCoordinate(coordinate, dimension, viewportSize, frameOffset = 1) {\n    return Math.min(Math.max(0, coordinate), getViewportMaxCoordinate(dimension, viewportSize, frameOffset));\n}\n/**\n * Update items based on new scroll position\n * If viewport wasn't changed fully simple recombination of positions\n * Otherwise rebuild viewport items\n */\nfunction getUpdatedItemsByPosition(pos, // coordinate\nitems, realCount, virtualSize, dimension) {\n    const activeItem = getItemByPosition(dimension, pos);\n    const firstItem = getFirstItem(items);\n    let toUpdate;\n    // do simple position recombination if items already present in viewport\n    if (firstItem) {\n        let changedOffsetStart = activeItem.itemIndex - (firstItem.itemIndex || 0);\n        // if item changed\n        if (changedOffsetStart) {\n            // simple recombination\n            toUpdate = recombineByOffset(Math.abs(changedOffsetStart), Object.assign(Object.assign({ positiveDirection: changedOffsetStart > -1 }, dimension), items));\n        }\n    }\n    const maxSizeVirtualSize = getMaxVirtualSize(virtualSize, dimension.realSize, activeItem);\n    // if partial recombination add items if revo-viewport has some space left\n    if (toUpdate) {\n        const extra = addMissingItems(activeItem, realCount, maxSizeVirtualSize, toUpdate, dimension);\n        if (extra.length) {\n            updateMissingAndRange(toUpdate.items, extra, toUpdate);\n        }\n    }\n    // new collection if no items after replacement full replacement\n    if (!toUpdate) {\n        const items = getItems({\n            firstItemStart: activeItem.start,\n            firstItemIndex: activeItem.itemIndex,\n            origSize: dimension.originItemSize,\n            maxSize: maxSizeVirtualSize,\n            maxCount: realCount,\n            sizes: dimension.sizes,\n        });\n        // range now comes from 0 to length - 1\n        toUpdate = {\n            items,\n            start: 0,\n            end: items.length - 1,\n        };\n    }\n    return toUpdate;\n}\n// virtual size can differ based on scroll position if some big items are present\n// scroll can be in the middle of item and virtual size will be larger\n// so we need to exclude this part from virtual size hence it's already passed\nfunction getMaxVirtualSize(virtualSize, realSize, activeItem) {\n    return Math.min(virtualSize + (activeItem.end - activeItem.start), realSize);\n}\nfunction updateMissingAndRange(items, missing, range) {\n    items.splice(range.end + 1, 0, ...missing);\n    // update range if start larger after recombination\n    if (range.start >= range.end &&\n        !(range.start === range.end && range.start === 0)) {\n        range.start += missing.length;\n    }\n    range.end += missing.length;\n}\n/**\n * If partial replacement\n * this function adds items if viewport has some space left\n */\nfunction addMissingItems(firstItem, realCount, virtualSize, existingCollection, dimension) {\n    const lastItem = getLastItem(existingCollection);\n    const items = getItems({\n        sizes: dimension.sizes,\n        firstItemStart: lastItem.end,\n        firstItemIndex: lastItem.itemIndex + 1,\n        origSize: dimension.originItemSize,\n        maxSize: virtualSize - (lastItem.end - firstItem.start),\n        maxCount: realCount,\n    });\n    return items;\n}\n/**\n * Get wiewport items parameters\n * caching position and calculating items count in viewport\n */\nfunction getItems(opt, currentSize = 0) {\n    const items = [];\n    let index = opt.firstItemIndex;\n    let size = currentSize;\n    // max size or max count\n    while (size <= opt.maxSize && index < opt.maxCount) {\n        const newSize = getItemSize(index, opt.sizes, opt.origSize);\n        items.push({\n            start: opt.firstItemStart + size,\n            end: opt.firstItemStart + size + newSize,\n            itemIndex: index,\n            size: newSize,\n        });\n        size += newSize;\n        index++;\n    }\n    return items;\n}\nfunction recombineByOffset(offset, data) {\n    var _a, _b;\n    const newItems = [...data.items];\n    const itemsCount = newItems.length;\n    let newRange = {\n        start: data.start,\n        end: data.end,\n    };\n    // if offset out of revo-viewport, makes sense whole redraw\n    if (offset > itemsCount) {\n        return undefined;\n    }\n    // is direction of scroll positive\n    if (data.positiveDirection) {\n        // push item to the end\n        let lastItem = getLastItem(data);\n        let i = newRange.start;\n        const length = i + offset;\n        for (; i < length; i++) {\n            const newIndex = lastItem.itemIndex + 1;\n            const size = getItemSize(newIndex, data.sizes, data.originItemSize);\n            // if item overlapped limit break a loop\n            if (lastItem.end + size > data.realSize) {\n                break;\n            }\n            // new item index to recombine\n            let newEnd = i % itemsCount;\n            // item should always present, we do not create new item, we recombine them\n            if (!newItems[newEnd]) {\n                throw new Error('incorrect index');\n            }\n            // do recombination\n            newItems[newEnd] = lastItem = {\n                start: lastItem.end,\n                end: lastItem.end + size,\n                itemIndex: newIndex,\n                size: size,\n            };\n            // update range\n            newRange.start++;\n            newRange.end = newEnd;\n        }\n        // direction is negative\n    }\n    else {\n        // push item to the start\n        let firstItem = getFirstItem(data);\n        const end = newRange.end;\n        for (let i = 0; i < offset; i++) {\n            const newIndex = ((_a = firstItem === null || firstItem === void 0 ? void 0 : firstItem.itemIndex) !== null && _a !== void 0 ? _a : 0) - 1;\n            const size = getItemSize(newIndex, data.sizes, data.originItemSize);\n            // new item index to recombine\n            let newStart = end - i;\n            newStart = (newStart < 0 ? itemsCount + newStart : newStart) % itemsCount;\n            // item should always present, we do not create new item, we recombine them\n            if (!newItems[newStart]) {\n                console.error('incorrect index');\n                break;\n            }\n            // do recombination\n            const firstItemStart = (_b = firstItem === null || firstItem === void 0 ? void 0 : firstItem.start) !== null && _b !== void 0 ? _b : 0;\n            newItems[newStart] = firstItem = {\n                start: firstItemStart - size,\n                end: firstItemStart,\n                itemIndex: newIndex,\n                size: size,\n            };\n            // update range\n            newRange.start = newStart;\n            newRange.end--;\n        }\n    }\n    const range = {\n        start: (newRange.start < 0 ? itemsCount + newRange.start : newRange.start) %\n            itemsCount,\n        end: (newRange.end < 0 ? itemsCount + newRange.end : newRange.end) %\n            itemsCount,\n    };\n    return Object.assign({ items: newItems }, range);\n}\nfunction getItemSize(index, sizes, origSize = 0) {\n    if (typeof (sizes === null || sizes === void 0 ? void 0 : sizes[index]) === 'number') {\n        return sizes[index];\n    }\n    return origSize;\n}\n/**\n * Verify if position is in range of the PositionItem, start and end are included\n */\nfunction isActiveRange(pos, realSize, first, last) {\n    if (!first || !last) {\n        return false;\n    }\n    // if position is in range of first item\n    // or position is after first item and last item is the last item in real size\n    return ((pos >= first.start && pos <= first.end) ||\n        (pos > first.end && last.end === realSize));\n}\nfunction isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem) {\n    var _a;\n    // if no first item, means no items in viewport\n    if (!firstItem) {\n        return false;\n    }\n    return virtualSize + pos > ((_a = lastItem === null || lastItem === void 0 ? void 0 : lastItem.end) !== null && _a !== void 0 ? _a : 0);\n}\nfunction getFirstItem(s) {\n    return s.items[s.start];\n}\nfunction getLastItem(s) {\n    return s.items[s.end];\n}\n/**\n * Set items sizes from start index to end\n * @param vpItems\n * @param start\n * @param size\n * @param lastCoordinate\n * @returns\n */\nfunction setItemSizes(vpItems, initialIndex, size, lastCoordinate) {\n    const items = [...vpItems];\n    const count = items.length;\n    let pos = lastCoordinate;\n    let i = 0;\n    let start = initialIndex;\n    // viewport not inited\n    if (!count) {\n        return [];\n    }\n    // loop through array from initial item after recombination\n    while (i < count) {\n        const item = items[start];\n        item.start = pos;\n        item.size = size;\n        item.end = item.start + size;\n        pos = item.end;\n        // loop by start index\n        start++;\n        i++;\n        // if start index out of array, reset it\n        if (start === count) {\n            start = 0;\n        }\n    }\n    return items;\n}\n\n/**\n * Viewport store\n * Used for virtualization (process of rendering only visible part of data)\n * Redraws viewport based on position and dimension\n */\nfunction initialState() {\n    return {\n        // virtual item information per rendered item\n        items: [],\n        // virtual dom item order to render\n        start: 0,\n        end: 0,\n        // size of virtual viewport in px\n        virtualSize: 0,\n        // total number of items\n        realCount: 0,\n        // size of viewport in px\n        clientSize: 0,\n        // logical-to-physical render offset used when scroll space is compressed\n        renderOffset: 0,\n    };\n}\n/**\n * Viewport store class\n */\nclass ViewportStore {\n    get lastCoordinate() {\n        return this.lastKnownScroll;\n    }\n    set lastCoordinate(value) {\n        this.lastKnownScroll = value;\n    }\n    constructor(type) {\n        this.type = type;\n        // last coordinate for store position restore\n        this.lastKnownScroll = 0;\n        this.store = createStore(initialState());\n    }\n    /**\n     * Render viewport based on coordinate\n     * It's the main method for draw\n     * Use force if you want to re-render viewport\n     */\n    setViewPortCoordinate(position, dimension, force = false) {\n        const viewportSize = this.store.get('virtualSize');\n        // no visible data to calculate\n        if (!viewportSize) {\n            return;\n        }\n        const frameOffset = 1;\n        const singleOffsetInPx = dimension.originItemSize * frameOffset;\n        // add offset to virtual size from both sides\n        const outsize = singleOffsetInPx * 2;\n        // math virtual size is based on visible area + 2 items outside of visible area\n        const virtualSize = viewportSize + outsize;\n        const maxCoordinate = getViewportMaxCoordinate(dimension, viewportSize, frameOffset);\n        let pos = clampViewportCoordinate(position, dimension, viewportSize, frameOffset);\n        // store last coordinate for further restore on redraw\n        this.lastCoordinate = pos;\n        // actual position is less than first item start based on offset\n        pos -= singleOffsetInPx;\n        pos = pos < 0 ? 0 : pos < maxCoordinate ? pos : maxCoordinate;\n        let allItems;\n        // if force clear all items and start from 0\n        if (force) {\n            allItems = {\n                items: [],\n                start: 0,\n                end: 0,\n            };\n        }\n        else {\n            allItems = this.getItems();\n        }\n        const firstItem = getFirstItem(allItems);\n        const lastItem = getLastItem(allItems);\n        let toUpdate = {};\n        // left position changed\n        // verify if new position is in range of previously rendered first item\n        if (!isActiveRange(pos, dimension.realSize, firstItem, lastItem)) {\n            toUpdate = Object.assign(Object.assign({}, toUpdate), getUpdatedItemsByPosition(pos, allItems, this.store.get('realCount'), virtualSize, dimension));\n            this.setViewport(Object.assign({}, toUpdate));\n            // verify is render area is outside of last item\n        }\n        else if (isActiveRangeOutsideLastItem(pos, virtualSize, firstItem, lastItem)) {\n            const items = [...allItems.items];\n            // check is any item missing for fulfill content\n            const missing = addMissingItems(firstItem, this.store.get('realCount'), virtualSize + pos - firstItem.start, allItems, {\n                sizes: dimension.sizes,\n                originItemSize: dimension.originItemSize,\n            });\n            // update missing items\n            if (missing.length) {\n                const range = {\n                    start: this.store.get('start'),\n                    end: this.store.get('end'),\n                };\n                updateMissingAndRange(items, missing, range);\n                toUpdate = Object.assign(Object.assign(Object.assign({}, toUpdate), { items: [...items] }), range);\n                this.setViewport(Object.assign({}, toUpdate));\n            }\n        }\n    }\n    /**\n     * Set sizes for existing items\n     */\n    setOriginalSizes(size) {\n        const items = this.store.get('items');\n        const count = items.length;\n        // viewport not inited\n        if (!count) {\n            return;\n        }\n        setStore(this.store, {\n            items: setItemSizes(items, this.store.get('start'), size, this.lastCoordinate),\n        });\n    }\n    getItems() {\n        return {\n            items: this.store.get('items'),\n            start: this.store.get('start'),\n            end: this.store.get('end'),\n        };\n    }\n    setViewport(data) {\n        // drop items on virtual size change, require a new item set\n        // drop items on real size change, require a new item set\n        if (typeof data.realCount === 'number' || typeof data.virtualSize === 'number') {\n            data = Object.assign(Object.assign({}, data), { items: data.items || [] });\n        }\n        setStore(this.store, data);\n    }\n}\n\nexport { ViewportStore as V, getUpdatedItemsByPosition as a, addMissingItems as b, clampViewportCoordinate as c, getItems as d, isActiveRangeOutsideLastItem as e, getFirstItem as f, getViewportMaxCoordinate as g, getLastItem as h, isActiveRange as i, calculateRowHeaderSize as j, recombineByOffset as r, setItemSizes as s, updateMissingAndRange as u };\n","/*!\n * Built by Revolist OU ❤️\n */\nfunction isTouch(e) {\n    return !!e.touches;\n}\nfunction verifyTouchTarget(touchEvent, focusClass) {\n    if (focusClass && touchEvent) {\n        if (!(touchEvent.target instanceof Element && touchEvent.target.classList.contains(focusClass))) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Function to get the value of a specific property from a MouseEvent or TouchEvent object.\n */\nfunction getPropertyFromEvent(e, prop, focusClass // for touch events\n) {\n    // Check if the event is a touch event\n    if (isTouch(e)) {\n        // If the event has touches, get the first touch\n        if (e.touches.length > 0) {\n            const touchEvent = e.touches[0];\n            // Check if the target of the touch event is the specified element\n            if (!verifyTouchTarget(touchEvent, focusClass)) {\n                // If not, return null\n                return null;\n            }\n            // Get the value of the specified property from the touch event and return it\n            return touchEvent[prop] || 0;\n        }\n        // If there are no touches, return null\n        return null;\n    }\n    // If the event is not a touch event, get the value of the specified property from the event and return it\n    return e[prop] || 0;\n}\n\nexport { getPropertyFromEvent as g, verifyTouchTarget as v };\n"]}

package/dist/element/chunk-LXR3CLCN.js

@@ -0,0 +1,30 @@
+// ../../node_modules/.pnpm/@revolist+revogrid@4.25.2/node_modules/@revolist/revogrid/dist/esm/index-D24ku9ej.js
+function getScrollbarSize(document) {
+  const container = document.createElement("div");
+  container.style.overflow = "scroll";
+  container.style.visibility = "hidden";
+  container.style.position = "absolute";
+  container.style.top = "-9999px";
+  container.style.width = "50px";
+  container.style.height = "50px";
+  document.body.appendChild(container);
+  const scrollbarWidth = container.offsetWidth - container.clientWidth;
+  document.body.removeChild(container);
+  return scrollbarWidth;
+}
+async function timeout(delay = 0) {
+  await new Promise((r) => {
+    setTimeout(() => r(), delay);
+  });
+}
+/*! Bundled license information:
+
+@revolist/revogrid/dist/esm/index-D24ku9ej.js:
+  (*!
+   * Built by Revolist OU ❤️
+   *)
+*/
+
+export { getScrollbarSize, timeout };
+//# sourceMappingURL=chunk-LXR3CLCN.js.map
+//# sourceMappingURL=chunk-LXR3CLCN.js.map

package/dist/element/chunk-LXR3CLCN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../node_modules/.pnpm/@revolist+revogrid@4.25.2/node_modules/@revolist/revogrid/dist/esm/index-D24ku9ej.js"],"names":[],"mappings":";AAyEA,SAAS,iBAAiB,QAAA,EAAU;AAEhC,EAAA,MAAM,SAAA,GAAY,QAAA,CAAS,aAAA,CAAc,KAAK,CAAA;AAE9C,EAAA,SAAA,CAAU,MAAM,QAAA,GAAW,QAAA;AAC3B,EAAA,SAAA,CAAU,MAAM,UAAA,GAAa,QAAA;AAC7B,EAAA,SAAA,CAAU,MAAM,QAAA,GAAW,UAAA;AAC3B,EAAA,SAAA,CAAU,MAAM,GAAA,GAAM,SAAA;AACtB,EAAA,SAAA,CAAU,MAAM,KAAA,GAAQ,MAAA;AACxB,EAAA,SAAA,CAAU,MAAM,MAAA,GAAS,MAAA;AAEzB,EAAA,QAAA,CAAS,IAAA,CAAK,YAAY,SAAS,CAAA;AAEnC,EAAA,MAAM,cAAA,GAAiB,SAAA,CAAU,WAAA,GAAc,SAAA,CAAU,WAAA;AAEzD,EAAA,QAAA,CAAS,IAAA,CAAK,YAAY,SAAS,CAAA;AAEnC,EAAA,OAAO,cAAA;AACX;AAmBA,eAAe,OAAA,CAAQ,QAAQ,CAAA,EAAG;AAC9B,EAAA,MAAM,IAAI,OAAA,CAAQ,CAAC,CAAA,KAAM;AACrB,IAAA,UAAA,CAAW,MAAM,CAAA,EAAE,EAAG,KAAK,CAAA;AAAA,EAC/B,CAAC,CAAA;AACL","file":"chunk-LXR3CLCN.js","sourcesContent":["/*!\n * Built by Revolist OU ❤️\n */\nimport './dimension.helpers-fl4HSSK9.js';\n\n/* Generate range on size\n */\nfunction range(size, startAt = 0) {\n    const res = [];\n    const end = startAt + size;\n    for (let i = startAt; i < end; i++) {\n        res.push(i);\n    }\n    return res;\n}\n/* Find index position in array */\nfunction findPositionInArray(el, compareFn) {\n    return (function (arr) {\n        let m = 0;\n        let n = arr.length - 1;\n        while (m <= n) {\n            const k = (n + m) >> 1;\n            const cmp = compareFn(el, arr[k]);\n            if (cmp > 0) {\n                m = k + 1;\n            }\n            else if (cmp < 0) {\n                n = k - 1;\n            }\n            else {\n                return k;\n            }\n        }\n        return -m - 1;\n    })(this);\n}\n/**\n * Sorted push\n */\nfunction pushSorted(arr, el, fn) {\n    arr.splice(findPositionInArray.bind(arr)(el, fn), 0, el);\n    return arr;\n}\n// (arr1[index1] < arr2[index2])\nfunction simpleCompare(el1, el2) {\n    return el1 < el2;\n}\n/**\n * Merge sorted array helper function\n */\nfunction mergeSortedArray(arr1, arr2, compareFn = simpleCompare) {\n    const merged = [];\n    let index1 = 0;\n    let index2 = 0;\n    let current = 0;\n    while (current < arr1.length + arr2.length) {\n        let isArr1Depleted = index1 >= arr1.length;\n        let isArr2Depleted = index2 >= arr2.length;\n        if (!isArr1Depleted && (isArr2Depleted || compareFn(arr1[index1], arr2[index2]))) {\n            merged[current] = arr1[index1];\n            index1++;\n        }\n        else {\n            merged[current] = arr2[index2];\n            index2++;\n        }\n        current++;\n    }\n    return merged;\n}\n/**\n * Calculate system scrollbar size\n */\nfunction getScrollbarSize(document) {\n    // Create a temporary div container and append it to the body\n    const container = document.createElement('div');\n    // Apply styling to ensure the div is scrollable\n    container.style.overflow = 'scroll';\n    container.style.visibility = 'hidden'; // make sure the container isn't visible\n    container.style.position = 'absolute';\n    container.style.top = '-9999px'; // move it out of the screen\n    container.style.width = '50px'; // arbitrary width\n    container.style.height = '50px'; // arbitrary height\n    // Append the div to the body\n    document.body.appendChild(container);\n    // Calculate the width of the scrollbar\n    const scrollbarWidth = container.offsetWidth - container.clientWidth;\n    // Remove the div from the body after calculation\n    document.body.removeChild(container);\n    // Return the calculated width of the scrollbar\n    return scrollbarWidth;\n}\n/* Scale a value between 2 ranges\n *\n * Sample:\n * // 55 from a 0-100 range to a 0-1000 range (Ranges don't have to be positive)\n * const n = scaleValue(55, [0,100], [0,1000]);\n *\n * Ranges of two values\n * @from\n * @to\n *\n * ~~ return value does the equivalent of Math.floor but faster.\n */\nfunction scaleValue(value, from, to) {\n    return ((to[1] - to[0]) * (value - from[0])) / (from[1] - from[0]) + to[0];\n}\n/**\n * Async timeout\n */\nasync function timeout(delay = 0) {\n    await new Promise((r) => {\n        setTimeout(() => r(), delay);\n    });\n}\n/**\n * Type script mixins\n */\nfunction applyMixins(derivedCtor, constructors) {\n    constructors.forEach(baseCtor => {\n        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {\n            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null));\n        });\n    });\n}\n\nexport { applyMixins as a, findPositionInArray as f, getScrollbarSize as g, mergeSortedArray as m, pushSorted as p, range as r, scaleValue as s, timeout as t };\n"]}

package/dist/element/chunk-TFV4CJR4.js

@@ -0,0 +1,183 @@
+// ../../node_modules/.pnpm/@revolist+revogrid@4.25.2/node_modules/@revolist/revogrid/dist/esm/debounce-PCRWZliA.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal || freeSelf || Function("return this")();
+var Symbol = root.Symbol;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty = objectProto$1.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$1.toString;
+var symToStringTag$1 = Symbol ? Symbol.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var objectProto = Object.prototype;
+var nativeObjectToString = objectProto.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+}
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {
+  }
+  return index;
+}
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var now = function() {
+  return root.Date.now();
+};
+var FUNC_ERROR_TEXT = "Expected a function";
+var nativeMax = Math.max;
+var nativeMin = Math.min;
+function debounce(func, wait, options) {
+  var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = toNumber(wait) || 0;
+  if (isObject(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    var args = lastArgs, thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(now());
+  }
+  function debounced() {
+    var time = now(), isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+/*! Bundled license information:
+
+@revolist/revogrid/dist/esm/debounce-PCRWZliA.js:
+  (*!
+   * Built by Revolist OU ❤️
+   *)
+*/
+
+export { Symbol, baseGetTag, debounce, freeGlobal, isObject, isObjectLike, isSymbol, root, toNumber };
+//# sourceMappingURL=chunk-TFV4CJR4.js.map
+//# sourceMappingURL=chunk-TFV4CJR4.js.map