agora-foundation 1.0.0

package/lib/utilities/misc.d.ts

@@ -0,0 +1,5 @@
+export declare const jsonstring: (json: unknown) => string;
+export declare const arr2map: <T>(arr: T[], fnKey: (ele: T) => string) => Record<string, T>;
+export declare const arr2Map: <T>(arr: T[], fnKey: (ele: T) => string) => Map<string, T>;
+export declare const sleep: (ms: number) => Promise<void>;
+export declare const randomString: (len: number) => string;

package/lib/utilities/misc.js

@@ -0,0 +1,52 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sleep = exports.randomString = exports.jsonstring = exports.arr2map = exports.arr2Map = void 0;
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.date.to-json.js");
+require("core-js/modules/es.json.stringify.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/web.timers.js");
+var jsonstring = exports.jsonstring = function jsonstring(json) {
+  try {
+    return JSON.stringify(json);
+  } catch (e) {}
+  return 'invalid json';
+};
+var arr2map = exports.arr2map = function arr2map(arr, fnKey) {
+  var map = {};
+  arr.forEach(function (ele) {
+    return map[fnKey(ele)] = ele;
+  });
+  return map;
+};
+var arr2Map = exports.arr2Map = function arr2Map(arr, fnKey) {
+  var map = new Map();
+  arr.forEach(function (ele) {
+    return map.set(fnKey(ele), ele);
+  });
+  return map;
+};
+var sleep = exports.sleep = function sleep(ms) {
+  return new Promise(function (r) {
+    setTimeout(r, ms);
+  });
+};
+var randomString = exports.randomString = function randomString(len) {
+  var characters = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  var result = '';
+  var charactersLength = characters.length;
+  for (var i = 0; i < len; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+};

package/lib/utilities/observable.d.ts

@@ -0,0 +1,11 @@
+type EventParameters<T> = T extends (...args: infer U) => any ? U : never;
+export declare class AgoraObservable<T> {
+    private _eventBus;
+    private _observers;
+    private _observerSet;
+    addObserver(observer: T): void;
+    removeObserver(observer: T): void;
+    notifyObservers<K extends keyof T>(eventName: K, ...args: EventParameters<T[K]>): void;
+    countOfObservers(): number;
+}
+export {};

package/lib/utilities/observable.js

@@ -0,0 +1,73 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AgoraObservable = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.set.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _events = require("./events");
+var AgoraObservable = exports.AgoraObservable = /*#__PURE__*/function () {
+  function AgoraObservable() {
+    (0, _classCallCheck2["default"])(this, AgoraObservable);
+    (0, _defineProperty2["default"])(this, "_eventBus", new _events.AgoraEventEmitter());
+    (0, _defineProperty2["default"])(this, "_observers", 0);
+    (0, _defineProperty2["default"])(this, "_observerSet", new Set());
+  }
+  return (0, _createClass2["default"])(AgoraObservable, [{
+    key: "addObserver",
+    value: function addObserver(observer) {
+      var _this = this;
+      if (this._observerSet.has(observer)) {
+        return;
+      }
+      var eventKeys = Object.keys(observer);
+      eventKeys.forEach(function (eventKey) {
+        if (typeof observer[eventKey] === 'function') {
+          _this._eventBus.on(eventKey, observer[eventKey]);
+        }
+      });
+      this._observers++;
+      this._observerSet.add(observer);
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      var _this2 = this;
+      var eventKeys = Object.keys(observer);
+      eventKeys.forEach(function (eventKey) {
+        if (typeof observer[eventKey] === 'function') {
+          _this2._eventBus.off(eventKey, observer[eventKey]);
+        }
+      });
+      this._observers--;
+      this._observerSet["delete"](observer);
+    }
+  }, {
+    key: "notifyObservers",
+    value: function notifyObservers(eventName) {
+      var _this$_eventBus;
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      (_this$_eventBus = this._eventBus).emit.apply(_this$_eventBus, [eventName].concat(args));
+    }
+  }, {
+    key: "countOfObservers",
+    value: function countOfObservers() {
+      return this._observers;
+    }
+  }]);
+}();

package/lib/utilities/race-condition.d.ts

@@ -0,0 +1 @@
+export declare const timeout: <T>(p: Promise<T>, ms: number) => Promise<T>;

package/lib/utilities/race-condition.js

@@ -0,0 +1,24 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.timeout = void 0;
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/web.timers.js");
+var timeout = exports.timeout = function timeout(p, ms) {
+  return Promise.race([p, new Promise(function (_, reject) {
+    setTimeout(function () {
+      return reject(new Error('race condition timeout', {
+        cause: 'timeout'
+      }));
+    }, ms);
+  })]);
+};

package/lib/utilities/value-check.d.ts

@@ -0,0 +1 @@
+export declare const isTrueValue: (value: unknown) => boolean;

package/lib/utilities/value-check.js

@@ -0,0 +1,10 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isTrueValue = void 0;
+var isTrueValue = exports.isTrueValue = function isTrueValue(value) {
+  return value === 'true' || !!value;
+};

package/lib/utilities/zip.d.ts

@@ -0,0 +1 @@
+export declare const zipDir: (dirPath: string) => Promise<File | null>;

package/lib/utilities/zip.js

@@ -0,0 +1,107 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.is-array.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.date.to-string.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.test.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.zipDir = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+var _jszip = _interopRequireDefault(require("jszip"));
+var _logger = require("../logger");
+var _dayjs = _interopRequireDefault(require("dayjs"));
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var zipDir = exports.zipDir = function zipDir(dirPath) {
+  var logger = (0, _logger.getLogger)();
+  return new Promise(function (resolve) {
+    try {
+      var fs = window.require('fs');
+      fs.readdir(dirPath, /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(err, files) {
+          var zip, _iterator, _step, _file, filePath, logsStr, blob, buffer, datefmt, file;
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                if (!err) {
+                  _context.next = 4;
+                  break;
+                }
+                console.error("failed to read log dir.", err);
+                _context.next = 20;
+                break;
+              case 4:
+                if (!(files.length === 0)) {
+                  _context.next = 8;
+                  break;
+                }
+                resolve(null);
+                _context.next = 20;
+                break;
+              case 8:
+                zip = new _jszip["default"]();
+                _iterator = _createForOfIteratorHelper(files);
+                try {
+                  for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                    _file = _step.value;
+                    filePath = "".concat(dirPath, "/").concat(_file);
+                    logsStr = fs.readFileSync(filePath, 'utf8');
+                    zip.file(_file, logsStr);
+                  }
+                } catch (err) {
+                  _iterator.e(err);
+                } finally {
+                  _iterator.f();
+                }
+                _context.next = 13;
+                return zip.generateAsync({
+                  type: 'blob'
+                });
+              case 13:
+                blob = _context.sent;
+                _context.next = 16;
+                return blob.arrayBuffer();
+              case 16:
+                buffer = _context.sent;
+                datefmt = (0, _dayjs["default"])().format('YYYY-MM-DDTHH:mm:ssZ[Z]');
+                file = new File([buffer], "logs-".concat(datefmt, ".zip"), {
+                  type: 'application/zip'
+                });
+                resolve(file);
+              case 20:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        }));
+        return function (_x, _x2) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+    } catch (e) {
+      logger.error("failed to get buffer.", e);
+      resolve(null);
+    }
+  });
+};

package/lib/worker/constants.d.ts

@@ -0,0 +1,11 @@
+export declare enum WorkerDirectives {
+    SET_MAX_RECORDS = "set-max-records",
+    WRITE_LOG = "writeLog",
+    COLLECT_LOGS = "collectLogs",
+    DELETE_LOGS = "deleteLogs",
+    PERSIST_BUFFER = "persistBuffer",
+    UNPERSIST_BUFFER = "unpersistBuffer",
+    GET_BUFFER = "getBuffer",
+    CLEAR_TEMP_LOGS = "clearTempLogs",
+    COLLECT_LOGS_ON_FS = "collectLogsOnFs"
+}

package/lib/worker/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WorkerDirectives = void 0;
+var WorkerDirectives = exports.WorkerDirectives = /*#__PURE__*/function (WorkerDirectives) {
+  WorkerDirectives["SET_MAX_RECORDS"] = "set-max-records";
+  WorkerDirectives["WRITE_LOG"] = "writeLog";
+  WorkerDirectives["COLLECT_LOGS"] = "collectLogs";
+  WorkerDirectives["DELETE_LOGS"] = "deleteLogs";
+  WorkerDirectives["PERSIST_BUFFER"] = "persistBuffer";
+  WorkerDirectives["UNPERSIST_BUFFER"] = "unpersistBuffer";
+  WorkerDirectives["GET_BUFFER"] = "getBuffer";
+  WorkerDirectives["CLEAR_TEMP_LOGS"] = "clearTempLogs";
+  WorkerDirectives["COLLECT_LOGS_ON_FS"] = "collectLogsOnFs";
+  return WorkerDirectives;
+}({});

package/lib/worker/handler/binary.d.ts

@@ -0,0 +1,5 @@
+import { WorkerContext } from "../type";
+export declare const persistBinary: (self: WorkerContext, callId: number, id: number, data: Blob) => Promise<void>;
+export declare const unpersistBinary: (self: WorkerContext, callId: number, id: number) => Promise<void>;
+export declare const getBuffer: (self: WorkerContext, callId: number, id: number) => Promise<void>;
+export declare const clearTempLogs: (self: WorkerContext, callId: number) => Promise<void>;

package/lib/worker/handler/binary.js

@@ -0,0 +1,161 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unpersistBinary = exports.persistBinary = exports.getBuffer = exports.clearTempLogs = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _fileReader = require("../../utilities/file-reader");
+var _constants = require("../constants");
+var _db = require("./db");
+var _reply = require("./reply");
+var persistBinary = exports.persistBinary = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(self, callId, id, data) {
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          _context.next = 3;
+          return _db.db.tempLogs.put({
+            id: id,
+            data: data
+          });
+        case 3:
+          (0, _reply.reply)(self, callId, _constants.WorkerDirectives.PERSIST_BUFFER, {
+            isSuccess: true
+          });
+          _context.next = 10;
+          break;
+        case 6:
+          _context.prev = 6;
+          _context.t0 = _context["catch"](0);
+          console.error("[logger] failed to persist buffer.", _context.t0);
+          (0, _reply.reply)(self, callId, _constants.WorkerDirectives.PERSIST_BUFFER, {
+            isSuccess: false
+          });
+        case 10:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 6]]);
+  }));
+  return function persistBinary(_x, _x2, _x3, _x4) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var unpersistBinary = exports.unpersistBinary = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(self, callId, id) {
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.prev = 0;
+          _context2.next = 3;
+          return _db.db.tempLogs["delete"](id);
+        case 3:
+          (0, _reply.reply)(self, callId, _constants.WorkerDirectives.UNPERSIST_BUFFER, {
+            isSuccess: true
+          });
+          _context2.next = 10;
+          break;
+        case 6:
+          _context2.prev = 6;
+          _context2.t0 = _context2["catch"](0);
+          console.error("[logger] failed to unpersist buffer.", _context2.t0);
+          (0, _reply.reply)(self, callId, _constants.WorkerDirectives.UNPERSIST_BUFFER, {
+            isSuccess: false
+          });
+        case 10:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[0, 6]]);
+  }));
+  return function unpersistBinary(_x5, _x6, _x7) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var getBuffer = exports.getBuffer = /*#__PURE__*/function () {
+  var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(self, callId, id) {
+    var tempLogs, buffer, data;
+    return _regenerator["default"].wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.prev = 0;
+          _context3.next = 3;
+          return _db.db.tempLogs.where("id").equals(id).first();
+        case 3:
+          tempLogs = _context3.sent;
+          if (!(tempLogs !== null && tempLogs !== void 0 && tempLogs.data)) {
+            _context3.next = 9;
+            break;
+          }
+          _context3.next = 7;
+          return (0, _fileReader.readAsArrayBuffer)(tempLogs.data);
+        case 7:
+          data = _context3.sent;
+          buffer = data;
+        case 9:
+          if (buffer) {
+            (0, _reply.reply)(self, callId, _constants.WorkerDirectives.GET_BUFFER, {
+              isSuccess: true,
+              buffer: buffer
+            }, [buffer]);
+          } else {
+            (0, _reply.reply)(self, callId, _constants.WorkerDirectives.GET_BUFFER, {
+              isSuccess: true,
+              buffer: null
+            });
+          }
+          _context3.next = 16;
+          break;
+        case 12:
+          _context3.prev = 12;
+          _context3.t0 = _context3["catch"](0);
+          console.error("[logger] failed to get buffer.", _context3.t0);
+          (0, _reply.reply)(self, callId, _constants.WorkerDirectives.GET_BUFFER, {
+            isSuccess: false
+          });
+        case 16:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[0, 12]]);
+  }));
+  return function getBuffer(_x8, _x9, _x10) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+var clearTempLogs = exports.clearTempLogs = /*#__PURE__*/function () {
+  var _ref4 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(self, callId) {
+    return _regenerator["default"].wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.prev = 0;
+          _context4.next = 3;
+          return _db.db.tempLogs.clear();
+        case 3:
+          (0, _reply.reply)(self, callId, _constants.WorkerDirectives.CLEAR_TEMP_LOGS, {
+            isSuccess: true
+          });
+          _context4.next = 10;
+          break;
+        case 6:
+          _context4.prev = 6;
+          _context4.t0 = _context4["catch"](0);
+          console.error("[logger] failed to clear temp logs.", _context4.t0);
+          (0, _reply.reply)(self, callId, _constants.WorkerDirectives.CLEAR_TEMP_LOGS, {
+            isSuccess: false
+          });
+        case 10:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[0, 6]]);
+  }));
+  return function clearTempLogs(_x11, _x12) {
+    return _ref4.apply(this, arguments);
+  };
+}();

package/lib/worker/handler/db.d.ts

@@ -0,0 +1,21 @@
+import Dexie, { Table } from 'dexie';
+type Timestamp = number;
+export type LogSchema = {
+    id: number;
+    content: string;
+    label: string;
+    created_at: Timestamp;
+    timestamp: string;
+};
+export type TempLogs = {
+    id: number;
+    data: Blob;
+};
+export declare class LoggerDB extends Dexie {
+    logs: Table<LogSchema, number>;
+    tempLogs: Table<TempLogs, number>;
+    constructor();
+    openDatabase(): void;
+}
+export declare const db: LoggerDB;
+export {};

package/lib/worker/handler/db.js

@@ -0,0 +1,42 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.reflect.construct.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.db = exports.LoggerDB = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _dexie = _interopRequireDefault(require("dexie"));
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var DATABASE_NAME = "AgoraLogger";
+var TABLE_NAME_LOGS = "logs";
+var TABLE_NAME_LOGS_TEMP_BUFFERS = "tempLogs";
+var LoggerDB = exports.LoggerDB = /*#__PURE__*/function (_Dexie) {
+  function LoggerDB() {
+    var _this;
+    (0, _classCallCheck2["default"])(this, LoggerDB);
+    _this = _callSuper(this, LoggerDB, [DATABASE_NAME]);
+    _this.openDatabase();
+    _this.logs = _this.table(TABLE_NAME_LOGS);
+    _this.tempLogs = _this.table(TABLE_NAME_LOGS_TEMP_BUFFERS);
+    return _this;
+  }
+  (0, _inherits2["default"])(LoggerDB, _Dexie);
+  return (0, _createClass2["default"])(LoggerDB, [{
+    key: "openDatabase",
+    value: function openDatabase() {
+      this.version(2).stores({
+        logs: '++id, content, label, created_at',
+        tempLogs: '++id, data'
+      });
+    }
+  }]);
+}(_dexie["default"]);
+var db = exports.db = new LoggerDB();

package/lib/worker/handler/fs-log.d.ts

@@ -0,0 +1,3 @@
+import { WorkerContext } from "../type";
+export declare const collectLogsOnFs: (self: WorkerContext, callId: number, logDirPath: string) => Promise<void>;
+export declare const clearTempLogs: (self: WorkerContext, callId: number) => Promise<void>;