balala-revogrid 1.0.0

package/dist/cjs/header-cell-renderer-D-RjAVfe.js

@@ -0,0 +1,1766 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+'use strict';
+
+var index = require('./index-BF1c1pO3.js');
+var dimension_helpers = require('./dimension.helpers-DA9-xqPT.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 = dimension_helpers.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, dimension_helpers.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 (!dimension_helpers.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 = dimension_helpers.isArray(collection) ? arrayReduce : baseReduce,
+      initAccum = arguments.length < 3;
+
+  return func(collection, dimension_helpers.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 (dimension_helpers.isArray(resultItem) && dimension_helpers.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 = `${dimension_helpers.GRID_INTERNALS}-depth`;
+const PSEUDO_GROUP_ITEM = `${dimension_helpers.GRID_INTERNALS}-name`;
+const PSEUDO_GROUP_ITEM_ID = `${dimension_helpers.GRID_INTERNALS}-id`;
+const PSEUDO_GROUP_ITEM_VALUE = `${dimension_helpers.GRID_INTERNALS}-value`;
+const PSEUDO_GROUP_COLUMN = `${dimension_helpers.GRID_INTERNALS}-column`;
+const GROUP_EXPANDED = `${dimension_helpers.GRID_INTERNALS}-expanded`;
+const GROUP_COLUMN_PROP = `${dimension_helpers.GRID_INTERNALS}-prop`;
+const GROUP_ORIGINAL_INDEX = `${dimension_helpers.GRID_INTERNALS}-original-index`;
+/** 分组行包含的子行物理索引数组 */
+const GROUP_CHILDREN_INDICES = `${dimension_helpers.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' && dimension_helpers.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 = dimension_helpers.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)), { [dimension_helpers.CELL_CLASS]: true, [dimension_helpers.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 = dimension_helpers.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 = dimension_helpers.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 = dimension_helpers.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: dimension_helpers.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 = dimension_helpers.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(index.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(index.h("div", { onClick: e => e.preventDefault(), onTouchStart: (e) => e.preventDefault(), onDblClick: e => {
+                        e.preventDefault();
+                        e.stopPropagation();
+                    }, class: `no-resize` }));
+            }
+        }
+    }
+    return (index.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(index.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 (index.h(ResizableElement, Object.assign({}, resizeProps),
+        index.h("div", Object.assign({ class: "header-content" }, headerContentProps), colTemplate),
+        children));
+};
+
+exports.ColumnService = ColumnService;
+exports.GROUPING_ROW_TYPE = GROUPING_ROW_TYPE;
+exports.GROUP_CHILDREN_INDICES = GROUP_CHILDREN_INDICES;
+exports.GROUP_COLUMN_PROP = GROUP_COLUMN_PROP;
+exports.GROUP_DEPTH = GROUP_DEPTH;
+exports.GROUP_EXPANDED = GROUP_EXPANDED;
+exports.GROUP_EXPAND_BTN = GROUP_EXPAND_BTN;
+exports.GROUP_EXPAND_EVENT = GROUP_EXPAND_EVENT;
+exports.GROUP_ORIGINAL_INDEX = GROUP_ORIGINAL_INDEX;
+exports.HeaderCellRenderer = HeaderCellRenderer;
+exports.ON_COLUMN_CLICK = ON_COLUMN_CLICK;
+exports.PSEUDO_GROUP_COLUMN = PSEUDO_GROUP_COLUMN;
+exports.PSEUDO_GROUP_ITEM = PSEUDO_GROUP_ITEM;
+exports.PSEUDO_GROUP_ITEM_ID = PSEUDO_GROUP_ITEM_ID;
+exports.PSEUDO_GROUP_ITEM_VALUE = PSEUDO_GROUP_ITEM_VALUE;
+exports.baseEach = baseEach;
+exports.columnTypes = columnTypes;
+exports.convertCollectionToColumns = convertCollectionToColumns;
+exports.cropCellToMax = cropCellToMax;
+exports.dispatch = dispatch;
+exports.dispatchByEvent = dispatchByEvent;
+exports.gatherGroup = gatherGroup;
+exports.gatherGrouping = gatherGrouping;
+exports.getCellData = getCellData;
+exports.getCellDataParsed = getCellDataParsed;
+exports.getCellEditor = getCellEditor;
+exports.getCellRaw = getCellRaw;
+exports.getColumnByProp = getColumnByProp;
+exports.getColumnSizes = getColumnSizes;
+exports.getColumnType = getColumnType;
+exports.getColumns = getColumns;
+exports.getExpanded = getExpanded;
+exports.getGroupingName = getGroupingName;
+exports.getParsedGroup = getParsedGroup;
+exports.getRange = getRange;
+exports.getSource = getSource;
+exports.getStretchColumnOptions = getStretchColumnOptions;
+exports.isColGrouping = isColGrouping;
+exports.isGrouping = isGrouping;
+exports.isGroupingColumn = isGroupingColumn;
+exports.isRangeSingleCell = isRangeSingleCell;
+exports.isRowDragService = isRowDragService;
+exports.isRowType = isRowType;
+exports.isSameGroup = isSameGroup;
+exports.measureEqualDepth = measureEqualDepth;
+exports.mergeAdjacentGroups = mergeAdjacentGroups;
+exports.nextCell = nextCell;
+exports.reduce = reduce;
+exports.rowTypes = rowTypes;
+exports.toInteger = toInteger;
+//# sourceMappingURL=header-cell-renderer-D-RjAVfe.js.map
+
+//# sourceMappingURL=header-cell-renderer-D-RjAVfe.js.map