balala-revogrid 1.0.0

package/standalone/column.service.js

@@ -0,0 +1,1110 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+import { v as toFinite, w as keys, n as isArrayLike, u as baseIteratee, l as isArray, x as isIterateeCall, b as getSourceItem } from './data.store.js';
+import '@stencil/core/internal/client';
+import './platform.js';
+import { b as DISABLED_CLASS, C as CELL_CLASS } from './consts.js';
+import { p as isGroupingColumn } from './grouping.service.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;
+}
+
+/**
+ * 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;
+}
+
+export { ColumnService as C, columnTypes as a, cropCellToMax as b, convertCollectionToColumns as c, getRange as d, isRangeSingleCell as e, getCellData as f, getStretchColumnOptions as g, getCellRaw as h, isRowType as i, getCellDataParsed as j, getColumnType as k, getColumnSizes as l, mergeAdjacentGroups as m, nextCell as n, isColGrouping as o, getColumns as p, gatherGroup as q, rowTypes as r, getColumnByProp as s, reduce as t, baseEach as u, toInteger as v, getCellEditor as w, isRowDragService as x, doPropMerge as y };
+//# sourceMappingURL=column.service.js.map
+
+//# sourceMappingURL=column.service.js.map