@opentinyvue/vue-renderless 3.21.0

package/grid/static/object/assign.js

@@ -0,0 +1,41 @@
+import "../../../chunk-G2ADBYYC.js";
+import arrayEach from "../array/arrayEach";
+import keys from "../base/keys";
+import clone from "../base/clone";
+let objectAssignFns = Object.assign;
+const handleAssign = (destination, args, isClone) => {
+  let len = args.length;
+  for (let source, index = 1; index < len; index++) {
+    source = args[index];
+    let eachCallback;
+    if (isClone) {
+      eachCallback = (key) => {
+        destination[key] = clone(source[key], isClone);
+      };
+    } else {
+      eachCallback = (key) => {
+        destination[key] = source[key];
+      };
+    }
+    arrayEach(keys(args[index]), eachCallback);
+  }
+  return destination;
+};
+const assign = function(target) {
+  if (target) {
+    let args = arguments;
+    if (target === true) {
+      if (args.length > 1) {
+        target = Array.isArray(target[1]) ? [] : {};
+        return handleAssign(target, args, true);
+      }
+    } else {
+      return objectAssignFns ? objectAssignFns.apply(Object, args) : handleAssign(target, args);
+    }
+  }
+  return target;
+};
+var assign_default = assign;
+export {
+  assign_default as default
+};

package/grid/static/object/extend.js

@@ -0,0 +1,7 @@
+import "../../../chunk-G2ADBYYC.js";
+import assign from "./assign";
+const extend = assign;
+var extend_default = extend;
+export {
+  extend_default as default
+};

package/grid/static/object/lastObjectEach.js

@@ -0,0 +1,12 @@
+import "../../../chunk-G2ADBYYC.js";
+import lastArrayEach from "../array/lastArrayEach";
+import keys from "../base/keys";
+const lastObjectEach = (obj, iterate, context) => {
+  lastArrayEach(keys(obj), (key) => {
+    iterate.call(context, obj[key], key, obj);
+  });
+};
+var lastObjectEach_default = lastObjectEach;
+export {
+  lastObjectEach_default as default
+};

package/grid/static/object/objectEach.js

@@ -0,0 +1,15 @@
+import "../../../chunk-G2ADBYYC.js";
+import hasOwnProp from "../base/hasOwnProp";
+const objectEach = (obj, iterate, context) => {
+  if (obj) {
+    Object.keys(obj).forEach((key) => {
+      if (hasOwnProp(obj, key)) {
+        iterate.call(context, obj[key], key, obj);
+      }
+    });
+  }
+};
+var objectEach_default = objectEach;
+export {
+  objectEach_default as default
+};

package/grid/static/object/objectMap.js

@@ -0,0 +1,24 @@
+import "../../../chunk-G2ADBYYC.js";
+import each from "../base/each";
+import isFunction from "../base/isFunction";
+import property from "../function/property";
+const objectMap = (obj, iterate, context) => {
+  let result = {};
+  if (obj) {
+    if (iterate) {
+      if (!isFunction(iterate)) {
+        iterate = property(iterate);
+      }
+      each(obj, (val, index) => {
+        result[index] = iterate.call(context, val, index, obj);
+      });
+    } else {
+      return obj;
+    }
+  }
+  return result;
+};
+var objectMap_default = objectMap;
+export {
+  objectMap_default as default
+};

package/grid/static/object/values.js

@@ -0,0 +1,17 @@
+import "../../../chunk-G2ADBYYC.js";
+import objectEach from "./objectEach";
+const values = (obj, iterator, ctx) => {
+  const objectValues = [];
+  objectEach(
+    obj,
+    (val) => {
+      objectValues.push(val);
+    },
+    ctx
+  );
+  return objectValues;
+};
+var values_default = values;
+export {
+  values_default as default
+};

package/grid/static/static/staticDocument.js

@@ -0,0 +1,7 @@
+import "../../../chunk-G2ADBYYC.js";
+import staticStrUndefined from "./staticStrUndefined";
+let staticDocument = typeof document === staticStrUndefined ? 0 : document;
+var staticDocument_default = staticDocument;
+export {
+  staticDocument_default as default
+};

package/grid/static/static/staticHGKeyRE.js

@@ -0,0 +1,6 @@
+import "../../../chunk-G2ADBYYC.js";
+const staticHGKeyRE = /(.+)?\[(\d+)\]$/;
+var staticHGKeyRE_default = staticHGKeyRE;
+export {
+  staticHGKeyRE_default as default
+};

package/grid/static/static/staticParseInt.js

@@ -0,0 +1,6 @@
+import "../../../chunk-G2ADBYYC.js";
+let staticParseInt = parseInt;
+var staticParseInt_default = staticParseInt;
+export {
+  staticParseInt_default as default
+};

package/grid/static/static/staticStrUndefined.js

@@ -0,0 +1,6 @@
+import "../../../chunk-G2ADBYYC.js";
+let staticStrUndefined = "undefined";
+var staticStrUndefined_default = staticStrUndefined;
+export {
+  staticStrUndefined_default as default
+};

package/grid/static/static/staticWindow.js

@@ -0,0 +1,7 @@
+import "../../../chunk-G2ADBYYC.js";
+import staticStrUndefined from "./staticStrUndefined";
+let staticWindow = typeof window === staticStrUndefined ? 0 : window;
+var staticWindow_default = staticWindow;
+export {
+  staticWindow_default as default
+};

package/grid/static/string/template.js

@@ -0,0 +1,14 @@
+import "../../../chunk-G2ADBYYC.js";
+import toValString from "./toString";
+import get from "../base/get";
+const template = (str, obj) => {
+  let rest = toValString(str);
+  if (rest && obj) {
+    return rest.replace(/\{{2}([.\w[\]\s]+)\}{2}/g, (match, keys) => get(obj, keys));
+  }
+  return rest;
+};
+var template_default = template;
+export {
+  template_default as default
+};

package/grid/static/string/toString.js

@@ -0,0 +1,16 @@
+import "../../../chunk-G2ADBYYC.js";
+import eqNull from "../base/eqNull";
+import isNumber from "../base/isNumber";
+const toValString = (obj) => {
+  if (isNumber(obj)) {
+    if (String(obj).includes("e-")) {
+      let isNegative = obj < 0;
+      return (isNegative ? "-" : "") + "0" + String((isNegative ? Math.abs(obj) : obj) + 1).substr(1);
+    }
+  }
+  return String(eqNull(obj) ? "" : obj);
+};
+var toString_default = toValString;
+export {
+  toString_default as default
+};

package/grid/utils/column.js

@@ -0,0 +1,73 @@
+import "../../chunk-G2ADBYYC.js";
+import { isBoolean } from "../static";
+import { initFilter } from "./common";
+let columnUniqueId = 0;
+const setColumnFormat = (column, props) => column.format = props.formatConfig;
+function setBasicProperty(column, context) {
+  column.id = `col_${++columnUniqueId}`;
+  column.type = context.type;
+  column.prop = context.prop;
+  column.rules = context.rules;
+  column.required = context.required;
+  column.property = context.field || context.prop;
+  column.title = context.title;
+  column.label = context.label;
+  column.width = context.width;
+  column.minWidth = context.minWidth;
+  column.resizable = context.resizable;
+  column.fixed = context.fixed;
+  column.align = context.align;
+  column.headerAlign = context.headerAlign;
+  column.footerAlign = context.footerAlign;
+  column.showOverflow = context.showOverflow;
+  column.showHeaderOverflow = context.showHeaderOverflow;
+  column.showTip = context.showTip;
+  column.showHeaderTip = context.showHeaderTip;
+  column.className = context.class || context.className;
+  column.headerClassName = context.headerClassName;
+  column.footerClassName = context.footerClassName;
+  column.indexMethod = context.indexMethod;
+  column.formatText = context.formatText;
+  column.formatValue = context.formatValue;
+  setColumnFormat(column, context);
+  column.sortable = context.sortable;
+  column.sortBy = context.sortBy;
+  column.sortMethod = context.sortMethod;
+  column.remoteSort = context.remoteSort;
+  column.filterMultiple = isBoolean(context.filterMultiple) ? context.filterMultiple : true;
+  column.filterMethod = context.filterMethod;
+  column.filterRender = context.filterRender;
+  column.filter = context.filter && initFilter(context.filter);
+  column.treeNode = context.treeNode;
+  column.renderer = context.renderer;
+  column.editor = context.editor;
+  column.operationConfig = context.operationConfig;
+  column.equals = context.equals;
+}
+function ColumnConfig(context, { renderHeader, renderCell, renderData } = {}, config = {}) {
+  setBasicProperty(this, context);
+  this.params = context.params;
+  this.visible = true;
+  this.level = 1;
+  this.rowSpan = 1;
+  this.colSpan = 1;
+  this.order = null;
+  this.renderWidth = 0;
+  this.renderHeight = 0;
+  this.resizeWidth = 0;
+  this.renderLeft = 0;
+  this.model = {};
+  this.renderHeader = renderHeader || context.renderHeader;
+  this.renderCell = renderCell || context.renderCell;
+  this.renderData = renderData;
+  this.showIcon = isBoolean(context.showIcon) ? context.showIcon : true;
+  this.loading = false;
+  this.slots = context.slots;
+  this.own = context;
+  this.asyncPrefix = config.constant.asyncPrefix;
+}
+const getColumnConfig = (context, options, config) => context instanceof ColumnConfig ? context : new ColumnConfig(context, options, config);
+export {
+  getColumnConfig,
+  setColumnFormat
+};

package/grid/utils/common.js

@@ -0,0 +1,136 @@
+import {
+  __spreadValues
+} from "../../chunk-G2ADBYYC.js";
+import { isNull } from "../../common/type";
+import { find } from "../../common/array";
+import { get, isFunction, set } from "../static";
+const gridSize = ["medium", "small", "mini"];
+const getSize = ({ size, $parent }) => size || ($parent && gridSize.includes($parent.size) ? $parent.size : null);
+const getFuncText = (content) => isFunction(content) ? content() : content;
+const getRowkey = ($table) => $table.rowId;
+const getRowid = ($table, row) => {
+  const rowId = get(row, getRowkey($table));
+  return rowId ? encodeURIComponent(rowId) : "";
+};
+const getColumnList = (columns) => {
+  const result = [];
+  columns.forEach((column) => {
+    if (column.children && column.children.length) {
+      result.push(...getColumnList(column.children));
+    } else {
+      result.push(column);
+    }
+  });
+  return result;
+};
+const getClass = (property, params) => property ? isFunction(property) ? property(params) : property : "";
+const getFilters = (filters) => (filters || []).map(({ label, value, data, checked }) => ({
+  label,
+  value,
+  data,
+  _data: data,
+  checked: !!checked
+}));
+const initFilter = (filter) => {
+  return __spreadValues({
+    condition: {
+      input: "",
+      relation: "equals",
+      empty: null,
+      type: null,
+      value: []
+    },
+    hasFilter: false,
+    custom: null
+  }, filter);
+};
+const formatText = (value) => `${isNull(value) ? "" : value}`;
+const setCellValue = (row, column, value) => {
+  const { format, property } = column;
+  if (format && format.async && Array.isArray(format.data) && format.data.length > 0 && value) {
+    let labelText = "";
+    const { enabled, valueSplit, textSplit } = format.async.splitConfig || {};
+    const findCellValue = (optionValue) => find(format.data, (col) => {
+      if (typeof col === "object") {
+        const colLabel = get(col, format.async.text || "label");
+        const colValue = get(col, format.async.value || "value");
+        col.label = colLabel;
+        return optionValue === colValue || optionValue === colLabel;
+      }
+      return optionValue === col;
+    });
+    if (enabled) {
+      const labelTexts = [];
+      value.split(valueSplit || ",").forEach((item) => {
+        const findValue = findCellValue(item);
+        if (findValue) {
+          labelTexts.push(findValue.label);
+        }
+      });
+      labelText = labelTexts.join(textSplit || ",");
+    } else {
+      labelText = findCellValue(value);
+    }
+    set(row, column.asyncPrefix + property, labelText ? labelText.label : labelText);
+  }
+  set(row, property, value);
+};
+const hasChildrenList = (item) => item && item.children && item.children.length > 0;
+const emitEvent = (vm, type, args) => {
+  if (vm.tableListeners[type]) {
+    const params = [].concat(args);
+    vm.$emit(type, ...params);
+  }
+};
+const assemColumn = ($table) => {
+  const collectColumn = [];
+  const assem = (columnVms, columns) => {
+    if (Array.isArray(columnVms)) {
+      columnVms.forEach((columnVm) => {
+        const column = columnVm.columnConfig;
+        const children = [];
+        if (column) {
+          columns.push(column);
+          assem(columnVm.childColumns, children);
+          column.children = children.length > 0 ? children : null;
+        }
+      });
+    }
+  };
+  assem($table.childColumns, collectColumn);
+  $table.collectColumn = collectColumn;
+};
+const getCellValue = (row, column) => get(row, column.own.field);
+const getListeners = ($attrs, $listeners) => {
+  const regHyphenate = /\B([A-Z])/g;
+  const regEventPrefix = /^on[A-Z]/;
+  const listeners = {};
+  if ($listeners) {
+    return $listeners;
+  }
+  Object.keys($attrs).forEach((name) => {
+    const event = $attrs[name];
+    if (regEventPrefix.test(name) && typeof event === "function") {
+      listeners[name.slice(2).replace(regHyphenate, "-$1").toLowerCase()] = event;
+    }
+  });
+  return listeners;
+};
+export {
+  assemColumn,
+  emitEvent,
+  formatText,
+  getCellValue,
+  getClass,
+  getColumnList,
+  getFilters,
+  getFuncText,
+  getListeners,
+  getRowid,
+  getRowkey,
+  getSize,
+  gridSize,
+  hasChildrenList,
+  initFilter,
+  setCellValue
+};

package/grid/utils/dom.js

@@ -0,0 +1,224 @@
+import "../../chunk-G2ADBYYC.js";
+import { getRowid } from "./common";
+import { hasClass, getDomNode } from "../../common/deps/dom";
+import { getActualTarget } from "../../common/event";
+import { arrayIndexOf } from "../static";
+const ATTR_NAME = "data-rowid";
+const CELL_CLS = ".tiny-grid-cell";
+const ROW_CLS = ".tiny-grid-body__row";
+const isPx = (val) => val && /^\d+(px)?$/.test(val);
+const isScale = (val) => val && /^\d+%$/.test(val);
+const updateCellTitle = (event) => {
+  const cellEl = event.currentTarget.querySelector(CELL_CLS);
+  const content = cellEl.innerText;
+  if (cellEl.getAttribute("title") !== content) {
+    cellEl.setAttribute("title", content);
+  }
+};
+const rowToVisible = ($table, row) => {
+  $table.$nextTick(() => {
+    const tableBodyVnode = $table.$refs.tableBody;
+    if (tableBodyVnode) {
+      const gridbodyEl = tableBodyVnode.$el;
+      const trEl = gridbodyEl.querySelector(`[${ATTR_NAME}="${getRowid($table, row)}"]`);
+      if (trEl) {
+        const bodyHeight = gridbodyEl.clientHeight;
+        const bodySrcollTop = gridbodyEl.scrollTop;
+        const trOffsetTop = trEl.offsetTop + (trEl.offsetParent ? trEl.offsetParent.offsetTop : 0);
+        const trHeight = trEl.clientHeight;
+        if (trOffsetTop < bodySrcollTop || trOffsetTop > bodySrcollTop + bodyHeight) {
+          gridbodyEl.scrollTop = trOffsetTop;
+        } else if (trOffsetTop + trHeight >= bodyHeight + bodySrcollTop) {
+          gridbodyEl.scrollTop = bodySrcollTop + trHeight;
+        }
+      } else {
+        if ($table.scrollYLoad) {
+          gridbodyEl.scrollTop = ($table.afterFullData.indexOf(row) - 1) * $table.scrollYStore.rowHeight;
+        }
+      }
+    }
+  });
+};
+function getFixedLeft($table, from, column, body, offset) {
+  let scrollLeft = $table.elemStore["main-body-wrapper"].scrollLeft + offset;
+  if (!column.fixed) {
+    from.fixed === "left" && (scrollLeft = 0);
+    from.fixed === "right" && (scrollLeft = body.scrollWidth);
+  }
+  return scrollLeft;
+}
+function computeScrollLeft($table, td) {
+  const { tableBody } = $table.$refs;
+  const { visibleColumn } = $table;
+  const { scrollLeft: bodyLeft, clientWidth: bodyWidth } = tableBody.$el;
+  let leftWidth = 0;
+  let rightWidth = 0;
+  visibleColumn.forEach((column) => {
+    if (column.fixed === "left") {
+      leftWidth += column.renderWidth;
+    } else if (column.fixed === "right") {
+      rightWidth += column.renderWidth;
+    }
+  });
+  const tdLeft = td._accumulateRenderWidth || td.offsetLeft + (td.offsetParent ? td.offsetParent.offsetLeft : 0);
+  const tdWidth = td._renderWidth || td.clientWidth;
+  let scrollLeft;
+  if (tdLeft < bodyLeft + leftWidth) {
+    scrollLeft = tdLeft - leftWidth;
+  } else if (tdLeft + tdWidth > bodyLeft + bodyWidth - rightWidth) {
+    scrollLeft = tdLeft + tdWidth - bodyWidth + rightWidth;
+  } else {
+    scrollLeft = bodyLeft;
+  }
+  return scrollLeft;
+}
+function setBodyLeft(body, td, $table, column, move) {
+  const { isLeftArrow, isRightArrow, from } = move || {};
+  const bodyScollLeft = computeScrollLeft($table, td);
+  $table.scrollTo(bodyScollLeft);
+  $table.lastScrollLeft = bodyScollLeft;
+  if (from) {
+    const direction = isLeftArrow ? "left" : isRightArrow ? "right" : null;
+    const fixedDom = $table.elemStore[`${direction}-body-list`];
+    const mainBody = $table.elemStore["main-body-wrapper"];
+    const { left, right } = td.getBoundingClientRect();
+    let offset = 0;
+    if (isLeftArrow && fixedDom) {
+      const div = fixedDom.querySelector("td.fixed__column");
+      const division = div ? div.getBoundingClientRect().left : fixedDom.getBoundingClientRect().right;
+      division > left && (offset = left - division);
+    }
+    if (isRightArrow && fixedDom) {
+      const div = fixedDom.querySelector("td:not(.fixed__column)") || fixedDom;
+      const division = div.getBoundingClientRect().left;
+      division < right && (offset = right - division);
+    }
+    mainBody.scrollLeft = getFixedLeft($table, from, column, body, offset);
+  }
+}
+const colToVisible = ($table, column, move) => {
+  $table.$nextTick(() => {
+    const gridbodyEl = $table.$refs.tableBody.$el;
+    const tdElem = gridbodyEl.querySelector(`.${column.id}`);
+    if (tdElem) {
+      setBodyLeft(gridbodyEl, tdElem, $table, column, move);
+    } else if ($table.scrollXLoad) {
+      const visibleColumn = $table.visibleColumn;
+      let scrollLeft = 0;
+      for (let index = 0; index < visibleColumn.length; index++) {
+        if (visibleColumn[index] === column) {
+          break;
+        }
+        scrollLeft += visibleColumn[index].renderWidth;
+      }
+      gridbodyEl.scrollLeft = computeScrollLeft($table, {
+        _accumulateRenderWidth: scrollLeft,
+        _renderWidth: column.renderWidth
+      });
+    }
+  });
+};
+const hasDataTag = (el, value) => {
+  if (!el || !value || !el.getAttribute) {
+    return false;
+  }
+  return (" " + el.getAttribute("data-tag") + " ").includes(" " + value + " ");
+};
+const getEventTargetNode = (event, container, queryCls) => {
+  let targetEl;
+  let target = getActualTarget(event);
+  while (target && target.nodeType && target !== document) {
+    if (queryCls && (hasClass(target, queryCls) || hasDataTag(target, queryCls))) {
+      targetEl = target;
+    } else if (target === container) {
+      return {
+        flag: queryCls ? !!targetEl : true,
+        container,
+        targetElem: targetEl
+      };
+    }
+    target = target.parentNode;
+  }
+  return { flag: false };
+};
+function getNodeOffset(el, container, rest) {
+  if (el) {
+    const htmlEl = document.querySelector("html");
+    const bodyEl = document.body;
+    const parentEl = el.parentNode;
+    rest.top += el.offsetTop;
+    rest.left += el.offsetLeft;
+    if (parentEl && parentEl !== htmlEl && parentEl !== bodyEl) {
+      rest.top -= parentEl.scrollTop;
+      rest.left -= parentEl.scrollLeft;
+    }
+    if (container && (el === container || el.offsetParent === container) ? 0 : el.offsetParent) {
+      return getNodeOffset(el.offsetParent, container, rest);
+    }
+  }
+  return rest;
+}
+const getOffsetPos = (el, container) => getNodeOffset(el, container, { left: 0, top: 0 });
+const getAbsolutePos = (el) => {
+  const bounding = el.getBoundingClientRect();
+  const { scrollTop, scrollLeft } = getDomNode();
+  return {
+    top: scrollTop + bounding.top,
+    left: scrollLeft + bounding.left
+  };
+};
+const getCellNodeIndex = (cell) => {
+  const trEl = cell.parentNode;
+  const columnIndex = arrayIndexOf(trEl.children, cell);
+  const rowIndex = arrayIndexOf(trEl.parentNode.children, trEl);
+  return { columnIndex, rowIndex };
+};
+const getRowNodes = (trList, cellNode, targetCellNode) => {
+  const startColIndex = cellNode.columnIndex;
+  const startRowIndex = cellNode.rowIndex;
+  const targetColIndex = targetCellNode.columnIndex;
+  const targetRowIndex = targetCellNode.rowIndex;
+  const rows = [];
+  for (let rowIndex = Math.min(startRowIndex, targetRowIndex), rowLen = Math.max(startRowIndex, targetRowIndex); rowIndex <= rowLen; rowIndex++) {
+    const cells = [];
+    const trEl = trList[rowIndex];
+    for (let colIndex = Math.min(startColIndex, targetColIndex), colLen = Math.max(startColIndex, targetColIndex); colIndex <= colLen; colIndex++) {
+      cells.push(trEl.children[colIndex]);
+    }
+    rows.push(cells);
+  }
+  return rows;
+};
+const getCellIndexs = (cell) => {
+  const trEl = cell.parentNode;
+  const rowid = trEl.getAttribute(ATTR_NAME);
+  const columnIndex = [].indexOf.call(trEl.children, cell);
+  const rowIndex = [].indexOf.call(trEl.parentNode.children, trEl);
+  return { rowid, rowIndex, columnIndex };
+};
+const getCell = ($table, { row, column }) => new Promise((resolve) => {
+  $table.$nextTick(() => {
+    const bodyElem = $table.$refs[`${column.fixed || "table"}Body`];
+    resolve(
+      (bodyElem || $table.$refs.tableBody).$el.querySelector(
+        `${ROW_CLS}[${ATTR_NAME}="${getRowid($table, row)}"] .${column.id}`
+      )
+    );
+  });
+});
+export {
+  colToVisible,
+  getAbsolutePos,
+  getCell,
+  getCellIndexs,
+  getCellNodeIndex,
+  getDomNode,
+  getEventTargetNode,
+  getOffsetPos,
+  getRowNodes,
+  hasDataTag,
+  isPx,
+  isScale,
+  rowToVisible,
+  updateCellTitle
+};

package/grid/utils/event.js

@@ -0,0 +1,40 @@
+import "../../chunk-G2ADBYYC.js";
+import browser from "../../common/browser";
+import { remove } from "../static";
+import { on } from "../../common/deps/dom";
+const wheelName = browser.isDoc && /Firefox/i.test(navigator.userAgent) ? "DOMMouseScroll" : "mousewheel";
+const eventStore = [];
+const invoke = ({ comp, type, cb }, event) => {
+  if (type === event.type || type === "mousewheel" && event.type === wheelName) {
+    cb.call(comp, event);
+  }
+};
+const GlobalEvent = {
+  on(comp, type, cb, capture = false) {
+    if (cb) {
+      eventStore.push({ comp, type, cb, capture });
+    }
+  },
+  off(comp, type, capture = false) {
+    remove(eventStore, (item) => item.comp === comp && item.type === type && item.capture === capture);
+  },
+  trigger(event) {
+    eventStore.filter((item) => !item.capture).forEach((item) => invoke(item, event));
+  },
+  capture(event) {
+    eventStore.filter((item) => item.capture).forEach((item) => invoke(item, event));
+  }
+};
+if (browser.isDoc) {
+  on(document, "keydown", GlobalEvent.trigger);
+  on(document, "contextmenu", GlobalEvent.trigger);
+  on(window, "mousedown", GlobalEvent.trigger);
+  on(window, "mousedown", GlobalEvent.capture, true);
+  on(window, "blur", GlobalEvent.trigger);
+  on(window, "resize", GlobalEvent.trigger);
+  on(window, wheelName, GlobalEvent.trigger);
+}
+var event_default = GlobalEvent;
+export {
+  event_default as default
+};

package/grid/utils/index.js

@@ -0,0 +1,8 @@
+import "../../chunk-G2ADBYYC.js";
+import GlobalEvent from "./event";
+export * from "./column";
+export * from "./common";
+export * from "./dom";
+export {
+  GlobalEvent
+};