vxe-table 3.21.13 → 3.21.14

package/es/table/module/edit/mixin.js

@@ -70,7 +70,7 @@ function insertTreeRow($xeTable, newRecords, isAppend) {
             }
             pChilds[funcName](item);
             pMapChilds[funcName](item);
-            const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: pChilds, parent: parentRow, level: parentLevel + 1, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
+            const rest = { row: item, rowid, _seq: -1, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: pChilds, parent: parentRow, level: parentLevel + 1, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
             fullDataRowIdData[rowid] = rest;
             fullAllDataRowIdData[rowid] = rest;
         }
@@ -80,7 +80,7 @@ function insertTreeRow($xeTable, newRecords, isAppend) {
             }
             afterFullData[funcName](item);
             tableFullTreeData[funcName](item);
-            const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: tableFullTreeData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
+            const rest = { row: item, rowid, _seq: -1, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: tableFullTreeData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
             fullDataRowIdData[rowid] = rest;
             fullAllDataRowIdData[rowid] = rest;
         }
@@ -133,7 +133,7 @@ function handleInsertRowAt($xeTable, records, targetRowOrRowid, isInsertNextRow)
         else {
             newRecords.forEach(item => {
                 const rowid = getRowid($xeTable, item);
-                const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: afterFullData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
+                const rest = { row: item, rowid, _seq: -1, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: afterFullData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
                 fullDataRowIdData[rowid] = rest;
                 fullAllDataRowIdData[rowid] = rest;
                 afterFullData.unshift(item);
@@ -165,7 +165,7 @@ function handleInsertRowAt($xeTable, records, targetRowOrRowid, isInsertNextRow)
             else {
                 newRecords.forEach(item => {
                     const rowid = getRowid($xeTable, item);
-                    const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: afterFullData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
+                    const rest = { row: item, rowid, _seq: -1, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: afterFullData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
                     fullDataRowIdData[rowid] = rest;
                     fullAllDataRowIdData[rowid] = rest;
                     afterFullData.push(item);
@@ -205,7 +205,7 @@ function handleInsertRowAt($xeTable, records, targetRowOrRowid, isInsertNextRow)
                     });
                     XEUtils.eachTree(treeRecords, (item) => {
                         const rowid = getRowid($xeTable, item);
-                        const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: parentMapChilds, parent: parentRow, level: parentLevel + 1, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
+                        const rest = { row: item, rowid, _seq: -1, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: parentMapChilds, parent: parentRow, level: parentLevel + 1, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
                         if (item[childrenField]) {
                             item[mapChildrenField] = item[childrenField];
                         }

package/es/table/src/methods.js

@@ -609,28 +609,65 @@ function handleDefaultRowGroupExpand($xeTable) {
         }
     }
 }
+function updateAfterTreeIndex($xeTable) {
+    const internalData = $xeTable;
+    const { fullDataRowIdData, fullAllDataRowIdData, afterFullData, afterTreeFullData } = internalData;
+    const treeOpts = $xeTable.computeTreeOpts;
+    const { transform, mapChildrenField } = treeOpts;
+    const childrenField = treeOpts.children || treeOpts.childrenField;
+    const fullMaps = {};
+    let rowNum = 0;
+    const { handleGetRowId } = createHandleGetRowId($xeTable);
+    XEUtils.eachTree(afterTreeFullData, (row, index, items, path) => {
+        const rowid = handleGetRowId(row);
+        const rowRest = fullAllDataRowIdData[rowid];
+        const seq = path.map((num, i) => i % 2 === 0 ? (Number(num) + 1) : '.').join('');
+        if (rowRest) {
+            rowRest.seq = seq;
+            rowRest._seq = rowNum;
+            rowRest.treeIndex = index;
+            rowRest._tIndex = rowNum;
+        }
+        else {
+            const rest = { row, rowid, _seq: rowNum, seq, index: -1, $index: -1, _index: -1, treeIndex: -1, _tIndex: rowNum, items: [], parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
+            fullAllDataRowIdData[rowid] = rest;
+            fullDataRowIdData[rowid] = rest;
+        }
+        rowNum++;
+        fullMaps[rowid] = row;
+    }, { children: transform ? mapChildrenField : childrenField });
+    if (transform) {
+        afterFullData.forEach((row, index) => {
+            const rowid = handleGetRowId(row);
+            const rowRest = fullAllDataRowIdData[rowid];
+            if (rowRest) {
+                rowRest._index = index;
+            }
+        });
+    }
+    internalData.afterFullRowMaps = fullMaps;
+}
 function updateAfterListIndex($xeTable) {
-    const props = $xeTable;
     const internalData = $xeTable;
-    const { treeConfig } = props;
     const { afterFullData, fullDataRowIdData, fullAllDataRowIdData } = internalData;
     const { handleGetRowId } = createHandleGetRowId($xeTable);
     const fullMaps = {};
+    let rowNum = 0;
     afterFullData.forEach((row, index) => {
         const rowid = handleGetRowId(row);
         const rowRest = fullAllDataRowIdData[rowid];
         const seq = index + 1;
         if (rowRest) {
-            if (!treeConfig) {
-                rowRest.seq = seq;
-            }
+            rowRest.seq = seq;
+            rowRest._seq = rowNum;
             rowRest._index = index;
         }
         else {
-            const rest = { row, rowid, seq, index: -1, $index: -1, _index: index, treeIndex: -1, _tIndex: -1, items: [], parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
+            const rest = { row, rowid, _seq: rowNum, seq, index: -1, $index: -1, _index: index, treeIndex: -1, _tIndex: -1, items: [], parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
             fullAllDataRowIdData[rowid] = rest;
             fullDataRowIdData[rowid] = rest;
         }
+        rowNum++;
         fullMaps[rowid] = row;
     });
     internalData.afterFullRowMaps = fullMaps;
@@ -641,47 +678,9 @@ function updateAfterListIndex($xeTable) {
  */
 function updateAfterDataIndex($xeTable) {
     const props = $xeTable;
-    const internalData = $xeTable;
     const { treeConfig } = props;
-    const { fullDataRowIdData, fullAllDataRowIdData, afterFullData, afterTreeFullData } = internalData;
-    const treeOpts = $xeTable.computeTreeOpts;
-    const { transform } = treeOpts;
-    const childrenField = treeOpts.children || treeOpts.childrenField;
-    const fullMaps = {};
     if (treeConfig) {
-        let _treeIndex = 0;
-        const { handleGetRowId } = createHandleGetRowId($xeTable);
-        XEUtils.eachTree(afterTreeFullData, (row, index, items, path) => {
-            const rowid = handleGetRowId(row);
-            const rowRest = fullAllDataRowIdData[rowid];
-            const seq = path.map((num, i) => i % 2 === 0 ? (Number(num) + 1) : '.').join('');
-            if (rowRest) {
-                rowRest.seq = seq;
-                rowRest.treeIndex = index;
-                rowRest._tIndex = _treeIndex;
-            }
-            else {
-                const rest = { row, rowid, seq, index: -1, $index: -1, _index: -1, treeIndex: -1, _tIndex: _treeIndex, items: [], parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
-                fullAllDataRowIdData[rowid] = rest;
-                fullDataRowIdData[rowid] = rest;
-            }
-            _treeIndex++;
-            fullMaps[rowid] = row;
-        }, { children: transform ? treeOpts.mapChildrenField : childrenField });
-        if (transform) {
-            afterFullData.forEach((row, index) => {
-                const rowid = handleGetRowId(row);
-                const rowRest = fullAllDataRowIdData[rowid];
-                const seq = index + 1;
-                if (rowRest) {
-                    if (!treeConfig) {
-                        rowRest.seq = seq;
-                    }
-                    rowRest._index = index;
-                }
-            });
-        }
-        internalData.afterFullRowMaps = fullMaps;
+        updateAfterTreeIndex($xeTable);
     }
     else {
         updateAfterListIndex($xeTable);
@@ -3072,10 +3071,11 @@ function handleRecalculateStyle($xeTable, reFull, reWidth, reHeight) {
         }
     });
 }
-const minRunDelay = 50;
-function handleLazyRecalculate($xeTable, reFull, reWidth, reHeight) {
+const defaultMinRunDelay = 50;
+function handleLazyRecalculate($xeTable, reFull, reWidth, reHeight, options) {
     const reactData = $xeTable;
     const internalData = $xeTable;
+    const minRunDelay = (options ? options.minRunDelay : defaultMinRunDelay) || defaultMinRunDelay;
     return new Promise(resolve => {
         const { customStore } = reactData;
         const { rceTimeout, rceRunTime } = internalData;
@@ -3102,6 +3102,7 @@ function handleLazyRecalculate($xeTable, reFull, reWidth, reHeight) {
         }
         if (rceTimeout) {
             clearTimeout(rceTimeout);
+            // 多少毫秒内至少执行一次
             if (rceRunTime && rceRunTime + minRunDelay < Date.now()) {
                 resolve(handleRecalculateStyle($xeTable, reFull, reWidth, reHeight));
             }
@@ -3124,7 +3125,18 @@ function handleLazyRecalculate($xeTable, reFull, reWidth, reHeight) {
     });
 }
 function handleResizeEvent($xeTable) {
-    handleLazyRecalculate($xeTable, true, true, true);
+    const internalData = $xeTable;
+    if (internalData.rsePending) {
+        return;
+    }
+    internalData.rsePending = true;
+    handleLazyRecalculate($xeTable, true, true, true, {
+        minRunDelay: 200
+    }).then(() => {
+        internalData.rsePending = false;
+    }).catch(() => {
+        internalData.rsePending = false;
+    });
 }
 function handleUpdateAggValues($xeTable) {
     const reactData = $xeTable;
@@ -4907,16 +4919,18 @@ const tableMethods = {
         const fullDataRowIdMaps = {};
         const idMaps = {};
         const { handleUpdateRowId } = createHandleUpdateRowId($xeTable);
+        let rowNum = 0;
         const handleRowCache = (row, index, items, currIndex, parentRow, rowid, level, seq) => {
             let rowRest = fullAllDataRowIdMaps[rowid];
             if (idMaps[rowid]) {
                 errLog('vxe.error.repeatKey', [currKeyField, rowid]);
             }
             if (!rowRest) {
-                rowRest = { row, rowid, seq, index: -1, _index: -1, $index: -1, treeIndex: index, _tIndex: -1, items, parent: parentRow, level, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
+                rowRest = { row, rowid, _seq: -1, seq, index: -1, _index: -1, $index: -1, treeIndex: index, _tIndex: -1, items, parent: parentRow, level, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
             }
             rowRest.treeLoaded = false;
             rowRest.expandLoaded = false;
+            rowRest._seq = rowNum++;
             rowRest.row = row;
             rowRest.items = items;
             rowRest.parent = parentRow;
@@ -5026,7 +5040,7 @@ const tableMethods = {
             XEUtils.eachTree(rows, (childRow, index, items, path, parentItem, nodes) => {
                 const rowid = getRowid($xeTable, childRow);
                 const parentRow = parentItem || parentRest.row;
-                const rest = { row: childRow, rowid, seq: -1, index, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items, parent: parentRow, level: parentLevel + nodes.length, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
+                const rest = { row: childRow, rowid, _seq: -1, seq: -1, index, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items, parent: parentRow, level: parentLevel + nodes.length, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 };
                 fullDataRowIdData[rowid] = rest;
                 fullAllDataRowIdData[rowid] = rest;
             }, { children: childrenField });
@@ -8464,31 +8478,162 @@ const tableMethods = {
         const { treeConfig } = props;
         const { row } = params;
         const { isRowGroupStatus } = reactData;
-        const { afterFullData } = internalData;
+        const { fullAllDataRowIdData, afterFullData, afterTreeFullData, afterGroupFullData } = internalData;
         const checkboxOpts = $xeTable.computeCheckboxOpts;
-        const { checkMethod, trigger } = checkboxOpts;
+        const aggregateOpts = $xeTable.computeAggregateOpts;
+        const treeOpts = $xeTable.computeTreeOpts;
+        const { checkMethod, trigger, checkStrictly } = checkboxOpts;
         if (trigger === 'manual') {
             return;
         }
         evnt.stopPropagation();
-        if (checkboxOpts.isShiftKey && evnt.shiftKey && !(treeConfig || isRowGroupStatus)) {
+        if (checkboxOpts.isShiftKey && evnt.shiftKey) {
+            const { handleGetRowId } = createHandleGetRowId($xeTable);
             const checkboxRecords = $xeTable.getCheckboxRecords();
-            if (checkboxRecords.length) {
-                const firstRow = checkboxRecords[0];
-                const _rowIndex = $xeTable.getVTRowIndex(row);
-                const _firstRowIndex = $xeTable.getVTRowIndex(firstRow);
-                if (_rowIndex !== _firstRowIndex) {
+            let currSeq = -1;
+            let currRow = null;
+            const currRowid = handleGetRowId(row);
+            const rowRest = fullAllDataRowIdData[currRowid];
+            if (rowRest) {
+                currRow = rowRest.row;
+                currSeq = rowRest._seq;
+            }
+            if (currRow && checkboxRecords.length) {
+                let rangeRows = [];
+                let firstSeq = -1;
+                let firstRow = null;
+                let firstRowid = '';
+                let lastSeq = -1;
+                let lastRow = null;
+                let lastRowid = '';
+                // 根据序号取出范围最小/最大的行
+                const selectMaps = {};
+                checkboxRecords.forEach(item => {
+                    const rowid = handleGetRowId(item);
+                    const rowRest = fullAllDataRowIdData[rowid];
+                    if (rowRest) {
+                        if (!firstRow || firstSeq > rowRest._seq) {
+                            firstRowid = rowRest.rowid;
+                            firstRow = rowRest.row;
+                            firstSeq = rowRest._seq;
+                        }
+                        if (!lastRow || lastSeq < rowRest._seq) {
+                            lastRowid = rowRest.rowid;
+                            lastRow = rowRest.row;
+                            lastSeq = rowRest._seq;
+                        }
+                    }
+                    selectMaps[rowid] = item;
+                });
+                // 如果已选只有一条并选择当前则跳过
+                if (firstRow && lastRow && (checkboxRecords.length > 1 || currRowid !== firstRowid) && (Math.abs(firstSeq - lastSeq) > 1 || Math.abs(currSeq - firstSeq) > 1 || Math.abs(currSeq - lastSeq) > 1)) {
+                    // 树与分组
+                    if (treeConfig || isRowGroupStatus) {
+                        const { transform } = treeOpts;
+                        const childrenField = treeOpts.children || treeOpts.childrenField;
+                        const iteratorChildField = treeConfig ? (transform ? treeOpts.mapChildrenField : childrenField) : aggregateOpts.mapChildrenField;
+                        let isMatchFirst = false;
+                        let matchStartRowid = '';
+                        let matchEndRowid = '';
+                        const handleGetChildRowid = (rowid, isLast) => {
+                            const rowRest = fullAllDataRowIdData[rowid];
+                            if (rowRest) {
+                                const item = rowRest.row;
+                                const childList = item[iteratorChildField];
+                                if (childList && childList.length) {
+                                    const targetRow = isLast ? XEUtils.last(childList) : XEUtils.first(childList);
+                                    return handleGetChildRowid(handleGetRowId(targetRow), isLast);
+                                }
+                            }
+                            return rowid;
+                        };
+                        const handleGetSelectParentRowid = (rowid) => {
+                            const rowRest = fullAllDataRowIdData[rowid];
+                            if (rowRest) {
+                                const parentItem = rowRest.parent;
+                                if (parentItem) {
+                                    const parentRowid = handleGetRowId(parentItem);
+                                    if (selectMaps[parentRowid]) {
+                                        return handleGetSelectParentRowid(parentRowid);
+                                    }
+                                }
+                            }
+                            return rowid;
+                        };
+                        const handleGetRootRow = (row) => {
+                            const rowid = handleGetRowId(row);
+                            if (rowid) {
+                                const rest = fullAllDataRowIdData[rowid];
+                                if (rest) {
+                                    return rest.parent ? handleGetRootRow(rest.parent) : rest;
+                                }
+                            }
+                            return null;
+                        };
+                        if (currSeq < firstSeq) {
+                            matchStartRowid = handleGetChildRowid(currRowid, 0);
+                            matchEndRowid = handleGetChildRowid(firstRowid, 1);
+                        }
+                        else {
+                            if (currSeq > lastSeq) {
+                                matchStartRowid = handleGetSelectParentRowid(lastRowid);
+                            }
+                            else {
+                                matchStartRowid = handleGetChildRowid(firstRowid, 0);
+                            }
+                            matchEndRowid = handleGetChildRowid(currRowid, 1);
+                        }
+                        const handleRangeRow = (item) => {
+                            const rowid = handleGetRowId(item);
+                            const childList = item[iteratorChildField];
+                            if (!isMatchFirst && rowid === matchStartRowid) {
+                                isMatchFirst = true;
+                            }
+                            // 如果是父子关联，则排除父节点
+                            if (isMatchFirst && (checkStrictly || !childList || !childList.length)) {
+                                rangeRows.push(item);
+                            }
+                            // break
+                            return rowid === matchEndRowid;
+                        };
+                        if (treeConfig) {
+                            const matchStartRowRest = fullAllDataRowIdData[matchStartRowid];
+                            const firstRootRowRest = matchStartRowRest ? handleGetRootRow(matchStartRowRest.row) : null;
+                            if (firstRootRowRest) {
+                                // 优化查找复杂度
+                                XEUtils.findTree(afterTreeFullData.slice(firstRootRowRest.treeIndex), handleRangeRow, { children: iteratorChildField });
+                            }
+                            else {
+                                XEUtils.findTree(afterTreeFullData, handleRangeRow, { children: iteratorChildField });
+                            }
+                        }
+                        else {
+                            XEUtils.findTree(afterGroupFullData, handleRangeRow, { children: iteratorChildField });
+                        }
+                    }
+                    else {
+                        const _currRowIndex = $xeTable.getVTRowIndex(currRow);
+                        const _firstRowIndex = $xeTable.getVTRowIndex(firstRow);
+                        const _lastRowIndex = $xeTable.getVTRowIndex(lastRow);
+                        if (_currRowIndex < _firstRowIndex) {
+                            rangeRows = afterFullData.slice(_currRowIndex, _firstRowIndex + 1);
+                        }
+                        else if (_currRowIndex > _lastRowIndex) {
+                            rangeRows = afterFullData.slice(_lastRowIndex, _currRowIndex + 1);
+                        }
+                        else {
+                            rangeRows = afterFullData.slice(_firstRowIndex, _currRowIndex + 1);
+                        }
+                    }
                     $xeTable.setAllCheckboxRow(false);
-                    const rangeRows = _rowIndex < _firstRowIndex ? afterFullData.slice(_rowIndex, _firstRowIndex + 1) : afterFullData.slice(_firstRowIndex, _rowIndex + 1);
                     $xeTable.$nextTick(() => {
                         handleCheckedCheckboxRow($xeTable, rangeRows, true, false);
                     });
                     $xeTable.dispatchEvent('checkbox-range-select', Object.assign({ rangeRecords: rangeRows }, params), evnt);
-                    return;
                 }
             }
         }
-        if (isRowGroupStatus || !checkMethod || checkMethod({ $table: $xeTable, row })) {
+        if (!checkMethod || checkMethod({ $table: $xeTable, row })) {
             $xeTable.handleBatchSelectRows([row], checked);
             $xeTable.checkSelectionStatus();
             $xeTable.dispatchEvent('checkbox-change', Object.assign({

package/es/table/src/table.js

@@ -1245,22 +1245,32 @@ export default {
             const { tableFullColumn } = internalData;
             const { updateColFlag } = reactData;
             const editDirtyOpts = $xeTable.computeEditDirtyOpts;
-            const { includeFields, excludeFields } = editDirtyOpts;
+            const { extraFields, includeFields, excludeFields } = editDirtyOpts;
             const kpFields = [];
             if (updateColFlag) {
                 if (includeFields && includeFields.length) {
                     return includeFields;
                 }
-                const exfMaps = {};
+                const excludeFdMaps = {};
                 if (excludeFields && excludeFields.length) {
                     excludeFields.forEach(field => {
-                        exfMaps[field] = 1;
+                        excludeFdMaps[field] = 1;
+                    });
+                }
+                const addFdMaps = {};
+                if (extraFields && extraFields.length) {
+                    extraFields.forEach(field => {
+                        if (!addFdMaps[field]) {
+                            addFdMaps[field] = 1;
+                            kpFields.push(field);
+                        }
                     });
                 }
                 for (let i = 0; i < tableFullColumn.length; i++) {
                     const column = tableFullColumn[i];
                     const { field, type, editRender, cellRender } = column;
-                    if (field && !type && (editRender || cellRender) && !exfMaps[field]) {
+                    if (field && !type && (editRender || cellRender) && !addFdMaps[field] && !excludeFdMaps[field]) {
+                        addFdMaps[field] = 1;
                         kpFields.push(field);
                     }
                 }
@@ -1727,9 +1737,6 @@ export default {
         if (props.editConfig && editOpts.activeMethod) {
             warnLog('vxe.error.delProp', ['table.edit-config.activeMethod', 'table.edit-config.beforeEditMethod']);
         }
-        if (props.treeConfig && checkboxOpts.isShiftKey) {
-            errLog('vxe.error.reqSupportProp', ['tree-config', 'checkbox-config.isShiftKey=false']);
-        }
         if (checkboxOpts.halfField) {
             warnLog('vxe.error.delProp', ['checkbox-config.halfField', 'checkbox-config.indeterminateField']);
         }

package/es/ui/index.js

@@ -1,6 +1,6 @@
 import { VxeUI } from '@vxe-ui/core';
 import { getFuncText } from './src/utils';
-export const version = "3.21.13";
+export const version = "3.21.14";
 VxeUI.version = version;
 VxeUI.tableVersion = version;
 VxeUI.setConfig({

package/es/ui/src/log.js

@@ -1,5 +1,5 @@
 import { VxeUI } from '@vxe-ui/core';
 const { log } = VxeUI;
-const version = `table v${"3.21.13"}`;
+const version = `table v${"3.21.14"}`;
 export const warnLog = log.create('warn', version);
 export const errLog = log.create('error', version);