balala-revogrid 1.0.0

package/dist/revo-grid/header-cell-renderer-BVHTuFGE.js

@@ -0,0 +1,1715 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+import { h } from './index-Dyptvvxf.js';
+import { a5 as toFinite, a6 as keys, _ as isArrayLike, a4 as baseIteratee, Y as isArray, P as GRID_INTERNALS, a7 as isIterateeCall, b as getSourceItem, z as DISABLED_CLASS, C as CELL_CLASS } from './dimension.helpers-DDil7Dg0.js';
+
+/**
+ * Converts `value` to an integer.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toInteger(3.2);
+ * // => 3
+ *
+ * _.toInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toInteger(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toInteger('3.2');
+ * // => 3
+ */
+function toInteger(value) {
+  var result = toFinite(value),
+      remainder = result % 1;
+
+  return result === result ? (remainder ? result - remainder : result) : 0;
+}
+
+/**
+ * A specialized version of `_.reduce` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the first element of `array` as
+ *  the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  if (initAccum && length) {
+    accumulator = array[++index];
+  }
+  while (++index < length) {
+    accumulator = iteratee(accumulator, array[index], index, array);
+  }
+  return accumulator;
+}
+
+/**
+ * Creates a base function for methods like `_.forIn` and `_.forOwn`.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseFor(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    var index = -1,
+        iterable = Object(object),
+        props = keysFunc(object),
+        length = props.length;
+
+    while (length--) {
+      var key = props[++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+
+/**
+ * The base implementation of `baseForOwn` which iterates over `object`
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseFor = createBaseFor();
+
+/**
+ * The base implementation of `_.forOwn` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwn(object, iteratee) {
+  return object && baseFor(object, iteratee, keys);
+}
+
+/**
+ * Creates a `baseEach` or `baseEachRight` function.
+ *
+ * @private
+ * @param {Function} eachFunc The function to iterate over a collection.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseEach(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length,
+        index = -1,
+        iterable = Object(collection);
+
+    while ((++index < length)) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+
+/**
+ * The base implementation of `_.forEach` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEach = createBaseEach(baseForOwn);
+
+/**
+ * The base implementation of `_.reduce` and `_.reduceRight`, without support
+ * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} accumulator The initial value.
+ * @param {boolean} initAccum Specify using the first or last element of
+ *  `collection` as the initial value.
+ * @param {Function} eachFunc The function to iterate over `collection`.
+ * @returns {*} Returns the accumulated value.
+ */
+function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
+  eachFunc(collection, function(value, index, collection) {
+    accumulator = initAccum
+      ? (initAccum = false, value)
+      : iteratee(accumulator, value, index, collection);
+  });
+  return accumulator;
+}
+
+/**
+ * Reduces `collection` to a value which is the accumulated result of running
+ * each element in `collection` thru `iteratee`, where each successive
+ * invocation is supplied the return value of the previous. If `accumulator`
+ * is not given, the first element of `collection` is used as the initial
+ * value. The iteratee is invoked with four arguments:
+ * (accumulator, value, index|key, collection).
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like
+ * `_.reduce`, `_.reduceRight`, and `_.transform`.
+ *
+ * The guarded methods are:
+ * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
+ * and `sortBy`
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @returns {*} Returns the accumulated value.
+ * @see _.reduceRight
+ * @example
+ *
+ * _.reduce([1, 2], function(sum, n) {
+ *   return sum + n;
+ * }, 0);
+ * // => 3
+ *
+ * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
+ *   (result[value] || (result[value] = [])).push(key);
+ *   return result;
+ * }, {});
+ * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
+ */
+function reduce(collection, iteratee, accumulator) {
+  var func = isArray(collection) ? arrayReduce : baseReduce,
+      initAccum = arguments.length < 3;
+
+  return func(collection, baseIteratee(iteratee), accumulator, initAccum, baseEach);
+}
+
+function getCellData(val) {
+    if (typeof val === 'undefined' || val === null) {
+        return '';
+    }
+    return val;
+}
+function getCellRaw(model = {}, column) {
+    if (!column) {
+        return;
+    }
+    if (column.cellParser) {
+        return column.cellParser(model, column);
+    }
+    return model[column.prop];
+}
+function getCellDataParsed(model, column) {
+    return getCellData(getCellRaw(model, column));
+}
+/**
+ * Get column type from column data
+ */
+function getColumnType(rgCol) {
+    if (rgCol.pin) {
+        return rgCol.pin;
+    }
+    return 'rgCol';
+}
+function getColumnSizes(cols) {
+    const res = {};
+    for (const [i, c] of cols.entries()) {
+        if (c.size) {
+            res[i] = c.size;
+        }
+    }
+    return res;
+}
+/**
+ * Check if column is grouping column
+ */
+function isColGrouping(colData) {
+    return !!colData.children;
+}
+/**
+ * This function is used to create a collection of columns.
+ */
+function getColumns(columns, level = 0, types, resFromRoot) {
+    const collection = {
+        // columns as they are in stores per type
+        columns: {
+            rgCol: [],
+            colPinStart: [],
+            colPinEnd: [],
+        },
+        // columns indexed by prop for quick access
+        columnByProp: {},
+        // column grouping
+        columnGrouping: {
+            rgCol: [],
+            colPinStart: [],
+            colPinEnd: [],
+        },
+        // sorting
+        sort: {},
+        // max depth level for column grouping
+        maxLevel: level,
+    };
+    return reduce(columns, (res, colData) => {
+        var _a;
+        // Grouped column
+        if (isColGrouping(colData)) {
+            res = gatherGroup(res, colData, getColumns(colData.children, level + 1, types, res), resFromRoot === null || resFromRoot === void 0 ? void 0 : resFromRoot.columns, level);
+            return res;
+        }
+        // Column type
+        const columnDefinitionFromType = colData.columnType && (types === null || types === void 0 ? void 0 : types[colData.columnType]);
+        // Regular column
+        const regularColumn = Object.assign(Object.assign({}, columnDefinitionFromType), colData);
+        // Regular column, no Pin
+        if (!regularColumn.pin) {
+            res.columns.rgCol.push(regularColumn);
+            // Pin
+        }
+        else {
+            res.columns[regularColumn.pin].push(regularColumn);
+        }
+        if (regularColumn.order) {
+            res.sort[regularColumn.prop] = regularColumn;
+        }
+        // it's possible that some columns have same prop, but better to avoid it
+        if (!res.columnByProp[regularColumn.prop]) {
+            res.columnByProp[regularColumn.prop] = [];
+        }
+        res.columnByProp[regularColumn.prop].push(regularColumn);
+        // trigger setup hook if present
+        (_a = regularColumn.beforeSetup) === null || _a === void 0 ? void 0 : _a.call(regularColumn, regularColumn);
+        return res;
+    }, collection);
+}
+function gatherGroup(res, colData, collection, existingColumnsByType, level = 0) {
+    // group template - 使用展开运算符保留所有属性
+    const group = Object.assign(Object.assign({}, colData), { level, indexes: [] });
+    // check columns for update
+    columnTypes.forEach(type => {
+        const resultItem = res.columns[type];
+        const collectionItem = collection.columns[type];
+        // if column data
+        if (isArray(resultItem) && isArray(collectionItem)) {
+            // fill grouping
+            const itemLength = collectionItem.length;
+            if (itemLength) {
+                const columnLength = [...((existingColumnsByType === null || existingColumnsByType === void 0 ? void 0 : existingColumnsByType[type]) || []), ...resultItem].length;
+                // fill columns
+                resultItem.push(...collectionItem);
+                // fill indexes per each viewport
+                res.columnGrouping[type].push(Object.assign(Object.assign({}, group), { indexes: Array(itemLength).fill(columnLength).map((v, i) => v + i) }));
+            }
+        }
+    });
+    // merge column groupings
+    for (let k in collection.columnGrouping) {
+        const key = k;
+        const collectionItem = collection.columnGrouping[key];
+        res.columnGrouping[key].push(...collectionItem);
+    }
+    res.maxLevel = Math.max(res.maxLevel, collection.maxLevel);
+    res.sort = Object.assign(Object.assign({}, res.sort), collection.sort);
+    res.columnByProp = Object.assign(Object.assign({}, res.columnByProp), collection.columnByProp);
+    return res;
+}
+function findColumn(columns, prop) {
+    for (const c of columns) {
+        if (isColGrouping(c)) {
+            const found = findColumn(c.children, prop);
+            if (found) {
+                return found;
+            }
+        }
+        else if (c.prop === prop) {
+            return c;
+        }
+    }
+    return undefined;
+}
+function getColumnByProp(columns, prop) {
+    return findColumn(columns, prop);
+}
+/**
+ * 获取自动宽度列的配置选项
+ * 用于 convertCollectionToColumns 的第二个参数
+ *
+ * @param providers - PluginProviders 对象
+ * @param stretchPlugin - ColumnStretchPlugin 实例
+ * @returns 自动宽度列配置选项
+ *
+ * @example
+ * ```typescript
+ * const stretchPlugin = providers.plugins.getByClass(ColumnStretchPlugin);
+ * const options = getStretchColumnOptions(providers, stretchPlugin);
+ * const columns = convertCollectionToColumns(providers, options);
+ * ```
+ */
+function getStretchColumnOptions(providers, stretchPlugin // ColumnStretchPlugin 实例
+) {
+    var _a, _b;
+    if (!stretchPlugin) {
+        return undefined;
+    }
+    const columnCollection = (_a = providers === null || providers === void 0 ? void 0 : providers.column) === null || _a === void 0 ? void 0 : _a.collection;
+    if (!columnCollection) {
+        return undefined;
+    }
+    // 收集自动宽度列的 prop
+    const stretchColumnProps = new Set();
+    const manuallyResizedProps = new Set();
+    const stretchConfig = (_b = stretchPlugin.getStretchColumnConfig) === null || _b === void 0 ? void 0 : _b.call(stretchPlugin);
+    if (stretchConfig) {
+        // 根据配置类型确定自动宽度列
+        if (stretchConfig === 'last') {
+            // 最后一列
+            const rgColColumns = columnCollection.columns.rgCol;
+            if (rgColColumns && rgColColumns.length > 0) {
+                const lastCol = rgColColumns[rgColColumns.length - 1];
+                if (lastCol.prop) {
+                    stretchColumnProps.add(lastCol.prop);
+                }
+            }
+        }
+        else if (stretchConfig === 'all') {
+            // 所有列
+            const dimensionTypes = ['colPinStart', 'rgCol', 'colPinEnd'];
+            dimensionTypes.forEach(type => {
+                const cols = columnCollection.columns[type];
+                if (cols) {
+                    cols.forEach((col) => {
+                        if (col.prop) {
+                            stretchColumnProps.add(col.prop);
+                        }
+                    });
+                }
+            });
+        }
+        else if (typeof stretchConfig === 'number') {
+            // 指定索引的列（从 columnCollection 中按顺序获取）
+            const allColumns = [];
+            const dimensionTypes = ['colPinStart', 'rgCol', 'colPinEnd'];
+            dimensionTypes.forEach(type => {
+                const cols = columnCollection.columns[type];
+                if (cols) {
+                    allColumns.push(...cols);
+                }
+            });
+            if (stretchConfig >= 0 && stretchConfig < allColumns.length) {
+                const col = allColumns[stretchConfig];
+                if (col === null || col === void 0 ? void 0 : col.prop) {
+                    stretchColumnProps.add(col.prop);
+                }
+            }
+        }
+        else if (typeof stretchConfig === 'string') {
+            // 指定 prop 的列
+            stretchColumnProps.add(stretchConfig);
+        }
+    }
+    // 获取手动调整过的列
+    if (stretchPlugin.isManuallyResized) {
+        stretchColumnProps.forEach(prop => {
+            if (stretchPlugin.isManuallyResized(prop)) {
+                manuallyResizedProps.add(prop);
+            }
+        });
+    }
+    return {
+        stretchColumnProps,
+        manuallyResizedProps,
+    };
+}
+/**
+ * 将 ColumnCollection 转换为 revogrid.columns 格式
+ * 按照冻结顺序合并：左冻结列 -> 普通列 -> 右冻结列
+ * 并根据 columnGrouping 信息重建分组结构
+ *
+ * @param providers - PluginProviders 对象
+ * @param options - 可选配置
+ * @param options.stretchColumnProps - 自动宽度列的 prop 集合
+ * @param options.manuallyResizedProps - 被手动调整过的列的 prop 集合
+ * @returns 适用于 revogrid.columns 的列数组（包含分组）
+ *
+ * @example
+ * ```typescript
+ * const columns = convertCollectionToColumns(this.providers, {
+ *   stretchColumnProps: new Set(['displayName']),
+ *   manuallyResizedProps: new Set(['priority'])
+ * });
+ * this.revogrid.columns = columns;
+ * ```
+ */
+function convertCollectionToColumns(providers, options) {
+    var _a;
+    const result = [];
+    const columnCollection = (_a = providers === null || providers === void 0 ? void 0 : providers.column) === null || _a === void 0 ? void 0 : _a.collection;
+    if (!columnCollection) {
+        return result;
+    }
+    const collectionColumns = columnCollection.columns;
+    const columnGrouping = columnCollection.columnGrouping;
+    const stretchColumnProps = (options === null || options === void 0 ? void 0 : options.stretchColumnProps) || new Set();
+    const manuallyResizedProps = (options === null || options === void 0 ? void 0 : options.manuallyResizedProps) || new Set();
+    // 按顺序处理：左冻结 -> 普通 -> 右冻结
+    const orderedTypes = ['colPinStart', 'rgCol', 'colPinEnd'];
+    orderedTypes.forEach(type => {
+        var _a, _b, _c;
+        const columns = collectionColumns[type];
+        if (!columns || columns.length === 0) {
+            return;
+        }
+        // 从 dimension store 获取实时的列宽
+        const dimensionSizes = ((_c = (_b = (_a = providers === null || providers === void 0 ? void 0 : providers.dimension) === null || _a === void 0 ? void 0 : _a.stores[type]) === null || _b === void 0 ? void 0 : _b.store) === null || _c === void 0 ? void 0 : _c.get('sizes')) || {};
+        // 获取该类型的分组信息
+        const groups = (columnGrouping === null || columnGrouping === void 0 ? void 0 : columnGrouping[type]) || [];
+        // 如果没有分组，直接添加所有列
+        if (groups.length === 0) {
+            columns.forEach((col, index) => {
+                const colAny = Object.assign({}, col);
+                // 设置 pin 属性
+                if (type === 'colPinStart') {
+                    colAny.pin = 'colPinStart';
+                }
+                else if (type === 'colPinEnd') {
+                    colAny.pin = 'colPinEnd';
+                }
+                else {
+                    delete colAny.pin;
+                }
+                // 从 dimension store 获取实时宽度
+                if (dimensionSizes[index] !== undefined) {
+                    colAny.size = dimensionSizes[index];
+                }
+                // 处理自动宽度列：如果是自动宽度列且未被手动调整，移除 size 属性
+                if (col.prop && stretchColumnProps.has(col.prop) && !manuallyResizedProps.has(col.prop)) {
+                    delete colAny.size;
+                }
+                result.push(colAny);
+            });
+            return;
+        }
+        // 构建索引到分组的映射
+        const indexToGroup = new Map();
+        groups.forEach((group) => {
+            group.indexes.forEach((index) => {
+                indexToGroup.set(index, group);
+            });
+        });
+        // 按原始顺序遍历列，遇到分组的第一个列时创建分组
+        const processedGroups = new Set();
+        columns.forEach((col, index) => {
+            const group = indexToGroup.get(index);
+            if (group && !processedGroups.has(group)) {
+                // 这是分组的第一个列，创建分组
+                processedGroups.add(group);
+                const children = [];
+                group.indexes.forEach((idx) => {
+                    if (idx < columns.length) {
+                        const childCol = columns[idx];
+                        const colCopy = Object.assign({}, childCol);
+                        // 设置子列的 pin 属性
+                        if (type === 'colPinStart') {
+                            colCopy.pin = 'colPinStart';
+                        }
+                        else if (type === 'colPinEnd') {
+                            colCopy.pin = 'colPinEnd';
+                        }
+                        else {
+                            delete colCopy.pin;
+                        }
+                        // 从 dimension store 获取实时宽度
+                        if (dimensionSizes[idx] !== undefined) {
+                            colCopy.size = dimensionSizes[idx];
+                        }
+                        // 处理自动宽度列
+                        if (childCol.prop && stretchColumnProps.has(childCol.prop) && !manuallyResizedProps.has(childCol.prop)) {
+                            delete colCopy.size;
+                        }
+                        children.push(colCopy);
+                    }
+                });
+                // 创建分组列
+                if (children.length > 0) {
+                    const groupCol = {
+                        name: group.name,
+                        children: children,
+                    };
+                    // 设置分组的 pin 属性
+                    if (type === 'colPinStart') {
+                        groupCol.pin = 'colPinStart';
+                    }
+                    else if (type === 'colPinEnd') {
+                        groupCol.pin = 'colPinEnd';
+                    }
+                    result.push(groupCol);
+                }
+            }
+            else if (!group) {
+                // 不在任何分组中的列，直接添加
+                const colAny = Object.assign({}, col);
+                // 设置 pin 属性
+                if (type === 'colPinStart') {
+                    colAny.pin = 'colPinStart';
+                }
+                else if (type === 'colPinEnd') {
+                    colAny.pin = 'colPinEnd';
+                }
+                else {
+                    delete colAny.pin;
+                }
+                // 从 dimension store 获取实时宽度
+                if (dimensionSizes[index] !== undefined) {
+                    colAny.size = dimensionSizes[index];
+                }
+                // 处理自动宽度列
+                if (col.prop && stretchColumnProps.has(col.prop) && !manuallyResizedProps.has(col.prop)) {
+                    delete colAny.size;
+                }
+                result.push(colAny);
+            }
+            // 如果是分组中的非第一个列，跳过（已在分组中处理）
+        });
+    });
+    return result;
+}
+/**
+ * 合并相邻的同名编组
+ * @param columns 列数组
+ * @returns 是否发生了合并
+ *
+ * @example
+ * ```typescript
+ * const columns = [...];
+ * const hasMerged = mergeAdjacentGroups(columns);
+ * if (hasMerged) {
+ *   // 列结构已更新
+ * }
+ * ```
+ */
+function mergeAdjacentGroups(columns) {
+    if (!columns || columns.length === 0)
+        return false;
+    // 获取列或编组的实际 pin 值（编组可能在子列上有 pin）
+    const getEffectivePin = (col) => {
+        if (col.pin)
+            return col.pin;
+        if (col.children && col.children.length > 0) {
+            // 从第一个子列获取 pin
+            return col.children[0].pin;
+        }
+        return undefined;
+    };
+    let hasMerged = false;
+    let i = 0;
+    while (i < columns.length - 1) {
+        const current = columns[i];
+        const next = columns[i + 1];
+        const currentPin = getEffectivePin(current);
+        const nextPin = getEffectivePin(next);
+        // 检查是否可以合并：都是编组、名称相同、实际 pin 值相同
+        if (current.children &&
+            next.children &&
+            current.name === next.name &&
+            currentPin === nextPin) {
+            // 合并：将 next 的子列添加到 current
+            current.children.push(...next.children);
+            // 删除 next
+            columns.splice(i + 1, 1);
+            hasMerged = true;
+            // 不增加 i，继续检查当前位置
+        }
+        else {
+            i++;
+        }
+    }
+    return hasMerged;
+}
+
+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;
+}
+function cropCellToMax(cell, lastCell) {
+    const croppedCell = Object.assign({}, cell);
+    const cellCoordinates = ['x', 'y'];
+    for (const coordinate of cellCoordinates) {
+        if (cell[coordinate] < 0) {
+            croppedCell[coordinate] = 0;
+        }
+        else if (cell[coordinate] >= lastCell[coordinate]) {
+            croppedCell[coordinate] = lastCell[coordinate] - 1;
+        }
+    }
+    return croppedCell;
+}
+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;
+}
+function isRangeSingleCell(a) {
+    return a.x === a.x1 && a.y === a.y1;
+}
+
+const rowTypes = ['rowPinStart', 'rgRow', 'rowPinEnd'];
+const columnTypes = [
+    'colPinStart',
+    'rgCol',
+    'colPinEnd',
+];
+function isRowType(type) {
+    return rowTypes.indexOf(type) > -1;
+}
+
+/**
+ * Dispatches a custom event to a specified target element.
+ *
+ * @param target - The target element to dispatch the event to.
+ * @param eventName - The name of the custom event.
+ * @param detail - Optional. The detail of the custom event.
+ * @returns The custom event that was dispatched.
+ */
+function dispatch(target, eventName, detail) {
+    // Create a new CustomEvent with the specified event name and detail.
+    const event = new CustomEvent(eventName, {
+        detail,
+        cancelable: true, // Indicates whether the event can be canceled.
+        bubbles: true, // Indicates whether the event bubbles up through the DOM.
+    });
+    // Dispatch the event on the target element.
+    target === null || target === void 0 ? void 0 : target.dispatchEvent(event);
+    // Return the custom event that was dispatched.
+    return event;
+}
+/**
+ * Dispatches a custom event based on an existing event object and prevents the default behavior of the original event.
+ *
+ * @param e - The original event object containing the target and preventDefault method.
+ * @param eventName - The name of the custom event.
+ * @param detail - Optional. The detail of the custom event.
+ * @returns The custom event that was dispatched.
+ */
+function dispatchByEvent(e, // The original event object containing the target and preventDefault method.
+eventName, // The name of the custom event.
+detail) {
+    // Prevent the default behavior of the original event.
+    e.preventDefault();
+    // Dispatch the custom event to the target element specified in the original event object.
+    return dispatch(e.target, eventName, detail);
+}
+
+const GROUP_DEPTH = `${GRID_INTERNALS}-depth`;
+const PSEUDO_GROUP_ITEM = `${GRID_INTERNALS}-name`;
+const PSEUDO_GROUP_ITEM_ID = `${GRID_INTERNALS}-id`;
+const PSEUDO_GROUP_ITEM_VALUE = `${GRID_INTERNALS}-value`;
+const PSEUDO_GROUP_COLUMN = `${GRID_INTERNALS}-column`;
+const GROUP_EXPANDED = `${GRID_INTERNALS}-expanded`;
+const GROUP_COLUMN_PROP = `${GRID_INTERNALS}-prop`;
+const GROUP_ORIGINAL_INDEX = `${GRID_INTERNALS}-original-index`;
+/** 分组行包含的子行物理索引数组 */
+const GROUP_CHILDREN_INDICES = `${GRID_INTERNALS}-children`;
+const GROUP_EXPAND_BTN = `group-expand`;
+const GROUP_EXPAND_EVENT = `groupexpandclick`;
+const GROUPING_ROW_TYPE = 'rgRow';
+
+function getGroupValueDefault(item, prop) {
+    return item[prop] || null;
+}
+// get source based on proxy item collection to preserve rgRow order
+function getSource(source, items, withoutGrouping = false) {
+    let index = 0;
+    const result = {
+        source: [],
+        prevExpanded: {},
+        oldNewIndexes: {},
+    };
+    // order important here, expected parent is first, then others
+    items.forEach(i => {
+        const model = source[i];
+        if (!withoutGrouping) {
+            result.source.push(model);
+            return;
+        }
+        // grouping filter
+        if (isGrouping(model)) {
+            if (getExpanded(model)) {
+                result.prevExpanded[model[PSEUDO_GROUP_ITEM_VALUE]] = true;
+            }
+        }
+        else {
+            result.source.push(model);
+            result.oldNewIndexes[i] = index;
+            index++;
+        }
+    });
+    return result;
+}
+function getExpanded(model = {}) {
+    return model[GROUP_EXPANDED];
+}
+function flattenGroupMaps({ groupedValues, parentIds, isExpanded, itemIndex, expandedAll, prevExpanded, columnProps, }) {
+    const depth = parentIds.length;
+    const sourceWithGroups = [];
+    // collapse all groups in the beginning
+    let trimmed = {};
+    // index mapping
+    let oldNewIndexMap = {};
+    groupedValues.forEach((innerGroupedValues, groupId) => {
+        const levelIds = [...parentIds, groupId];
+        const mergedIds = levelIds.join(',');
+        // 计算分组的展开状态
+        // 关键修改：如果 prevExpanded 中有明确的状态，优先使用它
+        // 这样即使父分组折叠，子分组的展开状态也会被保留
+        let isGroupExpanded;
+        if (prevExpanded.hasOwnProperty(mergedIds)) {
+            // 如果 prevExpanded 中有明确的状态，使用它（但仍需要父分组展开）
+            isGroupExpanded = isExpanded && !!prevExpanded[mergedIds];
+        }
+        else {
+            // 否则使用 expandedAll
+            isGroupExpanded = isExpanded && !!expandedAll;
+        }
+        // 子分组的 __rvgr-expanded 属性：始终从 prevExpanded 读取，不受父分组影响
+        // 这样当父分组重新展开时，doExpand 会读取到正确的子分组状态
+        const groupExpandedProp = prevExpanded.hasOwnProperty(mergedIds)
+            ? !!prevExpanded[mergedIds]
+            : (!!expandedAll || isGroupExpanded);
+        // 记录当前分组行在 sourceWithGroups 中的索引，用于后续更新子行索引
+        const groupRowIndex = sourceWithGroups.length;
+        sourceWithGroups.push({
+            [PSEUDO_GROUP_ITEM]: groupId,
+            [GROUP_DEPTH]: depth,
+            [PSEUDO_GROUP_ITEM_ID]: JSON.stringify(levelIds),
+            [PSEUDO_GROUP_ITEM_VALUE]: mergedIds,
+            [GROUP_EXPANDED]: groupExpandedProp, // 使用新的逻辑
+            [GROUP_COLUMN_PROP]: columnProps[depth],
+            [columnProps[depth]]: groupId,
+            [GROUP_CHILDREN_INDICES]: [], // 初始化子行索引数组
+        });
+        itemIndex += 1;
+        // If parent group is collapsed, mark all items as hidden
+        if (!isExpanded && depth) {
+            trimmed[itemIndex] = true;
+        }
+        if (Array.isArray(innerGroupedValues)) {
+            // This branch handles leaf nodes (actual data items)
+            // 收集当前分组的子行物理索引
+            const childIndices = [];
+            innerGroupedValues.forEach(value => {
+                itemIndex += 1;
+                if (!isGroupExpanded) {
+                    trimmed[itemIndex] = true; // Mark items as hidden if group is collapsed
+                }
+                oldNewIndexMap[value[GROUP_ORIGINAL_INDEX]] = itemIndex; // Keep track of new positions
+                childIndices.push(itemIndex); // 记录子行的新索引
+            });
+            // 更新分组行的子行索引
+            sourceWithGroups[groupRowIndex][GROUP_CHILDREN_INDICES] = childIndices;
+            sourceWithGroups.push(...innerGroupedValues);
+        }
+        else {
+            // This branch handles nested groups (further subgroups)
+            const children = flattenGroupMaps({
+                groupedValues: innerGroupedValues,
+                parentIds: levelIds,
+                isExpanded: isGroupExpanded,
+                itemIndex,
+                expandedAll,
+                prevExpanded,
+                columnProps,
+            }); // Recursively process subgroups
+            // 收集所有嵌套子分组中的数据行索引
+            const nestedChildIndices = [];
+            children.source.forEach(item => {
+                // 如果是数据行（非分组行），收集其索引
+                if (typeof item[PSEUDO_GROUP_ITEM] === 'undefined') {
+                    const newIndex = children.oldNewIndexMap[item[GROUP_ORIGINAL_INDEX]];
+                    if (newIndex !== undefined) {
+                        nestedChildIndices.push(newIndex);
+                    }
+                }
+            });
+            // 更新分组行的子行索引
+            sourceWithGroups[groupRowIndex][GROUP_CHILDREN_INDICES] = nestedChildIndices;
+            sourceWithGroups.push(...children.source);
+            trimmed = Object.assign(Object.assign({}, children.trimmed), trimmed);
+            oldNewIndexMap = Object.assign(Object.assign({}, children.oldNewIndexMap), oldNewIndexMap);
+            itemIndex = children.itemIndex;
+        }
+    });
+    return {
+        source: sourceWithGroups,
+        oldNewIndexMap,
+        trimmed,
+        itemIndex,
+    };
+}
+/**
+ * Gather data for grouping
+ * @param array - flat data array
+ * @param columnProps - ids of groups
+ * @param expanded - potentially expanded items if present
+ */
+function gatherGrouping(array, columnProps, { prevExpanded = {}, expandedAll = false, getGroupValue = getGroupValueDefault, }) {
+    const groupedItems = new Map();
+    array.forEach((item, originalIndex) => {
+        const groupLevelValues = columnProps.map(groupId => getGroupValue(item, groupId));
+        const lastLevelValue = groupLevelValues.pop();
+        let currentGroupLevel = groupedItems;
+        groupLevelValues.forEach(value => {
+            if (!currentGroupLevel.has(value)) {
+                currentGroupLevel.set(value, new Map());
+            }
+            currentGroupLevel = currentGroupLevel.get(value);
+        });
+        if (!currentGroupLevel.has(lastLevelValue)) {
+            const groupItems = [];
+            currentGroupLevel.set(lastLevelValue, groupItems);
+        }
+        const lastLevelItems = currentGroupLevel.get(lastLevelValue);
+        lastLevelItems.push(Object.assign(Object.assign({}, item), { [GROUP_ORIGINAL_INDEX]: originalIndex }));
+    });
+    const groupingDepth = columnProps.length;
+    const { source: sourceWithGroups, trimmed, oldNewIndexMap } = flattenGroupMaps({
+        groupedValues: groupedItems,
+        parentIds: [],
+        isExpanded: true,
+        itemIndex: -1,
+        expandedAll,
+        prevExpanded,
+        columnProps
+    });
+    return {
+        sourceWithGroups, // updates source mirror
+        depth: groupingDepth, // largest depth for grouping
+        trimmed, // used for expand/collapse grouping values
+        oldNewIndexMap, // used for mapping old values to new
+    };
+}
+function getGroupingName(rgRow) {
+    return rgRow === null || rgRow === void 0 ? void 0 : rgRow[PSEUDO_GROUP_ITEM];
+}
+function isGrouping(rgRow) {
+    return typeof (rgRow === null || rgRow === void 0 ? void 0 : rgRow[PSEUDO_GROUP_ITEM]) !== 'undefined';
+}
+function isGroupingColumn(column) {
+    return typeof (column === null || column === void 0 ? void 0 : column[PSEUDO_GROUP_COLUMN]) !== 'undefined';
+}
+function measureEqualDepth(groupA, groupB) {
+    const ln = groupA.length;
+    let i = 0;
+    for (; i < ln; i++) {
+        if (groupA[i] !== groupB[i]) {
+            return i;
+        }
+    }
+    return i;
+}
+function getParsedGroup(id) {
+    const parseGroup = JSON.parse(id);
+    // extra precaution and type safeguard
+    if (!Array.isArray(parseGroup)) {
+        return null;
+    }
+    return parseGroup;
+}
+// check if items is child of current clicked group
+function isSameGroup(currentGroup, currentModel, nextModel) {
+    const nextGroup = getParsedGroup(nextModel[PSEUDO_GROUP_ITEM_ID]);
+    if (!nextGroup) {
+        return false;
+    }
+    const depth = measureEqualDepth(currentGroup, nextGroup);
+    return currentModel[GROUP_DEPTH] < depth;
+}
+
+/**
+ * The base implementation of `_.slice` without an iteratee call guard.
+ *
+ * @private
+ * @param {Array} array The array to slice.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the slice of `array`.
+ */
+function baseSlice(array, start, end) {
+  var index = -1,
+      length = array.length;
+
+  if (start < 0) {
+    start = -start > length ? 0 : (length + start);
+  }
+  end = end > length ? length : end;
+  if (end < 0) {
+    end += length;
+  }
+  length = start > end ? 0 : ((end - start) >>> 0);
+  start >>>= 0;
+
+  var result = Array(length);
+  while (++index < length) {
+    result[index] = array[index + start];
+  }
+  return result;
+}
+
+/**
+ * Creates a slice of `array` from `start` up to, but not including, `end`.
+ *
+ * **Note:** This method is used instead of
+ * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
+ * returned.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to slice.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the slice of `array`.
+ */
+function slice(array, start, end) {
+  var length = array == null ? 0 : array.length;
+  if (!length) {
+    return [];
+  }
+  if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
+    start = 0;
+    end = length;
+  }
+  else {
+    start = start == null ? 0 : toInteger(start);
+    end = end === undefined ? length : toInteger(end);
+  }
+  return baseSlice(array, start, end);
+}
+
+function getCellEditor(column, editors = {}) {
+    const editor = column === null || column === void 0 ? void 0 : column.editor;
+    if (!editor) {
+        return undefined;
+    }
+    // reference
+    if (typeof editor === 'string') {
+        return editors[editor];
+    }
+    return editor;
+}
+class ColumnService {
+    get columns() {
+        if (this.overrideColumns) {
+            return this.overrideColumns;
+        }
+        const source = this.source.get('source');
+        const items = this.source.get('items');
+        if (!items.length) {
+            return [];
+        }
+        return items.map(v => source[v]);
+    }
+    setOverrideColumns(columns) {
+        this.overrideColumns = columns;
+    }
+    constructor(dataStore, source) {
+        this.dataStore = dataStore;
+        this.source = source;
+        this.unsubscribe = [];
+        this.loggedMissingCols = new Set();
+        this.overrideColumns = null;
+        this.hasGrouping = false;
+        this.unsubscribe.push(source.onChange('source', s => this.checkGrouping(s)));
+        this.checkGrouping(source.get('source'));
+        this.type = source.get('type');
+    }
+    getColumnByIndex(colIndex) {
+        if (this.overrideColumns) {
+            return this.overrideColumns[colIndex];
+        }
+        const direct = getSourceItem(this.source, colIndex);
+        if (direct) {
+            return direct;
+        }
+        const key = `${this.type}:${colIndex}`;
+        if (!this.loggedMissingCols.has(key)) {
+            this.loggedMissingCols.add(key);
+            const items = this.source.get('items');
+            const source = this.source.get('source');
+            console.warn('[column] missing column by index', {
+                colType: this.type,
+                colIndex,
+                itemsLength: items.length,
+                sourceLength: source.length,
+                itemsHead: items.slice(0, 10),
+            });
+        }
+        const columns = this.columns;
+        if (columns.length) {
+            return columns[0];
+        }
+        return this.source.get('source')[0];
+    }
+    checkGrouping(cols) {
+        for (let rgCol of cols) {
+            if (isGroupingColumn(rgCol)) {
+                this.hasGrouping = true;
+                return;
+            }
+            this.hasGrouping = false;
+        }
+    }
+    isReadOnly(r, c) {
+        var _a;
+        const readOnly = (_a = this.getColumnByIndex(c)) === null || _a === void 0 ? void 0 : _a.readonly;
+        if (typeof readOnly === 'function') {
+            const data = this.rowDataModel(r, c);
+            return readOnly(data);
+        }
+        return !!readOnly;
+    }
+    mergeProperties(r, c, defaultProps, schemaModel) {
+        var _a, _b;
+        const props = Object.assign({}, defaultProps);
+        props.class = Object.assign(Object.assign({}, (typeof props.class === 'string'
+            ? { [props.class]: true }
+            : props.class)), { [CELL_CLASS]: true, [DISABLED_CLASS]: this.isReadOnly(r, c) });
+        const extra = (_b = (_a = schemaModel.column) === null || _a === void 0 ? void 0 : _a.cellProperties) === null || _b === void 0 ? void 0 : _b.call(_a, schemaModel);
+        if (!extra) {
+            return props;
+        }
+        return doPropMerge(props, extra);
+    }
+    getRowClass(r, prop) {
+        const model = getSourceItem(this.dataStore, r) || {};
+        return model[prop] || '';
+    }
+    getSaveData(rowIndex, colIndex, val) {
+        const data = this.rowDataModel(rowIndex, colIndex);
+        if (typeof val === 'undefined') {
+            val = getCellData(data.value);
+        }
+        return Object.assign(Object.assign({}, data), { val });
+    }
+    /**
+     * Get cell data model for given rowIndex and colIndex
+     * Used to pass data to editor/renderer
+     */
+    rowDataModel(rowIndex, colIndex) {
+        const column = this.getColumnByIndex(colIndex);
+        const prop = column.prop;
+        const model = getSourceItem(this.dataStore, rowIndex) || {};
+        const type = this.dataStore.get('type');
+        return {
+            prop,
+            model,
+            data: this.dataStore.get('source'),
+            column,
+            rowIndex,
+            colIndex,
+            colType: this.type,
+            type,
+            value: getCellRaw(model, column),
+        };
+    }
+    getRangeData(d, columns) {
+        var _a;
+        const changed = {};
+        // get original length sizes
+        const copyColLength = d.oldRange.x1 - d.oldRange.x + 1;
+        const copyRowLength = d.oldRange.y1 - d.oldRange.y + 1;
+        const mapping = {};
+        // rows
+        for (let rowIndex = d.newRange.y, i = 0; rowIndex < d.newRange.y1 + 1; rowIndex++, i++) {
+            // copy original data link
+            const oldRowIndex = d.oldRange.y + (i % copyRowLength);
+            const copyRow = getSourceItem(this.dataStore, oldRowIndex) || {};
+            // columns
+            for (let colIndex = d.newRange.x, j = 0; colIndex < d.newRange.x1 + 1; colIndex++, j++) {
+                // check if old range area
+                if (rowIndex >= d.oldRange.y &&
+                    rowIndex <= d.oldRange.y1 &&
+                    colIndex >= d.oldRange.x &&
+                    colIndex <= d.oldRange.x1) {
+                    continue;
+                }
+                // requested column beyond range
+                if (!this.columns[colIndex]) {
+                    continue;
+                }
+                const prop = (_a = this.columns[colIndex]) === null || _a === void 0 ? void 0 : _a.prop;
+                const copyColIndex = d.oldRange.x + (j % copyColLength);
+                const copyColumnProp = columns[copyColIndex].prop;
+                /** if can write */
+                if (!this.isReadOnly(rowIndex, colIndex)) {
+                    /** to show before save */
+                    if (!changed[rowIndex]) {
+                        changed[rowIndex] = {};
+                    }
+                    changed[rowIndex][prop] = copyRow[copyColumnProp];
+                    /** Generate mapping object */
+                    if (!mapping[rowIndex]) {
+                        mapping[rowIndex] = {};
+                    }
+                    mapping[rowIndex][prop] = {
+                        colIndex: copyColIndex,
+                        colProp: copyColumnProp,
+                        rowIndex: oldRowIndex,
+                    };
+                }
+            }
+        }
+        return {
+            changed,
+            mapping,
+        };
+    }
+    getTransformedDataToApply(start, data) {
+        const changed = {};
+        const copyRowLength = data.length;
+        const colLength = this.columns.length;
+        const rowLength = this.dataStore.get('items').length;
+        // rows
+        let rowIndex = start.y;
+        let maxCol = 0;
+        for (let i = 0; rowIndex < rowLength && i < copyRowLength; rowIndex++, i++) {
+            // copy original data link
+            const copyRow = data[i % copyRowLength];
+            const copyColLength = (copyRow === null || copyRow === void 0 ? void 0 : copyRow.length) || 0;
+            // columns
+            let colIndex = start.x;
+            for (let j = 0; colIndex < colLength && j < copyColLength; colIndex++, j++) {
+                const p = this.columns[colIndex].prop;
+                const currentCol = j % colLength;
+                /** if can write */
+                if (!this.isReadOnly(rowIndex, colIndex)) {
+                    /** to show before save */
+                    if (!changed[rowIndex]) {
+                        changed[rowIndex] = {};
+                    }
+                    changed[rowIndex][p] = copyRow[currentCol];
+                }
+            }
+            maxCol = Math.max(maxCol, colIndex - 1);
+        }
+        const range = getRange(start, {
+            y: rowIndex - 1,
+            x: maxCol,
+        });
+        return {
+            changed,
+            range,
+        };
+    }
+    getRangeStaticData(d, value) {
+        const changed = {};
+        // rows
+        for (let rowIndex = d.y, i = 0; rowIndex < d.y1 + 1; rowIndex++, i++) {
+            // columns
+            for (let colIndex = d.x, j = 0; colIndex < d.x1 + 1; colIndex++, j++) {
+                // requested column beyond range
+                if (!this.columns[colIndex]) {
+                    continue;
+                }
+                const p = this.columns[colIndex].prop;
+                /** if can write */
+                if (!this.isReadOnly(rowIndex, colIndex)) {
+                    /** to show before save */
+                    if (!changed[rowIndex]) {
+                        changed[rowIndex] = {};
+                    }
+                    changed[rowIndex][p] = value;
+                }
+            }
+        }
+        return changed;
+    }
+    getRangeTransformedToProps(d, store) {
+        var _a;
+        const area = [];
+        const type = this.dataStore.get('type');
+        // rows
+        for (let rowIndex = d.y, i = 0; rowIndex < d.y1 + 1; rowIndex++, i++) {
+            // columns
+            for (let colIndex = d.x, j = 0; colIndex < d.x1 + 1; colIndex++, j++) {
+                const prop = (_a = this.columns[colIndex]) === null || _a === void 0 ? void 0 : _a.prop;
+                area.push({
+                    prop,
+                    rowIndex,
+                    colIndex,
+                    model: getSourceItem(store, rowIndex),
+                    type,
+                    colType: this.type,
+                });
+            }
+        }
+        return area;
+    }
+    copyRangeArray(range, store) {
+        const cols = [...this.columns];
+        const props = slice(cols, range.x, range.x1 + 1).map(v => v.prop);
+        const toCopy = [];
+        const mapping = {};
+        // rows indexes
+        for (let i = range.y; i <= range.y1; i++) {
+            const rgRow = [];
+            mapping[i] = {};
+            // columns indexes
+            for (let prop of props) {
+                const item = getSourceItem(store, i);
+                // if no item - skip
+                if (!item) {
+                    continue;
+                }
+                const val = item[prop];
+                rgRow.push(val);
+                mapping[i][prop] = val;
+            }
+            toCopy.push(rgRow);
+        }
+        return {
+            data: toCopy,
+            mapping,
+        };
+    }
+    destroy() {
+        this.unsubscribe.forEach(f => f());
+    }
+}
+/**
+ * Checks if the given rowDrag is a service for dragging rows.
+ */
+function isRowDragService(rowDrag, model) {
+    if (typeof rowDrag === 'function') {
+        return rowDrag(model);
+    }
+    return !!rowDrag;
+}
+function mergeClasses(class1 = {}, class2 = {}) {
+    if (typeof class1 === 'string') {
+        class1 = { [class1]: true };
+    }
+    if (typeof class2 === 'string') {
+        class2 = { [class2]: true };
+    }
+    return Object.assign(Object.assign({}, class1), class2);
+}
+function doPropMerge(existing, extra) {
+    // if className is provided - remove it from props it messing with stencil
+    if (extra.className) {
+        extra.class = mergeClasses(extra.class, extra.className);
+        delete extra.className;
+    }
+    let props = Object.assign(Object.assign({}, extra), existing);
+    // extend existing props
+    if (extra.class) {
+        props.class = mergeClasses(props.class, extra.class);
+    }
+    if (extra.style) {
+        props.style = Object.assign(Object.assign({}, extra.style), props.style);
+    }
+    return props;
+}
+
+var ResizeEvents;
+(function (ResizeEvents) {
+    ResizeEvents["start"] = "resize:start";
+    ResizeEvents["move"] = "resize:move";
+    ResizeEvents["end"] = "resize:end";
+})(ResizeEvents || (ResizeEvents = {}));
+const RESIZE_MASK = {
+    'resizable-r': { bit: 0b0001, cursor: 'col-resize' },
+    'resizable-rb': { bit: 0b0011, cursor: 'se-resize' },
+    'resizable-b': { bit: 0b0010, cursor: 's-resize' },
+    'resizable-lb': { bit: 0b0110, cursor: 'sw-resize' },
+    'resizable-l': { bit: 0b0100, cursor: 'w-resize' },
+    'resizable-lt': { bit: 0b1100, cursor: 'nw-resize' },
+    'resizable-t': { bit: 0b1000, cursor: 'n-resize' },
+    'resizable-rt': { bit: 0b1001, cursor: 'ne-resize' },
+};
+const DISABLE_MASK = {
+    w: 0b0100,
+    h: 0b1000,
+};
+const defaultProps = (props) => {
+    return Object.assign(Object.assign({}, props), { fitParent: props.fitParent || false, active: props.active || [], disableAttributes: props.disableAttributes || [], minWidth: props.minWidth || 0, minHeight: props.minHeight || 0 });
+};
+class ResizeDirective {
+    constructor(initialProps, $event) {
+        var _a, _b;
+        this.initialProps = initialProps;
+        this.$event = $event;
+        this.startMouseX = 0; // 记录拖拽开始时的鼠标位置
+        this.startMouseY = 0;
+        this.width = 0;
+        this.height = 0;
+        this.changeX = 0;
+        this.changeY = 0;
+        this.disableCalcMap = 0b1111;
+        this.props = defaultProps(initialProps);
+        this.mouseMoveFunc = this.handleMove.bind(this);
+        this.mouseUpFunc = this.handleUp.bind(this);
+        this.handleRightClickFunc = this.handleRightClick.bind(this);
+        this.handleContextMenuFunc = this.handleContextMenu.bind(this);
+        this.minW = this.props.minWidth;
+        this.minH = this.props.minHeight;
+        this.maxW = (_a = this.props.maxWidth) !== null && _a !== void 0 ? _a : 0;
+        this.maxH = (_b = this.props.maxHeight) !== null && _b !== void 0 ? _b : 0;
+        this.parent = { width: 0, height: 0 };
+        this.resizeState = 0;
+    }
+    set($el) {
+        this.$el = $el;
+        this.props.disableAttributes.forEach(attr => {
+            switch (attr) {
+                case 'l':
+                    this.disableCalcMap &= -2;
+                    break;
+                case 't':
+                    this.disableCalcMap &= -3;
+                    break;
+                case 'w':
+                    this.disableCalcMap &= -5;
+                    break;
+                case 'h':
+                    this.disableCalcMap &= -9;
+            }
+        });
+    }
+    emitEvent(eventName, additionalOptions) {
+        var _a;
+        if (!this.$event) {
+            return;
+        }
+        const isLeft = (_a = this.activeResizer) === null || _a === void 0 ? void 0 : _a.classList.contains('resizable-l');
+        this.$event(Object.assign({ eventName, width: this.width + this.changeX * (isLeft ? -1 : 1), height: this.height + this.changeY, changedX: this.changeX, changedY: this.changeY }, additionalOptions));
+    }
+    static isTouchEvent(e) {
+        var _a;
+        const event = e;
+        return ((_a = event.touches) === null || _a === void 0 ? void 0 : _a.length) >= 0;
+    }
+    handleMove(event) {
+        var _a;
+        if (!this.resizeState) {
+            return;
+        }
+        let eventY, eventX;
+        if (ResizeDirective.isTouchEvent(event)) {
+            eventY = event.touches[0].clientY;
+            eventX = event.touches[0].clientX;
+        }
+        else {
+            eventY = event.clientY;
+            eventX = event.clientX;
+        }
+        let isX = this.resizeState & RESIZE_MASK['resizable-r'].bit ||
+            this.resizeState & RESIZE_MASK['resizable-l'].bit;
+        let isY = this.resizeState & RESIZE_MASK['resizable-t'].bit ||
+            this.resizeState & RESIZE_MASK['resizable-b'].bit;
+        if (isY && this.disableCalcMap & DISABLE_MASK.h) {
+            // 使用绝对位置计算，避免累加误差
+            const totalDiffY = eventY - this.startMouseY;
+            let changedY = totalDiffY;
+            const newHeight = this.height + changedY;
+            // if overcrossed min height
+            if (newHeight < this.minH) {
+                changedY = -(this.height - this.minH);
+            }
+            // if overcrossed max heiht
+            if (this.maxH && newHeight > this.maxH) {
+                changedY = this.maxH - this.height;
+            }
+            this.changeY = changedY;
+            if (this.activeResizer) {
+                this.activeResizer.style.bottom = `${-this.changeY}px`;
+            }
+        }
+        if (isX && this.disableCalcMap & DISABLE_MASK.w) {
+            const isLeft = (_a = this.activeResizer) === null || _a === void 0 ? void 0 : _a.classList.contains('resizable-l');
+            // 使用绝对位置计算，避免累加误差
+            const totalDiffX = eventX - this.startMouseX;
+            let changedX = totalDiffX;
+            const newWidth = this.width + changedX * (isLeft ? -1 : 1);
+            // if overcrossed min width
+            if (newWidth < this.minW) {
+                changedX = -(this.width - this.minW) * (isLeft ? -1 : 1);
+            }
+            // if overcrossed max width
+            if (this.maxW && newWidth > this.maxW) {
+                changedX = (this.maxW - this.width) * (isLeft ? 1 : 1);
+            }
+            this.changeX = changedX;
+            if (this.activeResizer) {
+                if (!isLeft) {
+                    this.activeResizer.style.right = `${-this.changeX}px`;
+                }
+                else {
+                    this.activeResizer.style.left = `${this.changeX}px`;
+                }
+            }
+        }
+        this.emitEvent(ResizeEvents.move);
+    }
+    handleDown(event) {
+        if (event.defaultPrevented) {
+            return;
+        }
+        // 右键不触发拖拽
+        if (!ResizeDirective.isTouchEvent(event) && event.button !== 0) {
+            return;
+        }
+        // stop other events if resize in progress
+        event.preventDefault();
+        this.dropInitial();
+        for (let elClass in RESIZE_MASK) {
+            const target = event.target;
+            if (this.$el.contains(target) && (target === null || target === void 0 ? void 0 : target.classList.contains(elClass))) {
+                document.body.style.cursor = RESIZE_MASK[elClass].cursor;
+                if (ResizeDirective.isTouchEvent(event)) {
+                    this.setInitials(event.touches[0], target);
+                }
+                else {
+                    event.preventDefault && event.preventDefault();
+                    this.setInitials(event, target);
+                }
+                this.resizeState = RESIZE_MASK[elClass].bit;
+                const eventName = ResizeEvents.start;
+                this.emitEvent(eventName);
+                break;
+            }
+        }
+        this.bindMove();
+    }
+    handleUp(e) {
+        e.preventDefault();
+        if (this.resizeState !== 0) {
+            this.resizeState = 0;
+            document.body.style.cursor = '';
+            // 只有当宽度实际发生变化时才触发 resize:end 事件
+            // 允许 1px 的误差，避免微小的抖动触发调整
+            if (Math.abs(this.changeX) > 1 || Math.abs(this.changeY) > 1) {
+                const eventName = ResizeEvents.end;
+                this.emitEvent(eventName);
+            }
+        }
+        this.dropInitial();
+        this.unbindMove();
+    }
+    setInitials({ clientX, clientY }, target) {
+        var _a, _b, _c, _d;
+        const computedStyle = getComputedStyle(this.$el);
+        this.$el.classList.add('active');
+        this.activeResizer = target;
+        if (this.disableCalcMap & DISABLE_MASK.w) {
+            this.startMouseX = clientX; // 记录初始鼠标位置
+            this.width = this.$el.clientWidth;
+            this.parent.width = (_b = (_a = this.$el.parentElement) === null || _a === void 0 ? void 0 : _a.clientWidth) !== null && _b !== void 0 ? _b : 0;
+            // min width: 需要考虑 padding 和 border
+            const minPaddingX = parseFloat(computedStyle.paddingLeft) +
+                parseFloat(computedStyle.paddingRight);
+            const minBorderX = parseFloat(computedStyle.borderLeftWidth) +
+                parseFloat(computedStyle.borderRightWidth);
+            this.minW = Math.max(minPaddingX + minBorderX, this.initialProps.minWidth || 0);
+            // max width
+            if (this.initialProps.maxWidth) {
+                this.maxW = Math.max(this.width, this.initialProps.maxWidth);
+            }
+        }
+        if (this.disableCalcMap & DISABLE_MASK.h) {
+            this.startMouseY = clientY; // 记录初始鼠标位置
+            this.height = this.$el.clientHeight;
+            this.parent.height = (_d = (_c = this.$el.parentElement) === null || _c === void 0 ? void 0 : _c.clientHeight) !== null && _d !== void 0 ? _d : 0;
+            // min height
+            const minPaddingY = parseFloat(computedStyle.paddingTop) +
+                parseFloat(computedStyle.paddingBottom);
+            this.minH = Math.max(minPaddingY, this.initialProps.minHeight || 0);
+            // max height
+            if (this.initialProps.maxHeight) {
+                this.maxH = Math.max(this.height, this.initialProps.maxHeight);
+            }
+        }
+    }
+    dropInitial() {
+        this.changeX = this.changeY = this.minW = this.minH;
+        this.width = this.height = 0;
+        if (this.activeResizer) {
+            this.activeResizer.removeAttribute('style');
+        }
+        this.$el.classList.remove('active');
+        this.activeResizer = undefined;
+    }
+    bindMove() {
+        document.documentElement.addEventListener('mouseup', this.mouseUpFunc, true);
+        document.documentElement.addEventListener('touchend', this.mouseUpFunc, true);
+        document.documentElement.addEventListener('mousemove', this.mouseMoveFunc, true);
+        document.documentElement.addEventListener('touchmove', this.mouseMoveFunc, true);
+        document.documentElement.addEventListener('mouseleave', this.mouseUpFunc);
+        // 右键按下时取消拖拽
+        document.documentElement.addEventListener('mousedown', this.handleRightClickFunc, true);
+        document.documentElement.addEventListener('contextmenu', this.handleContextMenuFunc, true);
+    }
+    unbindMove() {
+        document.documentElement.removeEventListener('mouseup', this.mouseUpFunc, true);
+        document.documentElement.removeEventListener('touchend', this.mouseUpFunc, true);
+        document.documentElement.removeEventListener('mousemove', this.mouseMoveFunc, true);
+        document.documentElement.removeEventListener('touchmove', this.mouseMoveFunc, true);
+        document.documentElement.removeEventListener('mouseleave', this.mouseUpFunc);
+        document.documentElement.removeEventListener('mousedown', this.handleRightClickFunc, true);
+        document.documentElement.removeEventListener('contextmenu', this.handleContextMenuFunc, true);
+    }
+    // 右键按下时取消拖拽
+    handleRightClick(e) {
+        if (e.button === 2 && this.resizeState !== 0) {
+            e.preventDefault();
+            this.cancelResize();
+        }
+    }
+    // 阻止右键菜单
+    handleContextMenu(e) {
+        if (this.resizeState !== 0) {
+            e.preventDefault();
+        }
+    }
+    // 取消拖拽（不触发 resize:end 事件）
+    cancelResize() {
+        this.resizeState = 0;
+        document.body.style.cursor = '';
+        this.dropInitial();
+        this.unbindMove();
+    }
+}
+
+const ResizableElement = (props, children) => {
+    const resizeEls = [];
+    const directive = (props.canResize &&
+        new ResizeDirective(props, e => {
+            var _a;
+            if (e.eventName === ResizeEvents.end) {
+                (_a = props.onResize) === null || _a === void 0 ? void 0 : _a.call(props, e);
+            }
+        })) ||
+        null;
+    if (props.active) {
+        if (props.canResize) {
+            for (let p in props.active) {
+                resizeEls.push(h("div", { onClick: e => e.preventDefault(), onDblClick: e => {
+                        e.preventDefault();
+                        e.stopPropagation();
+                    }, onMouseDown: (e) => directive === null || directive === void 0 ? void 0 : directive.handleDown(e), onTouchStart: (e) => directive === null || directive === void 0 ? void 0 : directive.handleDown(e), class: `resizable resizable-${props.active[p]}` }));
+            }
+        }
+        else {
+            for (let _p in props.active) {
+                resizeEls.push(h("div", { onClick: e => e.preventDefault(), onTouchStart: (e) => e.preventDefault(), onDblClick: e => {
+                        e.preventDefault();
+                        e.stopPropagation();
+                    }, class: `no-resize` }));
+            }
+        }
+    }
+    return (h("div", Object.assign({}, props, { ref: e => e && (directive === null || directive === void 0 ? void 0 : directive.set(e)) }),
+        children,
+        resizeEls));
+};
+
+const ON_COLUMN_CLICK = 'columnclick';
+const HEADER_NOT_DRAGGABLE_CLASS = 'rgHeaderCell-not-draggable';
+const HeaderCellRenderer = ({ data, props, additionalData }, children) => {
+    let colTemplate = (data === null || data === void 0 ? void 0 : data.name) || '';
+    let cellProps = props;
+    if (data === null || data === void 0 ? void 0 : data.columnTemplate) {
+        colTemplate = data.columnTemplate(h, data, additionalData);
+    }
+    if (data === null || data === void 0 ? void 0 : data.columnProperties) {
+        const extra = data.columnProperties(data);
+        if (extra) {
+            cellProps = doPropMerge(props, extra);
+        }
+    }
+    // 添加 data-draggable 属性
+    const dataAny = data;
+    const isDraggable = (dataAny === null || dataAny === void 0 ? void 0 : dataAny.draggable) !== false;
+    const mergedClass = typeof cellProps.class === 'string'
+        ? { [cellProps.class]: true }
+        : (cellProps.class || {});
+    const draggableClass = Object.assign(Object.assign({}, mergedClass), { [HEADER_NOT_DRAGGABLE_CLASS]: !isDraggable });
+    const resizeProps = Object.assign(Object.assign({}, cellProps), { class: draggableClass, 'data-draggable': isDraggable ? 'true' : 'false', onMouseDown(e) {
+            dispatch(e.currentTarget, ON_COLUMN_CLICK, {
+                data,
+                event: e,
+            });
+        } });
+    // 为 header-content 准备属性
+    const headerContentProps = {};
+    // 如果配置了 tooltip，添加 data-tooltip 属性
+    if (dataAny === null || dataAny === void 0 ? void 0 : dataAny.tooltip) {
+        headerContentProps['data-tooltip'] = dataAny.tooltip;
+    }
+    // 如果没有配置 tooltip 但有 name，默认使用 name 作为 tooltip
+    else if ((data === null || data === void 0 ? void 0 : data.name) && typeof data.name === 'string') {
+        headerContentProps['data-tooltip'] = data.name;
+    }
+    if (data === null || data === void 0 ? void 0 : data.uniqueId)
+        headerContentProps['revo-grid-uid'] = data.uniqueId;
+    return (h(ResizableElement, Object.assign({}, resizeProps),
+        h("div", Object.assign({ class: "header-content" }, headerContentProps), colTemplate),
+        children));
+};
+
+export { isGrouping as A, isGroupingColumn as B, measureEqualDepth as C, getParsedGroup as D, isSameGroup as E, getCellData as F, GROUP_DEPTH as G, getCellRaw as H, getCellDataParsed as I, getColumnType as J, getColumnSizes as K, isColGrouping as L, getColumns as M, gatherGroup as N, getColumnByProp as O, PSEUDO_GROUP_ITEM as P, reduce as Q, baseEach as R, toInteger as S, ON_COLUMN_CLICK as T, ColumnService as U, getCellEditor as V, isRowDragService as W, HeaderCellRenderer as X, columnTypes as a, cropCellToMax as b, convertCollectionToColumns as c, dispatch as d, getRange as e, isRangeSingleCell as f, getStretchColumnOptions as g, dispatchByEvent as h, isRowType as i, PSEUDO_GROUP_ITEM_ID as j, PSEUDO_GROUP_ITEM_VALUE as k, PSEUDO_GROUP_COLUMN as l, mergeAdjacentGroups as m, nextCell as n, GROUP_EXPANDED as o, GROUP_COLUMN_PROP as p, GROUP_ORIGINAL_INDEX as q, rowTypes as r, GROUP_CHILDREN_INDICES as s, GROUP_EXPAND_BTN as t, GROUP_EXPAND_EVENT as u, GROUPING_ROW_TYPE as v, getSource as w, getExpanded as x, gatherGrouping as y, getGroupingName as z };
+//# sourceMappingURL=header-cell-renderer-BVHTuFGE.js.map
+
+//# sourceMappingURL=header-cell-renderer-BVHTuFGE.js.map