dtable-statistic 4.2.2 → 4.3.1

package/es/api/dtable-db-api.js

@@ -1,43 +1,37 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import axios from 'axios';
-var DTableDbAPI = /*#__PURE__*/function () {
-  function DTableDbAPI() {
-    _classCallCheck(this, DTableDbAPI);
+class DTableDbAPI {
+  constructor() {
     this.req = null;
   }
-  _createClass(DTableDbAPI, [{
-    key: "init",
-    value: function init() {
-      if (this.req) return;
-      var _window$dtable = window.dtable,
-        accessToken = _window$dtable.accessToken,
-        dtableDb = _window$dtable.dtableDb;
-      this.req = axios.create({
-        baseURL: dtableDb,
-        headers: {
-          'Authorization': 'Token ' + accessToken
-        }
-      });
-    }
-  }, {
-    key: "sqlQuery",
-    value: function sqlQuery(sql, parameters) {
-      var convert_keys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-      this.init();
-      var dtableUuid = window.dtable.dtableUuid;
-      var url = 'api/v1/query/' + dtableUuid;
-      var data = {
-        sql: sql,
-        convert_keys: convert_keys
-      };
-      if (parameters) {
-        data['parameters'] = parameters;
+  init() {
+    if (this.req) return;
+    const {
+      accessToken,
+      dtableDb
+    } = window.dtable;
+    this.req = axios.create({
+      baseURL: dtableDb,
+      headers: {
+        'Authorization': 'Token ' + accessToken
       }
-      return this.req.post(url, data);
+    });
+  }
+  sqlQuery(sql, parameters) {
+    let convert_keys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    this.init();
+    const {
+      dtableUuid
+    } = window.dtable;
+    const url = 'api/v1/query/' + dtableUuid;
+    let data = {
+      sql: sql,
+      convert_keys
+    };
+    if (parameters) {
+      data['parameters'] = parameters;
     }
-  }]);
-  return DTableDbAPI;
-}();
-var dtableDbAPI = new DTableDbAPI();
+    return this.req.post(url, data);
+  }
+}
+const dtableDbAPI = new DTableDbAPI();
 export default dtableDbAPI;

package/es/calculator/base-calculator.js

@@ -1,111 +1,61 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import * as ComLink from 'comlink';
 import { TableUtils, Views } from 'dtable-store';
 import dtableDbAPI from '../api/dtable-db-api';
 import CalculatorWorker from './workers/calculator.worker.js';
 import copyValue from './copy-value';
-var BaseCalculator = /*#__PURE__*/function () {
-  function BaseCalculator(_ref) {
-    var username = _ref.username,
-      userId = _ref.userId,
-      value = _ref.value,
-      statisticThreadManager = _ref.statisticThreadManager;
-    _classCallCheck(this, BaseCalculator);
+class BaseCalculator {
+  constructor(_ref) {
+    let {
+      username,
+      userId,
+      value,
+      statisticThreadManager
+    } = _ref;
     this.username = username;
     this.userId = userId;
     this.value = value;
     this.statisticThreadManager = statisticThreadManager;
   }
-  _createClass(BaseCalculator, [{
-    key: "validateBaseConfigs",
-    value: function validateBaseConfigs(chart) {
-      var table_id = chart.table_id,
-        view_id = chart.view_id;
-      var table = this.getTableById(table_id);
-      var view = this.getViewById(view_id, table);
-      if (!view) {
-        return false;
-      }
-      return true;
+  validateBaseConfigs(chart) {
+    const {
+      table_id,
+      view_id
+    } = chart;
+    const table = this.getTableById(table_id);
+    const view = this.getViewById(view_id, table);
+    if (!view) {
+      return false;
     }
-  }, {
-    key: "isCalcByQueryDB",
-    value: function isCalcByQueryDB(chart) {
-      var table_id = chart.table_id,
-        view_id = chart.view_id;
-      var table = this.getTableById(table_id);
-      var view = this.getViewById(view_id, table);
-      return Views.isArchiveView(view);
-    }
-  }, {
-    key: "getTableById",
-    value: function getTableById(tableId) {
-      return TableUtils.getTableById(this.value.tables, tableId);
-    }
-  }, {
-    key: "getViewById",
-    value: function getViewById(viewId, table) {
-      return table && Views.getViewById(table.views, viewId);
-    }
-  }, {
-    key: "calculateWithWorker",
-    value: function () {
-      var _calculateWithWorker = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chart) {
-        var chartId, calculatorWorker, calculateChart, newValue, result;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                chartId = chart._id;
-                _context.next = 3;
-                return this.statisticThreadManager.applyThread(chartId, CalculatorWorker);
-              case 3:
-                calculatorWorker = _context.sent;
-                calculateChart = ComLink.wrap(calculatorWorker);
-                newValue = copyValue(this.value);
-                _context.next = 8;
-                return calculateChart(chart, newValue, this.username, this.userId);
-              case 8:
-                result = _context.sent;
-                this.statisticThreadManager.removeThread(chartId);
-                return _context.abrupt("return", result);
-              case 11:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-      function calculateWithWorker(_x) {
-        return _calculateWithWorker.apply(this, arguments);
-      }
-      return calculateWithWorker;
-    }()
-  }, {
-    key: "sqlQuery",
-    value: function () {
-      var _sqlQuery = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(sql) {
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                return _context2.abrupt("return", dtableDbAPI.sqlQuery(sql));
-              case 1:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2);
-      }));
-      function sqlQuery(_x2) {
-        return _sqlQuery.apply(this, arguments);
-      }
-      return sqlQuery;
-    }()
-  }]);
-  return BaseCalculator;
-}();
+    return true;
+  }
+  isCalcByQueryDB(chart) {
+    const {
+      table_id,
+      view_id
+    } = chart;
+    const table = this.getTableById(table_id);
+    const view = this.getViewById(view_id, table);
+    return Views.isArchiveView(view);
+  }
+  getTableById(tableId) {
+    return TableUtils.getTableById(this.value.tables, tableId);
+  }
+  getViewById(viewId, table) {
+    return table && Views.getViewById(table.views, viewId);
+  }
+  async calculateWithWorker(chart) {
+    const {
+      _id: chartId
+    } = chart;
+    const calculatorWorker = await this.statisticThreadManager.applyThread(chartId, CalculatorWorker);
+    const calculateChart = ComLink.wrap(calculatorWorker);
+    const newValue = copyValue(this.value);
+    const result = await calculateChart(chart, newValue, this.username, this.userId);
+    this.statisticThreadManager.removeThread(chartId);
+    return result;
+  }
+  async sqlQuery(sql) {
+    return dtableDbAPI.sqlQuery(sql);
+  }
+}
 export default BaseCalculator;