@vope/utils 1.5.0 → 1.6.0-bate.10

package/{lib/index.js → dist/index.mjs}

@@ -25,7 +25,6 @@ import { deconPowersSum } from "./power/decon";
 import { rotateAngle } from "./rotate/angle";
 import { rotateRad } from "./rotate/rad";
 import { cubeURLParams, flatURLParams } from "./serialize/url-params";
-import { OfflineStorage } from "./storage/offline";
 import { css } from "./style/css";
 import { default as default4 } from "./subscriber";
 import { FlexTable } from "./table/flex";
@@ -41,7 +40,6 @@ export {
   MemorySimple,
   default3 as Neo4j,
   default2 as Neo4jAhchors,
-  OfflineStorage,
   default4 as Subscriber,
   Union,
   clamp,

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@vope/utils",
-  "version": "1.5.0",
+  "version": "1.6.0-bate.10",
   "description": "",
   "type": "module",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "types": "./types/index.d.ts",
-  "typings": "./types/index.d.ts",
-  "module": "./lib/index.js",
-  "main": "./cjs/index.js",
+  "types": "./dist/index.d.ts",
+  "typings": "./dist/index.d.ts",
+  "module": "./dist/index.mjs",
+  "main": "./dist/index.js",
   "scripts": {
     "start": "esbuild ./start.ts --outfile=start.cjs --format=cjs & node ./start.cjs",
     "poststart": "esbuild ./pre.ts --outfile=pre.cjs --format=cjs & node ./pre.cjs",
@@ -19,24 +19,26 @@
     "mocha": "mocha __tests/**/*.js",
     "test": "npm run mocha",
     "prepublishOnly": "npm run build & npm run test",
-    "debug": "npm run start & npm run premocha"
+    "debug": "npm run start & npm run premocha",
+    "clean": "rimraf start.cjs pre.cjs build.cjs dist/ __tests/ __examples/ sub_storage/"
   },
   "exports": {
     ".": {
-      "import": "./lib/index.js",
-      "require": "./cjs/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./storage": {
+      "types": "./sub_storage/offline.d.ts",
+      "import": "./sub_storage/offline.mjs",
+      "require": "./sub_storage/offline.js"
     }
   },
   "author": "vope",
   "license": "ISC",
-  "sideEffects": [
-    "lib/storage/offline.js",
-    "src/storage/offline.ts"
-  ],
   "files": [
-    "cjs",
-    "lib",
-    "types"
+    "dist",
+    "sub_storage"
   ],
   "devDependencies": {
     "@babel/parser": "^7.26.9",
@@ -59,7 +61,8 @@
     "rimraf": "^5.0.5",
     "rollup": "^4.34.8",
     "tslib": "^2.8.1",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "uuid": "^11.1.0"
   },
   "dependencies": {
     "@type-challenges/utils": "^0.1.1",

package/sub_storage/offline.d.ts

@@ -0,0 +1,51 @@
+export interface ICrypto<From, To> {
+    encrypt(plain: From): To | Promise<To>;
+    decrypt(cipher: To): From | Promise<From>;
+}
+interface Options<From, To> {
+    /** 存储名称 */
+    name: string;
+    /** 存储认证 */
+    token?: string;
+    /** 存储期限 */
+    expire?: number;
+    /** 存储加密 */
+    crypto: ICrypto<From, To>;
+}
+/**
+ * 离线存储
+ */
+export declare class OfflineStorage<From, To> {
+    #private;
+    get size(): number;
+    get mounted(): boolean;
+    constructor({ name, expire: newExpire, token: newToken, crypto, }: Options<From, To>);
+    ready(): Promise<this>;
+    /**
+     * 校验存储是否过期
+     */
+    validateExpire(): boolean;
+    /**
+     * 校验
+     */
+    validate(callback: (error?: Error) => void, expireMessage?: string): void;
+    /**
+     * 插入数据
+     */
+    push(data: From): Promise<number>;
+    /**
+     * 修改数据
+     */
+    update(index: number, data: From): Promise<boolean>;
+    /**
+     * 获取数据
+     */
+    get(index: number): Promise<From | null>;
+    /**
+     * 清理存储
+     */
+    clear(): Promise<void>;
+    static default<T>(options: string | Omit<Options<T, T>, 'crypto'>): OfflineStorage<T, T>;
+    static clear(token?: string, callback?: (name: string) => boolean): Promise<void>;
+}
+export {};

package/sub_storage/offline.js

@@ -0,0 +1,255 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage/offline.ts
+var offline_exports = {};
+__export(offline_exports, {
+  OfflineStorage: () => OfflineStorage
+});
+module.exports = __toCommonJS(offline_exports);
+var import_localforage = __toESM(require("localforage"), 1);
+var import_lodash_es = require("lodash-es");
+var import_sm_crypto = require("sm-crypto");
+var NAME = "@vope/utils";
+var PREFIX = NAME + "_";
+var key = [25, 144, 1, 32, 25, 135, 6, 40, 32, 23, 18, 19, 32, 36, 9, 5];
+var iv = [182, 59, 9, 29, 86, 64, 118, 111, 112, 101, 47, 117, 116, 105, 108, 115];
+var config = {
+  output: "string",
+  mode: "cbc",
+  iv
+};
+var HEADER = "." + import_sm_crypto.sm4.encrypt(NAME, key, config);
+var encrypt = (data) => {
+  let text = "";
+  for (const key2 in data) {
+    const value = data[key2];
+    if (value === void 0) continue;
+    text && (text += "&");
+    text += key2 + ":" + value;
+  }
+  return import_sm_crypto.sm4.encrypt(text, key, config);
+};
+var decrypt = (text) => {
+  const data = {};
+  let value;
+  try {
+    value = import_sm_crypto.sm4.decrypt(text, key, config);
+  } catch {
+    value = "";
+  }
+  value.split("&").forEach((pair) => {
+    const [key2, value2] = pair.split(":");
+    if (key2 === "expire") {
+      data[key2] = +value2;
+    } else {
+      data[key2] = value2;
+    }
+  });
+  return data;
+};
+var structKey = (index) => index.toString(16).padStart(8, "0");
+var reductKey = (key2) => parseInt(key2, 16);
+var MESSAGES = {
+  mount: "Please wait for the mounting to complete",
+  auth: "Unauthorized operation",
+  push: "Cannot add data to expired databases",
+  update: "Cannot update data to expired databases",
+  get: "Cannot get data from expired databases"
+};
+var createInstance = (name, version = 2) => import_localforage.default.createInstance({
+  driver: import_localforage.default.INDEXEDDB,
+  name,
+  version
+});
+var OfflineStorage = class _OfflineStorage {
+  #forage;
+  #expire;
+  #auth = false;
+  #crypto;
+  #size = 0;
+  #mount;
+  #mounted = false;
+  get size() {
+    return this.#size;
+  }
+  get mounted() {
+    return this.#mounted;
+  }
+  constructor({
+    name,
+    expire: newExpire,
+    token: newToken,
+    crypto
+  }) {
+    const forage = this.#forage = createInstance(import_sm_crypto.sm4.encrypt(PREFIX + name, key, config));
+    this.#mount = new Promise(async (resolve) => {
+      const keys = await forage.keys().then((keys2) => keys2).catch(() => []);
+      let size = 0;
+      let expire = newExpire;
+      let token = newToken;
+      let auth = true;
+      for (const key2 of keys) {
+        if (key2 === HEADER) {
+          const {
+            expire: oldExpire,
+            token: oldToken
+          } = decrypt(await forage.getItem(key2));
+          expire = oldExpire === void 0 ? newExpire : Date.now() < oldExpire ? newExpire : oldExpire;
+          auth = oldToken ? oldToken === newToken : true;
+          token = oldToken || newToken;
+        } else {
+          const value = reductKey(key2) + 1;
+          value > size && (size = value);
+        }
+      }
+      this.#size = size;
+      this.#expire = expire;
+      this.#auth = auth;
+      this.#crypto = crypto;
+      await forage.setItem(HEADER, encrypt({
+        expire,
+        token
+      }));
+      this.#mounted = true;
+      resolve(this);
+    });
+  }
+  ready() {
+    return this.#mount;
+  }
+  /**
+   * 校验存储是否过期
+   */
+  validateExpire() {
+    const expire = this.#expire;
+    return expire === void 0 || Date.now() < expire;
+  }
+  /**
+   * 校验
+   */
+  validate(callback, expireMessage) {
+    if (!this.#mounted) {
+      callback(new Error(MESSAGES.mount));
+    } else if (!this.#auth) {
+      callback(new Error(MESSAGES.auth));
+    } else if (expireMessage && !this.validateExpire()) {
+      callback(new Error(expireMessage));
+    } else {
+      callback();
+    }
+  }
+  /**
+   * 插入数据
+   */
+  async push(data) {
+    this.validate((e) => {
+      if (e) throw e;
+    }, MESSAGES.push);
+    const size = this.#size;
+    const key2 = structKey(size);
+    await this.#forage.setItem(key2, await this.#crypto.encrypt(data));
+    return this.#size = size + 1;
+  }
+  /**
+   * 修改数据
+   */
+  async update(index, data) {
+    this.validate((e) => {
+      if (e) throw e;
+    }, MESSAGES.update);
+    const forage = this.#forage;
+    const key2 = structKey(index);
+    const value = await forage.getItem(key2);
+    if (value === null) return false;
+    await forage.setItem(key2, await this.#crypto.encrypt(data));
+    return true;
+  }
+  /**
+   * 获取数据
+   */
+  async get(index) {
+    this.validate((e) => {
+      if (e) throw e;
+    }, MESSAGES.get);
+    const key2 = structKey(index);
+    const value = await this.#forage.getItem(key2);
+    return value === null ? null : await this.#crypto.decrypt(value);
+  }
+  /**
+   * 清理存储
+   */
+  async clear() {
+    this.validate((e) => {
+      if (e) throw e;
+    });
+    this.#size = 0;
+    await import_localforage.default.dropInstance({
+      name: this.#forage.config().name
+    });
+  }
+  static default(options) {
+    (0, import_lodash_es.isString)(options) && (options = { name: options });
+    return new _OfflineStorage({
+      ...options,
+      crypto: {
+        encrypt(plain) {
+          return plain;
+        },
+        decrypt(cipher) {
+          return cipher;
+        }
+      }
+    });
+  }
+  static async clear(token, callback) {
+    const size = PREFIX.length;
+    const databases = await indexedDB.databases();
+    const tasks = [];
+    for (const { name, version } of databases) {
+      if (name === void 0) continue;
+      let text;
+      try {
+        text = import_sm_crypto.sm4.decrypt(name, key, config);
+      } catch {
+        continue;
+      }
+      if (text.slice(0, size) !== PREFIX) continue;
+      const forage = createInstance(name, version);
+      const value = await forage.getItem(HEADER);
+      if (value === null || decrypt(value).token !== token || callback && callback(text.slice(size))) continue;
+      const idb = indexedDB.deleteDatabase(text);
+      tasks.push(new Promise((resolve) => {
+        idb.onerror = () => resolve();
+        idb.onsuccess = () => resolve();
+      }));
+    }
+    await Promise.all(tasks);
+  }
+};

package/sub_storage/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "offline.d.ts",
+  "import": "offline.mjs",
+  "require": "offline.js"
+}