dtable-statistic 5.0.48-alpha.2 → 5.0.48-alpha.20

package/es/dashboard.js

@@ -17,6 +17,7 @@ var _mobileDashboard = _interopRequireDefault(require("./mobile-dashboard"));
 var _utils = require("./utils");
 var _commonUtils = require("./utils/common-utils");
 var _constants = require("./constants");
+var _threadManager = _interopRequireDefault(require("./utils/formula-calc-worker/thread-manager"));
 require("./locale");
 require("./assets/css/dashboard.css");
 require("./assets/css/theme.css");
@@ -123,9 +124,14 @@ class DashBoard extends _react.Component {
         activeView
       });
     };
+    this.cancelCalculation = () => {
+      _threadManager.default.clearQueue();
+      _threadManager.default.terminateWorkers();
+    };
     this.selectDashboard = selectedDashboardIdx => {
       this.disabledUpdateLayout = true;
       this.setSelectedDashboardIdx(selectedDashboardIdx);
+      this.cancelCalculation();
       this.setState({
         selectedDashboardIdx
       });
@@ -158,6 +164,7 @@ class DashBoard extends _react.Component {
       });
       const selectedDashboardIdx = updatedStatistics.length - 1;
       this.setSelectedDashboardIdx(selectedDashboardIdx);
+      this.cancelCalculation();
       this.updateStatistics({
         statistics: updatedStatistics,
         selectedDashboardIdx
@@ -196,6 +203,7 @@ class DashBoard extends _react.Component {
         }
       });
       this.setSelectedDashboardIdx(nextSelectedDashboardIdx);
+      this.cancelCalculation();
       this.updateStatistics({
         statistics: updatedStatistics,
         selectedDashboardIdx: nextSelectedDashboardIdx
@@ -375,6 +383,7 @@ class DashBoard extends _react.Component {
   componentWillUnmount() {
     this.unsubscribeLocalDtableChanged();
     this.unsubscribeRemoteDtableChange();
+    this.cancelCalculation();
   }
   render() {
     const {

package/es/index.js

@@ -5,6 +5,7 @@ var _react = _interopRequireDefault(require("react"));
 var _dtableStore = require("dtable-store");
 var _dashboard = _interopRequireDefault(require("./dashboard"));
 var _calcWithWorker = require("./utils/formula-calc-worker/calc-with-worker");
+var _resultCacheManager = require("./utils/formula-calc-worker/result-cache-manager");
 class Statistic {
   static getInitProps() {
     if (!window || !window.app) {
@@ -41,10 +42,10 @@ class Statistic {
       userId = null,
       userDepartmentIdsMap = null
     } = dtableStore.dtableSettings;
-    const rows = await (0, _calcWithWorker.calcViewRowsWithWorker)(view, table, this.dtableStore.value, username, userId, userDepartmentIdsMap);
+    const rows = await (0, _calcWithWorker.calcViewRowsWithWorker)(view, table, dtableStore.value, username, userId, userDepartmentIdsMap);
     return rows;
   }
-  static async getTableFormulaResults(table, rows) {
+  static async getTableFormulaResults(table, rows, value, viewId) {
     const dtableStore = window.app.dtableStore || {};
     const {
       username = null,
@@ -52,7 +53,7 @@ class Statistic {
       userDepartmentIdsMap = null
     } = dtableStore.dtableSettings;
     const formulaColumns = _dtableStore.Views.getFormulaColumnsContainLinks(table);
-    const res = await (0, _calcWithWorker.calcFormulaResultsWithWorker)(table, rows, this.dtableStore.value, formulaColumns, username, userId, userDepartmentIdsMap);
+    const res = await (0, _calcWithWorker.calcFormulaResultsWithWorker)(table, rows, dtableStore.value, formulaColumns, username, userId, userDepartmentIdsMap, viewId);
     return res;
   }
   static updateStatistics(dtableStore, statistics) {
@@ -73,6 +74,9 @@ class Statistic {
       animation: true
     };
     if (!window.app) return;
+    _resultCacheManager.viewRowsCacheManager.clear();
+    _resultCacheManager.formulaResultsCacheManager.clear();
+    (0, _resultCacheManager.clearCachedBase)();
     window.app.unmountWidget({
       animation
     });

package/es/utils/formula-calc-worker/calc-with-worker.js

@@ -1,51 +1,86 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.calcFormulaResultsWithWorker = calcFormulaResultsWithWorker;
 exports.calcViewRowsWithWorker = calcViewRowsWithWorker;
-function calcViewRowsWithWorker(view, table, value) {
-  return new Promise((resolve, reject) => {
-    const worker = new Worker(new URL('./calc-view-rows-worker.js', import.meta.url), {
-      type: 'module'
-    });
-    worker.postMessage({
-      view,
-      table,
-      value
-    });
-    worker.onmessage = function (e) {
-      resolve(e.data);
-      worker.terminate();
-    };
-    worker.onerror = function (e) {
-      reject(e);
-      worker.terminate();
-    };
+var Comlink = _interopRequireWildcard(require("comlink"));
+var _calc = _interopRequireDefault(require("./calc.worker"));
+var _resultCacheManager = require("./result-cache-manager");
+var _threadManager = _interopRequireDefault(require("./thread-manager"));
+var _lodashEs = require("lodash-es");
+var _hasReactElement = require("../hasReactElement");
+function uuid() {
+  return Math.random().toString(36).slice(2, 9);
+}
+async function calcViewRowsWithWorker(view, table, value, username, userId, userDepartmentIdsMap) {
+  const key = view._id + table._id;
+  const cachedRows = _resultCacheManager.viewRowsCacheManager.get(key);
+  if (cachedRows) {
+    return cachedRows;
+  }
+  if (!_resultCacheManager.cachedBase) {
+    (0, _resultCacheManager.initCachedBase)(value);
+  }
+  const clonedTable = (0, _lodashEs.cloneDeep)(table);
+  // Symbol can't passed to workers
+  clonedTable.columns = clonedTable.columns.map(c => {
+    delete c.editor;
+    delete c.formatter;
+    return c;
   });
+  (0, _hasReactElement.containsReactElementSymbol)(_resultCacheManager.cachedBase);
+  (0, _hasReactElement.containsReactElementSymbol)(clonedTable);
+  const workerId = uuid();
+  let worker;
+  try {
+    worker = await _threadManager.default.applyThread(workerId, _calc.default);
+  } catch (e) {
+    return [];
+  }
+  const calcWorker = Comlink.wrap(worker);
+  const rows = await calcWorker.getViewRows(view, clonedTable, _resultCacheManager.cachedBase, username, userId, userDepartmentIdsMap);
+  _resultCacheManager.viewRowsCacheManager.set(key, rows);
+  _threadManager.default.removeThread(workerId);
+  return rows;
 }
-function calcFormulaResultsWithWorker(table, rows, value, formulaColumns, username, userId, userDepartmentIdsMap) {
-  return new Promise((resolve, reject) => {
-    const worker = new Worker(new URL('./calc-formula-result-worker.js', import.meta.url), {
-      type: 'module'
-    });
-    worker.postMessage({
-      table,
-      rows,
-      value,
-      formulaColumns,
-      username,
-      userId,
-      userDepartmentIdsMap
-    });
-    worker.onmessage = function (e) {
-      resolve(e.data);
-      worker.terminate();
-    };
-    worker.onerror = function (e) {
-      reject(e);
-      worker.terminate();
-    };
+async function calcFormulaResultsWithWorker(table, rows, value, formulaColumns, username, userId, userDepartmentIdsMap, viewId) {
+  const key = viewId + table._id;
+  const cachedResults = _resultCacheManager.formulaResultsCacheManager.get(key);
+  if (cachedResults) {
+    return cachedResults;
+  }
+  if (!_resultCacheManager.cachedBase) {
+    (0, _resultCacheManager.initCachedBase)(value);
+  }
+  const clonedTable = (0, _lodashEs.cloneDeep)(table);
+  // Symbol can't passed to workers
+  clonedTable.columns = clonedTable.columns.map(c => {
+    delete c.editor;
+    delete c.formatter;
+    return c;
+  });
+  let clonedFormulaColumns = (0, _lodashEs.cloneDeep)(formulaColumns);
+  clonedFormulaColumns = clonedFormulaColumns.map(c => {
+    delete c.editor;
+    delete c.formatter;
+    return c;
   });
+  (0, _hasReactElement.containsReactElementSymbol)(_resultCacheManager.cachedBase);
+  (0, _hasReactElement.containsReactElementSymbol)(clonedTable);
+  const workerId = uuid();
+  let worker;
+  try {
+    worker = await _threadManager.default.applyThread(workerId, _calc.default);
+  } catch (e) {
+    return [];
+  }
+  const calcWorker = Comlink.wrap(worker);
+  const results = await calcWorker.getTableFormulaResults(clonedTable, rows, _resultCacheManager.cachedBase, clonedFormulaColumns, username, userId, userDepartmentIdsMap);
+  _resultCacheManager.formulaResultsCacheManager.set(key, results);
+  _threadManager.default.removeThread(workerId);
+  return results;
 }

package/es/utils/formula-calc-worker/calc.worker.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var Comlink = _interopRequireWildcard(require("comlink"));
+var _dtableStore = require("dtable-store");
+// async function calc(callback) {
+//   const res =  await callback();
+//   return res;
+// }
+// Comlink.expose(calc);
+const workerFunctions = {
+  async getViewRows(view, table, value, username, userId, userDepartmentIdsMap) {
+    return _dtableStore.Views.getViewRows(view, table, value, username, userId, userDepartmentIdsMap);
+  },
+  async getTableFormulaResults(table, rows, value, formulaColumns, username, userId, userDepartmentIdsMap) {
+    return _dtableStore.Views.getTableFormulaResults(table, rows, value, formulaColumns, {
+      username,
+      userId,
+      userDepartmentIdsMap
+    });
+  }
+};
+Comlink.expose(workerFunctions);

package/es/utils/formula-calc-worker/result-cache-manager.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cachedBase = void 0;
+exports.clearCachedBase = clearCachedBase;
+exports.formulaResultsCacheManager = void 0;
+exports.initCachedBase = initCachedBase;
+exports.viewRowsCacheManager = void 0;
+var _lodashEs = require("lodash-es");
+class ResultCacheManager {
+  constructor() {
+    this.cache = new Map();
+  }
+  get(key) {
+    return this.cache.get(key);
+  }
+  set(key, value) {
+    this.cache.set(key, value);
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+const viewRowsCacheManager = exports.viewRowsCacheManager = new ResultCacheManager();
+const formulaResultsCacheManager = exports.formulaResultsCacheManager = new ResultCacheManager();
+let cachedBase = exports.cachedBase = null;
+function initCachedBase(value) {
+  // don't clone rows cause they are really big
+  const tableIdRowMap = {};
+  value.tables.forEach(t => {
+    tableIdRowMap[t._id] = t === null || t === void 0 ? void 0 : t.rows;
+    t.rows && delete t.rows;
+  });
+  const clonedBase = (0, _lodashEs.cloneDeep)(value);
+  clonedBase.tables.forEach(t => {
+    // delete symbols
+    t.columns = t.columns.map(c => {
+      delete c.editor;
+      delete c.formatter;
+      return c;
+    });
+    t.rows = tableIdRowMap[t._id];
+  });
+  value.tables.forEach(t => {
+    t.rows = tableIdRowMap[t._id];
+  });
+  exports.cachedBase = cachedBase = clonedBase;
+}
+function clearCachedBase() {
+  exports.cachedBase = cachedBase = null;
+}

package/es/utils/formula-calc-worker/thread-manager.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class ThreadManager {
+  constructor(threadCount) {
+    const supportedThreads = navigator.hardwareConcurrency;
+    // prevent the browser from freezing by leaving 3 threads for the main thread
+    if (typeof supportedThreads === 'number' && supportedThreads - 3 > 0) {
+      this.threadCount = supportedThreads - 3;
+    } else {
+      this.threadCount = 2;
+    }
+    this.threadList = [];
+    this.queue = [];
+  }
+  async applyThread(id, workerConstructor) {
+    return new Promise((resolve, reject) => {
+      if (this.threadList.length < this.threadCount) {
+        const worker = new workerConstructor();
+        worker.id = id;
+        this.threadList.push(worker);
+        resolve(worker);
+      } else {
+        this.queue.push({
+          id,
+          emitter: resolve,
+          rejector: reject,
+          workerConstructor
+        });
+      }
+    });
+  }
+  removeThread(id) {
+    const index = this.threadList.findIndex(worker => worker.id === id);
+    if (index > -1) {
+      this.threadList[index] && this.threadList[index].terminate();
+      this.threadList.splice(index, 1);
+    }
+    if (this.queue.length > 0) {
+      const {
+        id,
+        emitter,
+        workerConstructor
+      } = this.queue.shift();
+      const worker = new workerConstructor();
+      worker.id = id;
+      this.threadList.push(worker);
+      emitter(worker);
+    }
+  }
+  clearQueue() {
+    this.queue.forEach(_ref => {
+      let {
+        rejector
+      } = _ref;
+      return rejector();
+    });
+    this.queue = [];
+  }
+  terminateWorkers() {
+    this.threadList.forEach(item => {
+      item && item.terminate();
+    });
+    this.threadList = [];
+  }
+}
+const threadManager = new ThreadManager();
+var _default = exports.default = threadManager;

package/es/utils/hasReactElement.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.containsReactElementSymbol = containsReactElementSymbol;
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+function containsReactElementSymbol(obj) {
+  let parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  if (obj === null || typeof obj !== 'object') {
+    return false;
+  }
+
+  // Check if the current object is a React element
+  if (obj.$$typeof === REACT_ELEMENT_TYPE) {
+    console.log('Parent object containing Symbol(react.element):', parent);
+    return true;
+  }
+
+  // Recursively check all properties of the object
+  for (let key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      if (containsReactElementSymbol(obj[key], obj)) {
+        return true;
+      }
+    }
+  }
+
+  // Check symbol properties as well
+  const symbolProperties = Object.getOwnPropertySymbols(obj);
+  for (let symbol of symbolProperties) {
+    if (containsReactElementSymbol(obj[symbol], obj)) {
+      return true;
+    }
+  }
+  return false;
+}

package/es/utils/test.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dtable-statistic",
-  "version": "5.0.48-alpha.2",
+  "version": "5.0.48-alpha.20",
   "description": "statistics",
   "main": "dist/dtable-statistic.js",
   "author": "seafile",
@@ -18,8 +18,7 @@
     "react-grid-layout": "^1.2.5",
     "react-intl-universal": "^2.4.8",
     "reactstrap": "8.9.0",
-    "sea-chart": "~0.0.94"
-    
+    "sea-chart": "^0.0.95-alpha.7"
   },
   "peerDependencies": {
     "dtable-ui-component": "~5.0.*",
@@ -53,7 +52,7 @@
     "css-minimizer-webpack-plugin": "^3.2.0",
     "dotenv": "^10.0.0",
     "dotenv-expand": "^5.1.0",
-    "dtable-store": "5.0.8",
+    "dtable-store": "4.3.6",
     "dtable-ui-component": "~5.0.11",
     "dtable-utils": "5.0.0",
     "dtable-web-api": "^5.0.3",

package/es/utils/formula-calc-worker/calc-formula-result-worker.js

@@ -1,21 +0,0 @@
-"use strict";
-
-var _dtableStore = require("dtable-store");
-/* eslint-disable no-restricted-globals */
-self.onmessage = function (e) {
-  const {
-    table,
-    rows,
-    value,
-    formulaColumns,
-    username,
-    userId,
-    userDepartmentIdsMap
-  } = e.data;
-  const res = _dtableStore.Views.getTableFormulaResults(table, rows, value, formulaColumns, {
-    username,
-    userId,
-    userDepartmentIdsMap
-  });
-  self.postMessage(res);
-};

package/es/utils/formula-calc-worker/calc-view-rows-worker.js

@@ -1,16 +0,0 @@
-"use strict";
-
-var _dtableStore = require("dtable-store");
-/* eslint-disable no-restricted-globals */
-self.onmessage = function (e) {
-  const {
-    view,
-    table,
-    value,
-    username,
-    userId,
-    userDepartmentIdsMap
-  } = e.data;
-  const rows = _dtableStore.Views.getViewRows(view, table, value, username, userId, userDepartmentIdsMap);
-  self.postMessage(rows);
-};