pubo-web 1.0.78 → 1.0.80

package/es/storage/indexed-db/indexed-db-utils.js

@@ -0,0 +1,309 @@
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function sent() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+var __values = this && this.__values || function (o) {
+  var s = typeof Symbol === "function" && Symbol.iterator,
+    m = s && o[s],
+    i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function next() {
+      if (o && i >= o.length) o = void 0;
+      return {
+        value: o && o[i++],
+        done: !o
+      };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var IndexedDBUtils = /** @class */function () {
+  function IndexedDBUtils(name, version, tables) {
+    this.indexedDB = self.indexedDB;
+    this.get = this.createTransaction(function (objectStore, key) {
+      return objectStore.get(key);
+    });
+    this.getAll = this.createTransaction(function (objectStore) {
+      return objectStore.getAll();
+    });
+    this["delete"] = this.createTransaction(function (objectStore, key) {
+      return objectStore["delete"](key);
+    });
+    this.put = this.createTransaction(function (objectStore, values) {
+      return objectStore.put(values);
+    });
+    this.name = name;
+    this.version = version;
+    this.tables = tables;
+  }
+  IndexedDBUtils.prototype.open = function () {
+    var _this = this;
+    return new Promise(function (resolve, reject) {
+      var _a;
+      var request = (_a = _this.indexedDB) === null || _a === void 0 ? void 0 : _a.open(_this.name, _this.version);
+      request.onupgradeneeded = function (event) {
+        return __awaiter(_this, void 0, void 0, function () {
+          var _a, _b, table;
+          var e_1, _c;
+          var _this = this;
+          return __generator(this, function (_d) {
+            // @ts-ignore
+            this.db = event.target.result;
+            // @ts-ignore
+            this.transaction = event.target.transaction;
+            this.transaction.oncomplete = function () {
+              return __awaiter(_this, void 0, void 0, function () {
+                var _a, _b, table, e_2_1;
+                var e_2, _c;
+                return __generator(this, function (_d) {
+                  switch (_d.label) {
+                    case 0:
+                      this.transaction = null;
+                      _d.label = 1;
+                    case 1:
+                      _d.trys.push([1, 6, 7, 8]);
+                      _a = __values(this.tables), _b = _a.next();
+                      _d.label = 2;
+                    case 2:
+                      if (!!_b.done) return [3 /*break*/, 5];
+                      table = _b.value;
+                      if (!table["default"]) return [3 /*break*/, 4];
+                      return [4 /*yield*/, this.put(table.name, table["default"])];
+                    case 3:
+                      _d.sent();
+                      _d.label = 4;
+                    case 4:
+                      _b = _a.next();
+                      return [3 /*break*/, 2];
+                    case 5:
+                      return [3 /*break*/, 8];
+                    case 6:
+                      e_2_1 = _d.sent();
+                      e_2 = {
+                        error: e_2_1
+                      };
+                      return [3 /*break*/, 8];
+                    case 7:
+                      try {
+                        if (_b && !_b.done && (_c = _a["return"])) _c.call(_a);
+                      } finally {
+                        if (e_2) throw e_2.error;
+                      }
+                      return [7 /*endfinally*/];
+                    case 8:
+                      return [2 /*return*/];
+                  }
+                });
+              });
+            };
+
+            try {
+              for (_a = __values(this.tables), _b = _a.next(); !_b.done; _b = _a.next()) {
+                table = _b.value;
+                this.createTable(table);
+              }
+            } catch (e_1_1) {
+              e_1 = {
+                error: e_1_1
+              };
+            } finally {
+              try {
+                if (_b && !_b.done && (_c = _a["return"])) _c.call(_a);
+              } finally {
+                if (e_1) throw e_1.error;
+              }
+            }
+            resolve('success');
+            return [2 /*return*/];
+          });
+        });
+      };
+
+      request.onsuccess = function () {
+        _this.db = request.result;
+        resolve('success');
+      };
+      request.onerror = function (error) {
+        console.error('indexed db connect error: ', error);
+        reject(error);
+      };
+    });
+  };
+  IndexedDBUtils.prototype.createTable = function (table) {
+    if (!this.db.objectStoreNames.contains(table.name)) {
+      this.db.createObjectStore(table.name, table.options || {
+        keyPath: '_id',
+        autoIncrement: true
+      });
+    }
+  };
+  IndexedDBUtils.prototype.createTransaction = function (getRequest) {
+    var _this = this;
+    return function (store) {
+      var args = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+      }
+      return new Promise(function (resolve, reject) {
+        if (!_this.db) {
+          reject('not connect');
+          return;
+        }
+        var transaction = _this.db.transaction([store], 'readwrite');
+        var objectStore = transaction.objectStore(store);
+        var request = getRequest.apply(void 0, __spreadArray([objectStore], __read(args), false));
+        request.onerror = function (event) {
+          reject(event);
+        };
+        request.onsuccess = function () {
+          resolve(request.result);
+        };
+      });
+    };
+  };
+  return IndexedDBUtils;
+}();
+export { IndexedDBUtils };

package/lib/index.d.ts

@@ -5,3 +5,5 @@ export { WebStorage } from './storage';
 export { default as WebsocketClient } from './websocket/client';
 export { DragMethod } from './dom/drag';
 export { pickFiles } from './file/pick';
+export { IndexedStorage } from './storage/indexed-db/indexed-db-storage';
+export { getCookieValue } from './storage/cookie';

package/lib/index.js

@@ -8,7 +8,7 @@ var __importDefault = this && this.__importDefault || function (mod) {
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.pickFiles = exports.DragMethod = exports.WebsocketClient = exports.WebStorage = exports.downloadFile = exports.blob2file = exports.blob2base64 = exports.blob2text = exports.loadScript = void 0;
+exports.getCookieValue = exports.IndexedStorage = exports.pickFiles = exports.DragMethod = exports.WebsocketClient = exports.WebStorage = exports.downloadFile = exports.blob2file = exports.blob2base64 = exports.blob2text = exports.loadScript = void 0;
 var load_script_1 = require("./load-script");
 Object.defineProperty(exports, "loadScript", {
   enumerable: true,
@@ -69,4 +69,18 @@ Object.defineProperty(exports, "pickFiles", {
   get: function get() {
     return pick_1.pickFiles;
   }
+});
+var indexed_db_storage_1 = require("./storage/indexed-db/indexed-db-storage");
+Object.defineProperty(exports, "IndexedStorage", {
+  enumerable: true,
+  get: function get() {
+    return indexed_db_storage_1.IndexedStorage;
+  }
+});
+var cookie_1 = require("./storage/cookie");
+Object.defineProperty(exports, "getCookieValue", {
+  enumerable: true,
+  get: function get() {
+    return cookie_1.getCookieValue;
+  }
 });

package/lib/storage/cookie.d.ts

@@ -0,0 +1 @@
+export declare const getCookieValue: (key: string) => string;

package/lib/storage/cookie.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCookieValue = void 0;
+var getCookieValue = function getCookieValue(key) {
+  var reg = new RegExp("(^| )".concat(key, "=([^;]*)(;|$)"));
+  var res = reg.exec(document.cookie);
+  return res ? res[2] : '';
+};
+exports.getCookieValue = getCookieValue;

package/lib/storage/indexed-db/indexed-db-storage.d.ts

@@ -0,0 +1,27 @@
+import { IndexedDBUtils, IndexedTable } from './indexed-db-utils';
+export declare class Storage {
+    private readonly utils;
+    private readonly store;
+    constructor(utils: IndexedDBUtils, store: string);
+    getState(): Promise<any>;
+    setState(values: any): void;
+    merge(values: any): Promise<void>;
+}
+export interface StorageFactoryType {
+    name: string;
+    version: number;
+    tables?: IndexedTable[];
+}
+export declare class IndexedStorage {
+    private readonly name;
+    private readonly version;
+    utils: IndexedDBUtils;
+    private _cache;
+    private readonly tables;
+    private connected;
+    private connecting;
+    constructor({ name, version, tables }: StorageFactoryType);
+    register(tables: IndexedTable[]): void;
+    connect(): Promise<void>;
+    get(store: string): Storage;
+}

package/lib/storage/indexed-db/indexed-db-storage.js

@@ -0,0 +1,261 @@
+"use strict";
+
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function sent() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+var __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexedStorage = exports.Storage = void 0;
+var pubo_utils_1 = require("pubo-utils");
+var indexed_db_utils_1 = require("./indexed-db-utils");
+var Storage = /** @class */function () {
+  function Storage(utils, store) {
+    this.utils = utils;
+    this.store = store;
+  }
+  Storage.prototype.getState = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        return [2 /*return*/, this.utils.get(this.store, 1)];
+      });
+    });
+  };
+  Storage.prototype.setState = function (values) {
+    this.utils.put(this.store, __assign(__assign({}, values), {
+      _id: 1
+    }));
+  };
+  Storage.prototype.merge = function (values) {
+    return __awaiter(this, void 0, void 0, function () {
+      var state;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4 /*yield*/, this.getState()];
+          case 1:
+            state = _a.sent();
+            this.setState = __assign(__assign(__assign({}, state), values), {
+              _id: 1
+            });
+            return [2 /*return*/];
+        }
+      });
+    });
+  };
+
+  return Storage;
+}();
+exports.Storage = Storage;
+var IndexedStorage = /** @class */function () {
+  function IndexedStorage(_a) {
+    var name = _a.name,
+      version = _a.version,
+      tables = _a.tables;
+    this._cache = {};
+    this.tables = [];
+    this.connected = false;
+    this.connecting = false;
+    this.name = name;
+    this.version = version;
+    this.tables = tables !== null && tables !== void 0 ? tables : [];
+  }
+  IndexedStorage.prototype.register = function (tables) {
+    var _a;
+    (_a = this.tables).push.apply(_a, __spreadArray([], __read(tables), false));
+  };
+  IndexedStorage.prototype.connect = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            if (this.connected) {
+              return [2 /*return*/];
+            }
+
+            if (!this.connecting) return [3 /*break*/, 4];
+            _a.label = 1;
+          case 1:
+            if (!!this.connecting) return [3 /*break*/, 3];
+            return [4 /*yield*/, (0, pubo_utils_1.sleep)(100)];
+          case 2:
+            _a.sent();
+            return [3 /*break*/, 1];
+          case 3:
+            return [2 /*return*/];
+          case 4:
+            this.connecting = true;
+            this.utils = new indexed_db_utils_1.IndexedDBUtils(this.name, this.version, this.tables);
+            return [4 /*yield*/, this.utils.open()];
+          case 5:
+            _a.sent();
+            this.connected = true;
+            this.connecting = false;
+            return [2 /*return*/];
+        }
+      });
+    });
+  };
+
+  IndexedStorage.prototype.get = function (store) {
+    if (!this._cache[store] && this.utils) {
+      this._cache[store] = new Storage(this.utils, store);
+    }
+    return this._cache[store];
+  };
+  return IndexedStorage;
+}();
+exports.IndexedStorage = IndexedStorage;

package/lib/storage/indexed-db/indexed-db-utils.d.ts

@@ -0,0 +1,21 @@
+export interface IndexedTable {
+    name: string;
+    options?: any;
+    default?: any;
+}
+export declare class IndexedDBUtils {
+    private readonly name;
+    private readonly version;
+    private readonly indexedDB;
+    private readonly tables;
+    private db;
+    private transaction;
+    constructor(name: string, version: number, tables: IndexedTable[]);
+    open(): Promise<unknown>;
+    private createTable;
+    private createTransaction;
+    get: (store: string, values?: any) => Promise<any>;
+    getAll: (store: string, values?: any) => Promise<any>;
+    delete: (store: string, values?: any) => Promise<any>;
+    put: (store: string, values?: any) => Promise<any>;
+}