@uzum-tech/ui 2.0.0-beta.3 → 2.0.0-beta.5

package/lib/data-table/src/utils/mask-defaults.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultNumericMask = exports.REGEX = void 0;
+exports.REGEX = {
+    ONLY_DIGITS: /\D/g,
+    ONLY_NUMERIC_AND_DOT: /[^\d.]/g
+};
+exports.defaultNumericMask = {
+    postProcess: (value) => {
+        if (!value)
+            return '';
+        const negative = value.trim().startsWith('-');
+        const cleaned = value.replace(/[^\d.,]/g, '').replace(',', '.');
+        const [integerPartRaw, decimalPartRaw = ''] = cleaned.split('.', 2);
+        const integerPart = integerPartRaw.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+        const decimalPart = decimalPartRaw.slice(0, 2);
+        const result = cleaned.includes('.')
+            ? `${integerPart}.${decimalPart}`
+            : integerPart;
+        return negative ? `-${result}` : result;
+    }
+};

package/lib/data-table/src/utils/resize-orchestrator-utils.d.ts

@@ -0,0 +1,6 @@
+import type { ColumnWidthComputationItem, TableBaseColumn, TableExpandColumn, TableSelectionColumn } from '../interface';
+type ResizableLeafColumn = TableSelectionColumn | TableBaseColumn | TableExpandColumn;
+export declare function deriveVisibleLeafColumnWidthItems(columns: ResizableLeafColumn[]): ColumnWidthComputationItem[];
+export declare function deriveResizableColumnWidthItems(columns: ResizableLeafColumn[]): ColumnWidthComputationItem[];
+export declare function deriveColumnWidthSignature(columns: ColumnWidthComputationItem[]): string;
+export {};

package/lib/data-table/src/utils/resize-orchestrator-utils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveVisibleLeafColumnWidthItems = deriveVisibleLeafColumnWidthItems;
+exports.deriveResizableColumnWidthItems = deriveResizableColumnWidthItems;
+exports.deriveColumnWidthSignature = deriveColumnWidthSignature;
+const column_utils_1 = require("./column-utils");
+function toColumnWidthItem(column) {
+    return {
+        key: (0, column_utils_1.getColKey)(column),
+        width: column.width,
+        minWidth: column.minWidth,
+        maxWidth: column.maxWidth
+    };
+}
+function deriveVisibleLeafColumnWidthItems(columns) {
+    return columns.map(column => toColumnWidthItem(column));
+}
+function deriveResizableColumnWidthItems(columns) {
+    return columns
+        .filter(column => (0, column_utils_1.isColumnResizable)(column))
+        .map(column => toColumnWidthItem(column));
+}
+function deriveColumnWidthSignature(columns) {
+    return columns
+        .map((column) => {
+        var _a, _b, _c;
+        return [
+            String(column.key),
+            String((_a = column.width) !== null && _a !== void 0 ? _a : ''),
+            String((_b = column.minWidth) !== null && _b !== void 0 ? _b : ''),
+            String((_c = column.maxWidth) !== null && _c !== void 0 ? _c : '')
+        ].join(':');
+    })
+        .join('|');
+}

package/lib/data-table/src/utils/sort-filter-utils.d.ts

@@ -0,0 +1,6 @@
+import type { SortOrder, SortOrderFlag, SortState, TableBaseColumn, TableColumn } from '../interface';
+export declare function createShallowClonedObject<T>(object: T): T;
+export declare function getFlagOfOrder(order: SortOrder): SortOrderFlag;
+export declare function shouldUseArrayInSingleMode(column: TableBaseColumn): boolean;
+export declare function createNextSorter(column: TableBaseColumn, currentSortState: SortState | null): SortState | null;
+export declare function isColumnSorting(column: TableColumn, mergedSortState: SortState[]): boolean;

package/lib/data-table/src/utils/sort-filter-utils.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createShallowClonedObject = createShallowClonedObject;
+exports.getFlagOfOrder = getFlagOfOrder;
+exports.shouldUseArrayInSingleMode = shouldUseArrayInSingleMode;
+exports.createNextSorter = createNextSorter;
+exports.isColumnSorting = isColumnSorting;
+function createShallowClonedObject(object) {
+    if (!object)
+        return object;
+    if (typeof object === 'object') {
+        return Object.assign({}, object);
+    }
+    return object;
+}
+function getFlagOfOrder(order) {
+    if (order === 'ascend')
+        return 1;
+    else if (order === 'descend')
+        return -1;
+    return 0;
+}
+// for compatibility
+// If column.filterOptionValues or column.defaultFilterOptionValues is set, use
+// array value
+function shouldUseArrayInSingleMode(column) {
+    return (column.filterOptionValues !== undefined
+        || (column.filterOptionValue === undefined
+            && column.defaultFilterOptionValues !== undefined));
+}
+function getNextOrderOf(order) {
+    if (!order)
+        return 'descend';
+    else if (order === 'descend')
+        return 'ascend';
+    return false;
+}
+function createNextSorter(column, currentSortState) {
+    if (column.sorter === undefined)
+        return null;
+    if (currentSortState === null || currentSortState.columnKey !== column.key) {
+        return {
+            columnKey: column.key,
+            sorter: column.sorter,
+            order: getNextOrderOf(false)
+        };
+    }
+    else {
+        return Object.assign(Object.assign({}, currentSortState), { order: getNextOrderOf(currentSortState.order) });
+    }
+}
+function isColumnSorting(column, mergedSortState) {
+    return mergedSortState.some(state => state.columnKey === column.key && state.order);
+}

package/lib/data-table/src/utils/width-utils.d.ts

@@ -0,0 +1,20 @@
+import type { ColumnKey, ColumnWidthComputationItem, TableBaseColumn, TableExpandColumn, TableSelectionColumn } from '../interface';
+export interface ColumnWidthConstraint {
+    min?: number;
+    max?: number;
+}
+export declare function clampValueFollowCSSRules(value: number, min?: number | string, max?: number | string): number;
+export declare function parseLengthToNumber(value: number | string | undefined): number | undefined;
+export declare function resolveColumnWidthConstraint(column: TableBaseColumn | TableSelectionColumn | TableExpandColumn | ColumnWidthComputationItem, systemMinWidth?: number | string, systemMaxWidth?: number | string): ColumnWidthConstraint;
+export declare function computeFixedTableColumnWidths(columns: ColumnWidthComputationItem[], { containerWidth, systemMinWidth, systemMaxWidth, preferredWidths }: {
+    containerWidth?: number;
+    systemMinWidth?: number | string;
+    systemMaxWidth?: number | string;
+    preferredWidths?: Record<ColumnKey, number>;
+}): Record<ColumnKey, number>;
+export declare function sanitizeColumnWidthMap(columns: ColumnWidthComputationItem[], { systemMinWidth, systemMaxWidth, source }: {
+    systemMinWidth?: number | string;
+    systemMaxWidth?: number | string;
+    source: Record<ColumnKey, number> | undefined;
+}): Record<ColumnKey, number>;
+export declare function areColumnWidthMapsEqual(previousWidths: Record<ColumnKey, number>, nextWidths: Record<ColumnKey, number>, keys: ColumnKey[]): boolean;

package/lib/data-table/src/utils/width-utils.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clampValueFollowCSSRules = clampValueFollowCSSRules;
+exports.parseLengthToNumber = parseLengthToNumber;
+exports.resolveColumnWidthConstraint = resolveColumnWidthConstraint;
+exports.computeFixedTableColumnWidths = computeFixedTableColumnWidths;
+exports.sanitizeColumnWidthMap = sanitizeColumnWidthMap;
+exports.areColumnWidthMapsEqual = areColumnWidthMapsEqual;
+const WIDTH_PRECISION = 1000;
+const WIDTH_EPSILON = 1e-6;
+// priority: min-width > max-width > width
+function clampValueFollowCSSRules(value, min, max) {
+    if (max !== undefined) {
+        value = Math.min(value, typeof max === 'number' ? max : Number.parseFloat(max));
+    }
+    if (min !== undefined) {
+        value = Math.max(value, typeof min === 'number' ? min : Number.parseFloat(min));
+    }
+    return value;
+}
+function parseLengthToNumber(value) {
+    if (value === undefined)
+        return;
+    const parsed = typeof value === 'number' ? value : Number.parseFloat(value);
+    if (!Number.isFinite(parsed))
+        return;
+    return parsed;
+}
+function roundWidth(width) {
+    return Math.round(width * WIDTH_PRECISION) / WIDTH_PRECISION;
+}
+function normalizeWidthConstraint(min, max) {
+    if (min !== undefined && max !== undefined && max < min) {
+        return {
+            min,
+            max: min
+        };
+    }
+    return { min, max };
+}
+function resolveColumnWidthConstraint(column, systemMinWidth, systemMaxWidth) {
+    var _a, _b;
+    const min = parseLengthToNumber((_a = column.minWidth) !== null && _a !== void 0 ? _a : systemMinWidth);
+    const max = parseLengthToNumber((_b = column.maxWidth) !== null && _b !== void 0 ? _b : systemMaxWidth);
+    return normalizeWidthConstraint(min, max);
+}
+function clampByConstraint(value, constraint) {
+    return clampValueFollowCSSRules(value, constraint.min, constraint.max);
+}
+function normalizeIncomingWidth(value, constraint) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return;
+    if (value <= 0)
+        return;
+    return roundWidth(clampByConstraint(value, constraint));
+}
+function fillRemainingWidthFrom(widths, constraints, delta, startIndex) {
+    if (delta <= 0 || widths.length === 0)
+        return;
+    let remaining = delta;
+    let cursor = startIndex;
+    let blockedTurns = 0;
+    while (remaining > WIDTH_EPSILON && blockedTurns < widths.length) {
+        const index = (cursor + widths.length) % widths.length;
+        const { max } = constraints[index];
+        const current = widths[index];
+        const capacity = max === undefined ? Number.POSITIVE_INFINITY : max - current;
+        if (capacity > WIDTH_EPSILON) {
+            const append = capacity === Number.POSITIVE_INFINITY
+                ? remaining
+                : Math.min(capacity, remaining);
+            widths[index] = roundWidth(current + append);
+            remaining = roundWidth(remaining - append);
+            blockedTurns = 0;
+        }
+        else {
+            blockedTurns += 1;
+        }
+        cursor += 1;
+    }
+}
+function assignFlexibleWidths(widths, constraints, target, flexibleIndexes) {
+    const unresolved = new Set(flexibleIndexes);
+    let remainingTarget = target;
+    while (unresolved.size > 0) {
+        const share = remainingTarget / unresolved.size;
+        let didClamp = false;
+        for (const index of Array.from(unresolved)) {
+            const limited = roundWidth(clampByConstraint(share, constraints[index]));
+            if (Math.abs(limited - share) > WIDTH_EPSILON) {
+                widths[index] = limited;
+                unresolved.delete(index);
+                remainingTarget = roundWidth(remainingTarget - limited);
+                didClamp = true;
+            }
+        }
+        if (!didClamp) {
+            unresolved.forEach((index) => {
+                widths[index] = roundWidth(clampByConstraint(share, constraints[index]));
+            });
+            unresolved.clear();
+        }
+    }
+}
+function computeFixedTableColumnWidths(columns, { containerWidth, systemMinWidth, systemMaxWidth, preferredWidths }) {
+    var _a;
+    const constraints = columns.map(column => resolveColumnWidthConstraint(column, systemMinWidth, systemMaxWidth));
+    const widths = columns.map((column, index) => {
+        const preferred = normalizeIncomingWidth(preferredWidths === null || preferredWidths === void 0 ? void 0 : preferredWidths[column.key], constraints[index]);
+        if (preferred !== undefined)
+            return preferred;
+        const width = parseLengthToNumber(column.width);
+        if (width === undefined)
+            return undefined;
+        return roundWidth(clampByConstraint(width, constraints[index]));
+    });
+    const canFitContainer = containerWidth !== undefined
+        && Number.isFinite(containerWidth)
+        && containerWidth > 0;
+    const flexibleIndexes = [];
+    widths.forEach((width, index) => {
+        if (width === undefined)
+            flexibleIndexes.push(index);
+    });
+    if (flexibleIndexes.length) {
+        if (canFitContainer) {
+            const allocated = (_a = widths.reduce((accumulatedWidth = 0, width) => accumulatedWidth + (width !== null && width !== void 0 ? width : 0), 0)) !== null && _a !== void 0 ? _a : 0;
+            assignFlexibleWidths(widths, constraints, containerWidth - allocated, flexibleIndexes);
+        }
+        else {
+            flexibleIndexes.forEach((index) => {
+                const { min, max } = constraints[index];
+                if (min !== undefined) {
+                    widths[index] = roundWidth(min);
+                }
+                else if (max !== undefined) {
+                    widths[index] = roundWidth(max);
+                }
+                else {
+                    widths[index] = 0;
+                }
+            });
+        }
+    }
+    const normalizedWidths = widths.map((width, index) => {
+        const base = width !== null && width !== void 0 ? width : 0;
+        return roundWidth(clampByConstraint(base, constraints[index]));
+    });
+    if (canFitContainer) {
+        const totalWidth = normalizedWidths.reduce((accumulatedWidth, width) => accumulatedWidth + width, 0);
+        if (totalWidth < containerWidth) {
+            fillRemainingWidthFrom(normalizedWidths, constraints, containerWidth - totalWidth, normalizedWidths.length - 1);
+        }
+    }
+    const result = {};
+    columns.forEach((column, index) => {
+        result[column.key] = roundWidth(normalizedWidths[index]);
+    });
+    return result;
+}
+function sanitizeColumnWidthMap(columns, { systemMinWidth, systemMaxWidth, source }) {
+    if (!source)
+        return {};
+    const result = {};
+    columns.forEach((column) => {
+        const constraint = resolveColumnWidthConstraint(column, systemMinWidth, systemMaxWidth);
+        const sanitized = normalizeIncomingWidth(source[column.key], constraint);
+        if (sanitized !== undefined) {
+            result[column.key] = sanitized;
+        }
+    });
+    return result;
+}
+function areColumnWidthMapsEqual(previousWidths, nextWidths, keys) {
+    var _a, _b;
+    for (const key of keys) {
+        if (((_a = previousWidths[key]) !== null && _a !== void 0 ? _a : undefined) !== ((_b = nextWidths[key]) !== null && _b !== void 0 ? _b : undefined)) {
+            return false;
+        }
+    }
+    return true;
+}

package/lib/data-table/src/utils.d.ts

@@ -1,25 +1 @@
-import type { CSSProperties } from 'vue';
-import type { CreateRowClassName, InternalRowData, RowData, SortOrder, SortOrderFlag, SortState, TableBaseColumn, TableColumn, TableColumnMaskObject, TableExpandColumn, TableSelectionColumn } from './interface';
-import type { DataTableGetCsvCell, DataTableGetCsvHeader } from './public-types';
-export declare const SELECTION_COL_WIDTH = 40;
-export declare const EXPAND_COL_WIDTH = 40;
-export declare const REGEX: {
-    ONLY_DIGITS: RegExp;
-    ONLY_NUMERIC_AND_DOT: RegExp;
-};
-export declare const defaultNumericMask: TableColumnMaskObject;
-export declare function getNumberColWidth(col: TableColumn): number | undefined;
-export declare function getStringColWidth(col: TableColumn): string | undefined;
-export declare function getColKey(col: TableColumn): string | number;
-export declare function createShallowClonedObject<T>(object: T): T;
-export declare function getFlagOfOrder(order: SortOrder): SortOrderFlag;
-export declare function clampValueFollowCSSRules(value: number, min?: number | string, max?: number | string): number;
-export declare function createCustomWidthStyle(column: TableBaseColumn | TableSelectionColumn | TableExpandColumn, resizedWidth?: string): CSSProperties;
-export declare function createRowClassName(row: InternalRowData, index: number, rowClassName?: string | CreateRowClassName): string;
-export declare function shouldUseArrayInSingleMode(column: TableBaseColumn): boolean;
-export declare function isColumnSortable(column: TableColumn): boolean;
-export declare function isColumnResizable(column: TableColumn): boolean;
-export declare function isColumnFilterable(column: TableColumn): boolean;
-export declare function createNextSorter(column: TableBaseColumn, currentSortState: SortState | null): SortState | null;
-export declare function isColumnSorting(column: TableColumn, mergedSortState: SortState[]): boolean;
-export declare function generateCsv(columns: TableColumn[], data: RowData[], getCsvCell: DataTableGetCsvCell | undefined, getCsvHeader: DataTableGetCsvHeader | undefined): string;
+export * from './utils/index';

package/lib/data-table/src/utils.js

@@ -1,231 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultNumericMask = exports.REGEX = exports.EXPAND_COL_WIDTH = exports.SELECTION_COL_WIDTH = void 0;
-exports.getNumberColWidth = getNumberColWidth;
-exports.getStringColWidth = getStringColWidth;
-exports.getColKey = getColKey;
-exports.createShallowClonedObject = createShallowClonedObject;
-exports.getFlagOfOrder = getFlagOfOrder;
-exports.clampValueFollowCSSRules = clampValueFollowCSSRules;
-exports.createCustomWidthStyle = createCustomWidthStyle;
-exports.createRowClassName = createRowClassName;
-exports.shouldUseArrayInSingleMode = shouldUseArrayInSingleMode;
-exports.isColumnSortable = isColumnSortable;
-exports.isColumnResizable = isColumnResizable;
-exports.isColumnFilterable = isColumnFilterable;
-exports.createNextSorter = createNextSorter;
-exports.isColumnSorting = isColumnSorting;
-exports.generateCsv = generateCsv;
-const seemly_1 = require("seemly");
-const _utils_1 = require("../../_utils");
-exports.SELECTION_COL_WIDTH = 40;
-exports.EXPAND_COL_WIDTH = 40;
-exports.REGEX = {
-    ONLY_DIGITS: /\D/g,
-    ONLY_NUMERIC_AND_DOT: /[^\d.]/g
-};
-exports.defaultNumericMask = {
-    postProcess: (value) => {
-        if (!value)
-            return '';
-        const isNegative = value.trim().startsWith('-');
-        const cleaned = value.replace(/[^\d.,]/g, '').replace(',', '.');
-        const [intPartRaw, decimalPartRaw = ''] = cleaned.split('.', 2);
-        const intPart = intPartRaw.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-        const decimalPart = decimalPartRaw.slice(0, 2);
-        const result = cleaned.includes('.') ? `${intPart}.${decimalPart}` : intPart;
-        return isNegative ? `-${result}` : result;
-    }
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-function getNumberColWidth(col) {
-    if (col.type === 'selection') {
-        return col.width === undefined ? exports.SELECTION_COL_WIDTH : (0, seemly_1.depx)(col.width);
-    }
-    if (col.type === 'expand') {
-        return col.width === undefined ? exports.EXPAND_COL_WIDTH : (0, seemly_1.depx)(col.width);
-    }
-    if ('children' in col)
-        return undefined;
-    if (typeof col.width === 'string') {
-        return (0, seemly_1.depx)(col.width);
-    }
-    return col.width;
-}
-function getStringColWidth(col) {
-    var _a, _b;
-    if (col.type === 'selection') {
-        return (0, _utils_1.formatLength)((_a = col.width) !== null && _a !== void 0 ? _a : exports.SELECTION_COL_WIDTH);
-    }
-    if (col.type === 'expand') {
-        return (0, _utils_1.formatLength)((_b = col.width) !== null && _b !== void 0 ? _b : exports.EXPAND_COL_WIDTH);
-    }
-    if ('children' in col) {
-        return undefined;
-    }
-    return (0, _utils_1.formatLength)(col.width);
-}
-function getColKey(col) {
-    if (col.type === 'selection')
-        return '__n_selection__';
-    if (col.type === 'expand')
-        return '__n_expand__';
-    return col.key;
-}
-function createShallowClonedObject(object) {
-    if (!object)
-        return object;
-    if (typeof object === 'object') {
-        return Object.assign({}, object);
-    }
-    return object;
-}
-function getFlagOfOrder(order) {
-    if (order === 'ascend')
-        return 1;
-    else if (order === 'descend')
-        return -1;
-    return 0;
-}
-// priority: min-width > max-width > width
-function clampValueFollowCSSRules(value, min, max) {
-    if (max !== undefined) {
-        value = Math.min(value, typeof max === 'number' ? max : Number.parseFloat(max));
-    }
-    if (min !== undefined) {
-        value = Math.max(value, typeof min === 'number' ? min : Number.parseFloat(min));
-    }
-    return value;
-}
-function createCustomWidthStyle(column, resizedWidth) {
-    var _a;
-    if (resizedWidth !== undefined) {
-        const numWidth = (0, seemly_1.depx)(resizedWidth);
-        const minMaxColumn = column && 'minWidth' in column && 'maxWidth' in column
-            ? column
-            : null;
-        const clampedNum = minMaxColumn
-            ? clampValueFollowCSSRules(numWidth, minMaxColumn.minWidth, minMaxColumn.maxWidth)
-            : numWidth;
-        const clamped = (0, _utils_1.formatLength)(clampedNum);
-        return {
-            width: clamped,
-            minWidth: clamped,
-            maxWidth: clamped
-        };
-    }
-    const explicitNum = (_a = getNumberColWidth(column)) !== null && _a !== void 0 ? _a : undefined;
-    const minWidth = column && 'minWidth' in column
-        ? column.minWidth
-        : undefined;
-    const maxWidth = column && 'maxWidth' in column
-        ? column.maxWidth
-        : undefined;
-    let widthNum = explicitNum;
-    if (widthNum === undefined
-        && (minWidth !== undefined || maxWidth !== undefined)) {
-        widthNum = clampValueFollowCSSRules(maxWidth !== undefined
-            ? typeof maxWidth === 'number'
-                ? maxWidth
-                : Number.parseFloat(maxWidth)
-            : minWidth !== undefined
-                ? typeof minWidth === 'number'
-                    ? minWidth
-                    : Number.parseFloat(minWidth)
-                : 0, minWidth, maxWidth);
-    }
-    else if (widthNum !== undefined
-        && (minWidth !== undefined || maxWidth !== undefined)) {
-        widthNum = clampValueFollowCSSRules(widthNum, minWidth, maxWidth);
-    }
-    const width = widthNum !== undefined
-        ? (0, _utils_1.formatLength)(widthNum)
-        : getStringColWidth(column);
-    return {
-        width,
-        minWidth: (0, _utils_1.formatLength)(minWidth) || width,
-        maxWidth: (0, _utils_1.formatLength)(maxWidth)
-    };
-}
-function createRowClassName(row, index, rowClassName) {
-    if (typeof rowClassName === 'function')
-        return rowClassName(row, index);
-    return rowClassName || '';
-}
-// for compatibility
-// If column.filterOptionValues or column.defaultFilterOptionValues is set, use
-// array value
-function shouldUseArrayInSingleMode(column) {
-    return (column.filterOptionValues !== undefined
-        || (column.filterOptionValue === undefined
-            && column.defaultFilterOptionValues !== undefined));
-}
-function isColumnSortable(column) {
-    if ('children' in column)
-        return false;
-    return !!column.sorter;
-}
-function isColumnResizable(column) {
-    if ('children' in column && !!column.children.length)
-        return false;
-    return !!column.resizable;
-}
-function isColumnFilterable(column) {
-    if ('children' in column)
-        return false;
-    return (!!column.filter && (!!column.filterOptions || !!column.renderFilterMenu));
-}
-function getNextOrderOf(order) {
-    if (!order)
-        return 'descend';
-    else if (order === 'descend')
-        return 'ascend';
-    return false;
-}
-function createNextSorter(column, currentSortState) {
-    if (column.sorter === undefined)
-        return null;
-    if (currentSortState === null || currentSortState.columnKey !== column.key) {
-        return {
-            columnKey: column.key,
-            sorter: column.sorter,
-            order: getNextOrderOf(false)
-        };
-    }
-    else {
-        return Object.assign(Object.assign({}, currentSortState), { order: getNextOrderOf(currentSortState.order) });
-    }
-}
-function isColumnSorting(column, mergedSortState) {
-    return (mergedSortState.find(state => state.columnKey === column.key && state.order) !== undefined);
-}
-function formatCsvCell(value) {
-    if (typeof value === 'string') {
-        return value.replace(/,/g, '\\,');
-    }
-    else if (value === null || value === undefined) {
-        return '';
-    }
-    else {
-        return `${value}`.replace(/,/g, '\\,');
-    }
-}
-function generateCsv(columns, data, getCsvCell, getCsvHeader) {
-    const exportableColumns = columns.filter(column => column.type !== 'expand'
-        && column.type !== 'selection'
-        && column.allowExport !== false);
-    const header = exportableColumns
-        .map((col) => {
-        return getCsvHeader ? getCsvHeader(col) : col.title;
-    })
-        .join(',');
-    const rows = data.map((row) => {
-        return exportableColumns
-            .map((col) => {
-            return getCsvCell
-                ? getCsvCell(row[col.key], row, col)
-                : formatCsvCell(row[col.key]);
-        })
-            .join(',');
-    });
-    return [header, ...rows].join('\n');
-}
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils/index"), exports);

package/lib/grid/src/Grid.d.ts

@@ -96,11 +96,11 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         readonly default: 0;
     };
 }>> & Readonly<{}>, {
+    readonly cols: string | number;
     readonly responsive: "self" | "screen";
     readonly collapsed: boolean;
     readonly xGap: string | number;
     readonly yGap: string | number;
-    readonly cols: string | number;
     readonly layoutShiftDisabled: boolean;
     readonly itemResponsive: boolean;
     readonly collapsedRows: number;

package/lib/header/src/HeaderSearchResults.d.ts

@@ -75,7 +75,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>> & Readonly<{}>, {
     readonly loading: boolean;
     readonly results: HeaderSearchResult[];
-    readonly version: "desktop" | "mobile";
+    readonly version: "mobile" | "desktop";
     readonly query: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/lib/icon-bar/src/IconBar.d.ts

@@ -119,7 +119,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         cols: number;
     }, any>>>;
 }>> & Readonly<{}>, {
-    readonly items: IconBarItemProps[];
     readonly cols: number;
+    readonly items: IconBarItemProps[];
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/lib/input/src/Input.d.ts

@@ -1134,10 +1134,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     defaultValue: string | [string, string] | null;
     round: boolean;
     loadingSkeleton: boolean;
+    rows: string | number;
     stateful: boolean;
     resizable: boolean;
     pair: boolean;
-    rows: string | number;
     autosize: boolean | {
         minRows?: number;
         maxRows?: number;

package/lib/list/src/ListItem.d.ts

@@ -1,6 +1,6 @@
 import type { Component, ComputedRef, Slot } from 'vue';
 import type { ArrayEmptyHandler, ArrayFocusHandler, ArrayKeyboardHandler, ArrayMouseHandler, KeyboardEventHandler, MouseEventHandler } from '../../_utils';
-import type { Size } from './interface';
+import type { RenderableType, Size } from './interface';
 import type { DescriptionPropsObject, HeaderPropObject } from './props';
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     avatar: {
@@ -155,7 +155,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     loadingSkeleton: import("./interface").BooleanProp;
     icon: import("./interface").RenderableProp;
 }>> & Readonly<{}>, {
-    icon: import("./interface").RenderableType;
+    icon: RenderableType;
     avatar: import("../../avatar").AvatarProps & {
         icon: Component;
         hasBadge?: boolean;