dtable-statistic 4.0.2-test-2

package/es/utils/stat-utils.js

@@ -0,0 +1,353 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import { DateUtils, isNumber, isNumericColumn, CellType, FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE, sortText, sortNumber, sortDate, sortSingleSelect, getPrecisionNumber, getFormulaDisplayString, getGeolocationDisplayString, getDateDisplayString, getNumberDisplayString } from 'dtable-store';
+import { getClientFormulaDisplayString } from '../utils';
+import { STATISTICS_COUNT_TYPE } from '../constants';
+var SUPPORT_SORT_COLUMNS = [CellType.TEXT, CellType.NUMBER, CellType.DATE, CellType.SINGLE_SELECT, CellType.FORMULA, CellType.LINK_FORMULA, CellType.CTIME, CellType.MTIME, CellType.RATE];
+var getValidCollaborators = function getValidCollaborators(collaborators, emails) {
+  if (!Array.isArray(emails)) {
+    return [];
+  }
+  return emails.filter(function (e) {
+    return collaborators.findIndex(function (c) {
+      return c.email === e;
+    }) > -1;
+  });
+};
+var StatUtils = /*#__PURE__*/function () {
+  function StatUtils() {
+    _classCallCheck(this, StatUtils);
+  }
+  _createClass(StatUtils, null, [{
+    key: "getGroupLabel",
+    value: function getGroupLabel(cellValue, formulaRow, column, dateGranularity, geoGranularity, value) {
+      var type = column.type,
+        key = column.key,
+        data = column.data;
+      switch (type) {
+        case CellType.TEXT:
+          {
+            return cellValue || null;
+          }
+        case CellType.NUMBER:
+          {
+            if (!cellValue && cellValue !== 0) {
+              return null;
+            }
+            var number = getPrecisionNumber(cellValue, data);
+            var valueNumber = parseFloat(number);
+            return isNumber(valueNumber) ? getNumberDisplayString(valueNumber, column.data) : valueNumber;
+          }
+        case CellType.SINGLE_SELECT:
+          {
+            var isInvalidValue = data && data.options.findIndex(function (opt) {
+              return opt.id === cellValue;
+            }) < 0;
+            if (isInvalidValue) {
+              return null;
+            }
+            return cellValue;
+          }
+        case CellType.DATE:
+        case CellType.CTIME:
+        case CellType.MTIME:
+          {
+            if (!dateGranularity) {
+              return getDateDisplayString(cellValue);
+            }
+            return DateUtils.getDateByGranularity(cellValue, dateGranularity);
+          }
+        case CellType.MULTIPLE_SELECT:
+          {
+            var options = data && data.options;
+            if (!Array.isArray(cellValue)) {
+              return [];
+            }
+            return cellValue.filter(function (id) {
+              return options.findIndex(function (o) {
+                return o.id === id;
+              }) > -1;
+            });
+          }
+        case CellType.COLLABORATOR:
+          {
+            return getValidCollaborators(value.collaborators, cellValue);
+          }
+        case CellType.CREATOR:
+        case CellType.LAST_MODIFIER:
+          {
+            return cellValue ? cellValue : null;
+          }
+        case CellType.LINK_FORMULA:
+        case CellType.FORMULA:
+          {
+            if (!formulaRow) return '';
+            var formulaCellValue = formulaRow[key];
+            var _ref = data || {},
+              result_type = _ref.result_type;
+            if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+              return getFormulaDisplayString(formulaCellValue, data, {
+                tables: value.tables
+              }) || null;
+            }
+            if (result_type === FORMULA_RESULT_TYPE.NUMBER) {
+              return getPrecisionNumber(formulaCellValue, data);
+            }
+            return formulaCellValue ? formulaCellValue + '' : null;
+          }
+        case CellType.GEOLOCATION:
+          {
+            var _ref2 = data || {},
+              geo_format = _ref2.geo_format;
+            if (geo_format === 'country_region' || geo_format === 'lng_lat' || !geoGranularity) {
+              return getGeolocationDisplayString(cellValue, data);
+            }
+            return cellValue ? cellValue[geoGranularity] : null;
+          }
+        case CellType.LINK:
+          {
+            var linkCellValue = formulaRow && formulaRow[key];
+            if (!Array.isArray(linkCellValue)) {
+              return [];
+            }
+            return linkCellValue.map(function (linkVal) {
+              return linkVal.display_value;
+            });
+          }
+        case CellType.CHECKBOX:
+          {
+            return String(!!cellValue);
+          }
+        case CellType.RATE:
+          {
+            if (!cellValue) return null;
+            return cellValue + '';
+          }
+        default:
+          {
+            return null;
+          }
+      }
+    }
+  }, {
+    key: "sortStatistics",
+    value: function sortStatistics(statistics, column, sort_key) {
+      var column_type = column.type,
+        data = column.data;
+      var sortType = 'up';
+      var option_id_index_map = {};
+      if (column_type === CellType.SINGLE_SELECT) {
+        var _ref3 = data || {},
+          options = _ref3.options;
+        Array.isArray(options) && options.forEach(function (option, index) {
+          option_id_index_map[option.id] = index;
+        });
+      }
+      statistics.sort(function (currResult, nextResult) {
+        var current = currResult[sort_key];
+        var next = nextResult[sort_key];
+        if (!current && current !== 0) {
+          return -1;
+        }
+        if (!next && next !== 0) {
+          return 1;
+        }
+        if (SUPPORT_SORT_COLUMNS.includes(column_type)) {
+          switch (column_type) {
+            case CellType.NUMBER:
+              {
+                if (current) {
+                  current = current - 0;
+                }
+                if (next) {
+                  next = next - 0;
+                }
+                return sortNumber(current, next, sortType);
+              }
+            case CellType.DATE:
+            case CellType.CTIME:
+            case CellType.MTIME:
+              {
+                return sortDate(current, next, sortType);
+              }
+            case CellType.SINGLE_SELECT:
+            case CellType.MULTIPLE_SELECT:
+              {
+                return sortSingleSelect(current, next, {
+                  sort_type: sortType,
+                  option_id_index_map: option_id_index_map
+                });
+              }
+            case CellType.FORMULA:
+            case CellType.LINK_FORMULA:
+              {
+                var _ref4 = data || {},
+                  result_type = _ref4.result_type;
+                if (result_type === FORMULA_RESULT_TYPE.NUMBER) {
+                  if (current) {
+                    current = current - 0;
+                  }
+                  if (next) {
+                    next = next - 0;
+                  }
+                  return sortNumber(current, next, sortType);
+                }
+                return sortText(result_type, current, next, sortType);
+              }
+            default:
+              {
+                return sortText(current, next, sortType);
+              }
+          }
+        }
+      });
+    }
+  }, {
+    key: "sortStatisticData",
+    value: function sortStatisticData(statistics, sort_type) {
+      statistics.sort(function (currResult, nextResult) {
+        var current = currResult.value;
+        var next = nextResult.value;
+        if (!current && current !== 0) {
+          return -1;
+        }
+        if (!next && next !== 0) {
+          return 1;
+        }
+        if (sort_type === 'ascending') {
+          return current > next ? 1 : -1;
+        } else {
+          return current > next ? -1 : 1;
+        }
+      });
+    }
+  }, {
+    key: "getTotal",
+    value: function getTotal(summary_column_key, summary_column_type, summary_type, summary_method) {
+      var rows = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+      var formula_rows = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+      var rowsLength = rows.length;
+      var total;
+      if (summary_type === STATISTICS_COUNT_TYPE.COUNT) {
+        total = rowsLength;
+      } else if (summary_type === STATISTICS_COUNT_TYPE.ADVANCED) {
+        switch (summary_method) {
+          case 'Distinct_values':
+            {
+              var count = 0;
+              var existMap = {};
+              rows.forEach(function (r) {
+                var num;
+                if (FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                  var formulaRow = formula_rows[r._id] || {};
+                  num = formulaRow[summary_column_key];
+                  num = Array.isArray(num) ? num[0] : num;
+                } else {
+                  num = r[summary_column_key];
+                }
+                if (!num) {
+                  if (num === 0) {
+                    num = '0';
+                  } else {
+                    num = !!num;
+                  }
+                }
+                if (!existMap[num]) {
+                  existMap[num] = true;
+                  count++;
+                }
+              });
+              total = count;
+              break;
+            }
+          case 'Sum':
+          case 'Mean':
+            {
+              var sum = 0;
+              var validNumbersCount = 0;
+              rows.forEach(function (r) {
+                var num;
+                if (FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                  var formulaRow = formula_rows[r._id] || {};
+                  num = formulaRow[summary_column_key];
+                  num = Array.isArray(num) ? num[0] : num;
+                } else {
+                  num = r[summary_column_key];
+                }
+                if (isNumber(num)) {
+                  validNumbersCount++;
+                  sum += num;
+                }
+              });
+              if (summary_method === 'Sum') {
+                total = Number.parseFloat(sum.toFixed(8));
+              } else if (summary_method === 'Mean') {
+                total = validNumbersCount === 0 ? 0 : Number.parseFloat((sum / validNumbersCount).toFixed(8));
+              }
+              break;
+            }
+          case 'Max':
+          case 'Min':
+            {
+              if (rowsLength > 0) {
+                var result = rows.reduce(function (current, next) {
+                  var currentValue, nextValue;
+                  if (FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                    var currentFormulaRow = formula_rows[current._id];
+                    var nextFormulaRow = formula_rows[next._id];
+                    currentValue = currentFormulaRow && currentFormulaRow[summary_column_key];
+                    nextValue = nextFormulaRow && nextFormulaRow[summary_column_key];
+                    currentValue = Array.isArray(currentValue) ? currentValue[0] : currentValue;
+                    nextValue = Array.isArray(nextValue) ? nextValue[0] : nextValue;
+                  } else {
+                    currentValue = current[summary_column_key];
+                    nextValue = next[summary_column_key];
+                  }
+                  if (!nextValue && nextValue !== 0) {
+                    return current;
+                  }
+                  var isNextGreater = currentValue < nextValue;
+                  if (summary_method === 'Min') {
+                    return isNextGreater ? current : next;
+                  } else {
+                    return isNextGreater ? next : current;
+                  }
+                });
+                if (FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                  var formulaRow = formula_rows[result._id];
+                  total = formulaRow && formulaRow[summary_column_key];
+                  total = Array.isArray(total) ? total[0] : total;
+                } else {
+                  total = result[summary_column_key];
+                }
+              }
+              break;
+            }
+          default:
+            {
+              break;
+            }
+        }
+      }
+      return total || 0;
+    }
+  }, {
+    key: "getFormattedValue",
+    value: function getFormattedValue(value, column) {
+      if (!column) {
+        return value;
+      }
+      var type = column.type,
+        data = column.data;
+      if (FORMULA_COLUMN_TYPES_MAP[type]) {
+        return getClientFormulaDisplayString(value, data);
+      }
+      if (isNumericColumn(column)) {
+        return getNumberDisplayString(value, data);
+      }
+      return value;
+    }
+  }]);
+  return StatUtils;
+}();
+export default StatUtils;

package/es/utils/trend-utils.js

@@ -0,0 +1,136 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import dayjs from 'dayjs';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import { getSummaryResult } from './common-utils';
+import { DATE_GRANULARITY, SUMMARY_TYPE } from '../constants';
+dayjs.extend(quarterOfYear);
+export function getCompareDate(dateGranularity) {
+  var currentDate = dayjs();
+  switch (dateGranularity) {
+    case DATE_GRANULARITY.DAY:
+      {
+        var compareDate = dayjs(currentDate).subtract(1, 'days').format('YYYY-MM-DD');
+        var comparedDate = dayjs(currentDate).subtract(2, 'days').format('YYYY-MM-DD');
+        return {
+          compareDate: compareDate,
+          comparedDate: comparedDate
+        };
+      }
+    case DATE_GRANULARITY.WEEK:
+      {
+        var currentWeek = dayjs().day(1);
+        var _compareDate = dayjs(currentWeek).subtract(1, 'weeks').format('YYYY-MM-DD');
+        var _comparedDate = dayjs(currentWeek).subtract(2, 'weeks').format('YYYY-MM-DD');
+        return {
+          compareDate: _compareDate,
+          comparedDate: _comparedDate
+        };
+      }
+    case DATE_GRANULARITY.MONTH:
+      {
+        var _compareDate2 = dayjs(currentDate).subtract(1, 'months').format('YYYY-MM');
+        var _comparedDate2 = dayjs(currentDate).subtract(2, 'months').format('YYYY-MM');
+        return {
+          compareDate: _compareDate2,
+          comparedDate: _comparedDate2
+        };
+      }
+    case DATE_GRANULARITY.QUARTER:
+      {
+        var currentQuarter = dayjs().quarter();
+        var currentYear = dayjs().year();
+        var lastQuarter = currentQuarter - 1;
+        var _compareDate3, _comparedDate3;
+        if (lastQuarter < 1) {
+          _compareDate3 = currentYear - 1 + '-Q4';
+          _comparedDate3 = currentYear - 1 + '-Q3';
+          return {
+            compareDate: _compareDate3,
+            comparedDate: _comparedDate3
+          };
+        }
+        _compareDate3 = currentYear + '-Q' + lastQuarter;
+        _comparedDate3 = currentYear + '-Q' + (lastQuarter - 1);
+        if (lastQuarter - 1 < 1) {
+          _comparedDate3 = currentYear - 1 + '-Q4';
+        }
+        return {
+          compareDate: _compareDate3,
+          comparedDate: _comparedDate3
+        };
+      }
+    case DATE_GRANULARITY.YEAR:
+      {
+        var _currentYear = dayjs().year();
+        return {
+          compareDate: _currentYear - 1 + '',
+          comparedDate: _currentYear - 2 + ''
+        };
+      }
+    default:
+      {
+        return {};
+      }
+  }
+}
+export function summaryDurationResult(result, duration, summaryType, summaryMethod, useDataDb, dbDateKey, valueKey) {
+  var currentTime = dayjs();
+  var days = duration === 'days_30' ? 30 : 7;
+  var endDate = currentTime.format('YYYY-MM-DD');
+  var middleDate = currentTime.subtract(days, 'days').format('YYYY-MM-DD');
+  var startDate = currentTime.subtract(days, 'days').format('YYYY-MM-DD');
+  var compareValue = [];
+  var comparedValue = [];
+  if (useDataDb) {
+    var days1 = [];
+    var days2 = [];
+    for (var index = 0; index < result.length; index++) {
+      var item = result[index];
+      var key = item[dbDateKey];
+      if (key >= startDate && key < middleDate) {
+        comparedValue.push(item[valueKey]);
+        days1.push(key);
+      } else if (key >= middleDate && key < endDate) {
+        compareValue.push(item[valueKey]);
+        days2.push(key);
+      }
+    }
+  } else {
+    var _iterator = _createForOfIteratorHelper(result),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _item = _step.value;
+        var _key = _item[0];
+        if (_key >= startDate && _key < middleDate) {
+          if (summaryType === SUMMARY_TYPE.ADVANCED) {
+            comparedValue = comparedValue.concat(_item[1] || []);
+          } else {
+            comparedValue.push(_item[1]);
+          }
+        } else if (_key >= middleDate && _key < endDate) {
+          if (summaryType === SUMMARY_TYPE.ADVANCED) {
+            compareValue = compareValue.concat(_item[1] || []);
+          } else {
+            compareValue.push(_item[1]);
+          }
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  if (summaryType === SUMMARY_TYPE.ADVANCED) {
+    comparedValue = getSummaryResult(comparedValue, summaryMethod);
+    compareValue = getSummaryResult(compareValue, summaryMethod);
+  } else {
+    compareValue = getSummaryResult(compareValue, 'Sum');
+    comparedValue = getSummaryResult(comparedValue, 'Sum');
+  }
+  return {
+    compareValue: compareValue,
+    comparedValue: comparedValue
+  };
+}

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./dist/dtable-statistic');

package/package.json

@@ -0,0 +1,188 @@
+{
+  "name": "dtable-statistic",
+  "version": "4.0.2-test-2",
+  "description": "statistics",
+  "main": "dist/dtable-statistic.js",
+  "author": "seafile",
+  "private": false,
+  "dependencies": {
+    "@antv/data-set": "^0.11.8",
+    "@antv/g2": "^4.1.42",
+    "@antv/util": "^3.3.2",
+    "@seafile/seafile-calendar": "0.0.24",
+    "comlink": "^4.3.1",
+    "dayjs": "1.10.7",
+    "dtable-store": "4.0.2",
+    "dtable-web-api": "4.0.1",
+    "html2canvas": "^1.4.1",
+    "rc-slider": "^9.7.4",
+    "react": "16.14.0",
+    "react-color": "2.19.3",
+    "react-dom": "16.14.0",
+    "react-grid-layout": "^1.2.5",
+    "react-intl-universal": "^2.4.8",
+    "react-select": "^3.1.0",
+    "reactstrap": "8.9.0"
+  },
+  "scripts": {
+    "clean:esm": "rm -rf es && mkdir es",
+    "clean:lib": "rm -rf lib && mkdir lib",
+    "clean:dist": "rm -rf dist && mkdir dist",
+    "start": "node scripts/start.js",
+    "build": "node scripts/build.js",
+    "test": "node scripts/test.js",
+    "translate": "node scripts/translate.js",
+    "push-translate": "tx push -s",
+    "pull-translate": "tx pull -a -f && npm run translate",
+    "pub:esm": "npm run clean:esm && export BABEL_ENV=production && ./node_modules/.bin/babel src --out-dir es --copy-files",
+    "pub:optimized": "rm es/settings.js es/index.local.*",
+    "prepublishOnly": "npm run pub:esm && npm run pub:optimized"
+  },
+  "files": [
+    "es",
+    "index.js",
+    "package.json"
+  ],
+  "eslintConfig": {
+    "extends": "react-app"
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  },
+  "jest": {
+    "roots": [
+      "<rootDir>/src"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.{js,jsx,ts,tsx}",
+      "!src/**/*.d.ts"
+    ],
+    "setupFiles": [
+      "react-app-polyfill/jsdom"
+    ],
+    "setupFilesAfterEnv": [
+      "<rootDir>/src/setupTests.js"
+    ],
+    "testMatch": [
+      "<rootDir>/src/**/__tests__/**/*.{js,jsx,ts,tsx}",
+      "<rootDir>/src/**/*.{spec,test}.{js,jsx,ts,tsx}"
+    ],
+    "testEnvironment": "jest-environment-jsdom-fourteen",
+    "transform": {
+      "^.+\\.(js|jsx|ts|tsx)$": "<rootDir>/node_modules/babel-jest",
+      "^.+\\.css$": "<rootDir>/config/jest/cssTransform.js",
+      "^(?!.*\\.(js|jsx|ts|tsx|css|json)$)": "<rootDir>/config/jest/fileTransform.js"
+    },
+    "transformIgnorePatterns": [
+      "[/\\\\]node_modules[/\\\\].+\\.(js|jsx|ts|tsx)$",
+      "^.+\\.module\\.(css|sass|scss)$"
+    ],
+    "modulePaths": [],
+    "moduleNameMapper": {
+      "^react-native$": "react-native-web",
+      "^.+\\.module\\.(css|sass|scss)$": "identity-obj-proxy"
+    },
+    "moduleFileExtensions": [
+      "web.js",
+      "js",
+      "web.ts",
+      "ts",
+      "web.tsx",
+      "tsx",
+      "json",
+      "web.jsx",
+      "jsx",
+      "node"
+    ],
+    "watchPlugins": [
+      "jest-watch-typeahead/filename",
+      "jest-watch-typeahead/testname"
+    ]
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.4.4",
+    "@babel/core": "7.4.3",
+    "@babel/plugin-proposal-class-properties": "^7.4.4",
+    "@babel/plugin-proposal-export-default-from": "^7.5.2",
+    "@babel/plugin-proposal-export-namespace-from": "^7.5.2",
+    "@babel/plugin-proposal-object-rest-spread": "^7.5.2",
+    "@babel/plugin-transform-member-expression-literals": "^7.2.0",
+    "@babel/plugin-transform-property-literals": "^7.2.0",
+    "@babel/plugin-transform-runtime": "^7.4.4",
+    "@babel/preset-env": "^7.4.5",
+    "@babel/preset-react": "^7.0.0",
+    "@babel/runtime": "^7.14.0",
+    "@svgr/webpack": "4.1.0",
+    "@typescript-eslint/eslint-plugin": "1.6.0",
+    "@typescript-eslint/parser": "1.6.0",
+    "babel-eslint": "10.0.1",
+    "babel-jest": "^24.8.0",
+    "babel-loader": "8.0.5",
+    "babel-plugin-named-asset-import": "^0.3.2",
+    "babel-preset-react-app": "^9.0.0",
+    "camelcase": "^5.2.0",
+    "case-sensitive-paths-webpack-plugin": "2.2.0",
+    "css-loader": "^3.0.0",
+    "debug": "^4.1.1",
+    "dotenv": "6.2.0",
+    "dotenv-expand": "4.2.0",
+    "enzyme": "^3.10.0",
+    "enzyme-adapter-react-16": "^1.14.0",
+    "eslint": "^5.16.0",
+    "eslint-config-react-app": "^4.0.1",
+    "eslint-loader": "2.1.2",
+    "eslint-plugin-flowtype": "2.50.1",
+    "eslint-plugin-import": "2.16.0",
+    "eslint-plugin-jsx-a11y": "6.2.1",
+    "eslint-plugin-react": "7.12.4",
+    "eslint-plugin-react-hooks": "^1.5.0",
+    "file-loader": "^4.0.0",
+    "fs-extra": "7.0.1",
+    "html-webpack-plugin": "4.0.0-beta.5",
+    "identity-obj-proxy": "3.0.0",
+    "is-wsl": "^1.1.0",
+    "jest": "24.7.1",
+    "jest-environment-jsdom-fourteen": "0.1.0",
+    "jest-resolve": "24.7.1",
+    "jest-watch-typeahead": "0.3.0",
+    "less": "^3.10.3",
+    "less-loader": "^5.0.0",
+    "mini-css-extract-plugin": "0.5.0",
+    "optimize-css-assets-webpack-plugin": "5.0.1",
+    "pnp-webpack-plugin": "1.2.1",
+    "postcss-flexbugs-fixes": "^4.1.0",
+    "postcss-loader": "^3.0.0",
+    "postcss-normalize": "7.0.1",
+    "postcss-preset-env": "6.6.0",
+    "postcss-safe-parser": "4.0.1",
+    "react": "16.14.0",
+    "react-app-polyfill": "^1.0.1",
+    "react-dev-utils": "^9.0.1",
+    "react-dom": "16.14.0",
+    "resolve": "1.10.0",
+    "sass-loader": "^7.1.0",
+    "semver": "6.0.0",
+    "style-loader": "^0.23.1",
+    "svg-sprite-loader": "^6.0.11",
+    "svgo-loader": "^3.0.0",
+    "terser-webpack-plugin": "^1.2.3",
+    "ts-pnp": "1.1.2",
+    "url-loader": "^2.0.0",
+    "webpack": "4.29.6",
+    "webpack-bundle-analyzer": "^4.7.0",
+    "webpack-cli": "^3.3.4",
+    "webpack-dev-server": "3.2.1",
+    "webpack-manifest-plugin": "2.0.4",
+    "workbox-webpack-plugin": "4.2.0",
+    "worker-loader": "^3.0.8"
+  }
+}