@vope/utils 1.4.25 → 1.4.26

package/lib/compare/weak-equal.js

@@ -1,4 +1,5 @@
-const deepWeakEqual = (from, to) => {
+import { hash8strings } from "../convert/strings";
+const deepWeakEqual = (from, to, exclude) => {
   if (typeof from !== "object" || from === null || typeof to !== "object" || to === null)
     return from === to;
   if (Array.isArray(from) && Array.isArray(to)) {
@@ -11,7 +12,10 @@ const deepWeakEqual = (from, to) => {
     });
   } else {
     const caches = {};
+    const excludeCaches = exclude && hash8strings(exclude);
     for (const key in from) {
+      if (excludeCaches && key in excludeCaches)
+        continue;
       if (!deepWeakEqual(from[key], to[key])) {
         return false;
       } else {
@@ -19,7 +23,7 @@ const deepWeakEqual = (from, to) => {
       }
     }
     for (const key in to) {
-      if (key in caches)
+      if (excludeCaches && key in excludeCaches || key in caches)
         continue;
       if (!deepWeakEqual(from[key], to[key])) {
         return false;

package/lib/index.js

@@ -25,6 +25,7 @@ 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";
@@ -40,6 +41,7 @@ export {
   MemorySimple,
   default3 as Neo4j,
   default2 as Neo4jAhchors,
+  OfflineStorage,
   default4 as Subscriber,
   Union,
   clamp,

package/lib/serialize/url-params.js

@@ -1,99 +1,51 @@
-import { isFunction, isObject } from "lodash-es";
+import { isString } from "lodash-es";
+import { isKey } from "../is/key";
+const cubes = {
+  string: (text) => text,
+  boolean: (text) => text === "true",
+  number: (text) => Number(text),
+  bigint: (text) => BigInt(text),
+  date: (text) => new Date(text),
+  regexp: (text) => new RegExp(text),
+  null: () => null
+};
+const flats = {
+  string: (data) => flatEncode(data),
+  boolean: (data) => `${data}`,
+  number: (data) => `${data}`,
+  bigint: (data) => `${data}`,
+  date: (data) => data.toJSON(),
+  regexp: (data) => flatEncode(data.source),
+  null: () => "null"
+};
 const cubeURLParams = (text, serializes) => {
   const params = new URLSearchParams(text);
   const result = {};
   for (const [key, value] of params) {
     const serialize = serializes[key];
-    switch (serialize) {
-      case Boolean:
-        result[key] = value === "true";
-        break;
-      case Number:
-        result[key] = Number(value);
-        break;
-      case Date:
-        result[key] = new Date(value);
-        break;
-      case BigInt:
-        result[key] = BigInt(value);
-        break;
-      case RegExp:
-        result[key] = new RegExp(value);
-        break;
-      default:
-        if (isFunction(serialize)) {
-          result[key] = serialize(value);
-        } else if (isObject(serialize) && isFunction(serialize.cube)) {
-          result[key] = serialize.cube(value);
-        } else {
-          result[key] = value;
-        }
+    if (!serialize)
+      continue;
+    if (isString(serialize) && isKey(serialize, cubes)) {
+      result[key] = cubes[serialize](value);
+    } else {
+      result[key] = serialize.cube(value);
     }
   }
   return result;
 };
 const re_flat = /\+/g;
 const flatEncode = (text) => text.replace(re_flat, () => "%2B");
-const flatValue = (value) => {
-  switch (typeof value) {
-    case "boolean":
-    case "bigint":
-    case "number":
-    case "symbol":
-    case "function":
-      return value.toString();
-    case "string":
-      return flatEncode(value);
-    case "undefined":
-      return "";
-    default:
-      if (value === null) {
-        return "";
-      }
-      if (value instanceof Date) {
-        return value.toJSON();
-      } else if (value instanceof RegExp) {
-        return flatEncode(value.source);
-      } else {
-        return flatEncode(value.toString());
-      }
-  }
-};
 const flatURLParams = (data, serializes) => {
   const params = new URLSearchParams();
   for (const key in data) {
     const value = data[key];
     const serialize = serializes[key];
-    let result;
-    switch (serialize) {
-      case Boolean:
-        result = typeof value === "boolean" ? `${value}` : "";
-        break;
-      case Number:
-        result = typeof value === "number" ? `${value}` : "";
-        break;
-      case Date:
-        result = value instanceof Date ? value.toJSON() : "";
-        break;
-      case BigInt:
-        result = typeof value === "bigint" ? `${value}` : "";
-        break;
-      case RegExp:
-        result = value instanceof RegExp ? flatEncode(value.source) : "";
-        break;
-      case String:
-        result = typeof value === "string" ? flatEncode(value) : "";
-        break;
-      default:
-        if (isFunction(serialize)) {
-          result = flatValue(value);
-        } else if (isObject(serialize) && isFunction(serialize.flat)) {
-          result = serialize.flat(value);
-        } else {
-          result = flatValue(value);
-        }
-    }
-    params.append(key, result);
+    if (!serialize)
+      continue;
+    params.append(
+      key,
+      isString(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
+    );
   }
   return params.toString();
 };

package/lib/storage/offline.js

@@ -0,0 +1,232 @@
+import { name } from "@package";
+import localforage from "localforage";
+import { isString } from "lodash-es";
+import { sm4 } from "sm-crypto";
+const PREFIX = name + "_";
+const key = [25, 144, 1, 32, 25, 135, 6, 40, 32, 23, 18, 19, 32, 36, 9, 5];
+const iv = [182, 59, 9, 29, 86, 64, 118, 111, 112, 101, 47, 117, 116, 105, 108, 115];
+const config = {
+  output: "string",
+  mode: "cbc",
+  iv
+};
+const HEADER = "." + sm4.encrypt(name, key, config);
+const encrypt = (data) => {
+  let text = "";
+  for (const key2 in data) {
+    const value = data[key2];
+    if (value === void 0)
+      continue;
+    text && (text += "&");
+    text += key2 + ":" + value;
+  }
+  return sm4.encrypt(text, key, config);
+};
+const decrypt = (text) => {
+  const data = {};
+  let value;
+  try {
+    value = 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;
+};
+const structKey = (index) => index.toString(16).padStart(8, "0");
+const reductKey = (key2) => parseInt(key2, 16);
+const 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"
+};
+const createInstance = (name2, version = 2) => localforage.createInstance({
+  driver: localforage.INDEXEDDB,
+  name: name2,
+  version
+});
+class OfflineStorage {
+  #forage;
+  #expire;
+  #auth = false;
+  #crypto;
+  #size = 0;
+  #mount;
+  #mounted = false;
+  get size() {
+    return this.#size;
+  }
+  get mounted() {
+    return this.#mounted;
+  }
+  constructor({
+    name: name2,
+    expire: newExpire,
+    token: newToken,
+    crypto
+  }) {
+    const forage = this.#forage = createInstance(sm4.encrypt(PREFIX + name2, 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 localforage.dropInstance({
+      name: this.#forage.config().name
+    });
+  }
+  static default(options) {
+    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: name2, version } of databases) {
+      if (name2 === void 0)
+        continue;
+      let text;
+      try {
+        text = sm4.decrypt(name2, key, config);
+      } catch {
+        continue;
+      }
+      if (text.slice(0, size) !== PREFIX)
+        continue;
+      const forage = createInstance(name2, 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);
+  }
+}
+export {
+  OfflineStorage
+};

package/lib/url/params.js

@@ -1,29 +1,8 @@
-import { isBoolean } from "lodash-es";
 import { flatURLParams } from "../serialize/url-params";
-const formatter = (params, isOpenType) => {
-  const list = [];
-  for (const key in params) {
-    const value = params[key];
-    if (value === void 0) {
-      list.push(key);
-    } else if (Array.isArray(value)) {
-      list.push(
-        key + "=" + (isOpenType ? JSON.stringify(value).slice(1, -1) : value.join(","))
-      );
-    } else {
-      list.push(key + "=" + (isOpenType ? JSON.stringify(value) : value.toString()));
-    }
-  }
-  return list.join("&");
+const connectURLParams = (url, params, serializes) => {
+  const query = flatURLParams(params, serializes);
+  return query ? url.includes("?") ? url + "&" + query : url + "?" + query : url;
 };
-function connectURLParams(url, params, serializes) {
-  if (!params)
-    return url;
-  const query = serializes === void 0 || isBoolean(serializes) ? formatter(params, serializes) : flatURLParams(params, serializes);
-  if (!query)
-    return url;
-  return url.includes("?") ? url + "&" + query : url + "?" + query;
-}
 export {
   connectURLParams
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vope/utils",
-  "version": "1.4.25",
+  "version": "1.4.26",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -12,13 +12,14 @@
   "module": "./lib/index.js",
   "main": "./cjs/index.js",
   "scripts": {
-    "start": "esbuild ./pre.ts --outfile=pre.cjs --format=cjs & node ./pre.cjs",
-    "prebuild": "npm run start & esbuild ./build.ts --outfile=build.cjs --format=cjs",
-    "build": "node ./build.cjs",
+    "start": "esbuild ./start.ts --outfile=start.cjs --format=cjs & node ./start.cjs",
+    "poststart": "esbuild ./pre.ts --outfile=pre.cjs --format=cjs & node ./pre.cjs",
+    "build": "npm run start & node ./build.cjs",
     "premocha": "node ./build.cjs --type=test",
     "mocha": "mocha __tests/**/*.js",
     "test": "npm run mocha",
-    "prepublishOnly": "npm run build & npm run test"
+    "prepublishOnly": "npm run build & npm run test",
+    "debug": "npm run build & npm run premocha"
   },
   "exports": {
     ".": {
@@ -37,14 +38,22 @@
     "@babel/parser": "^7.23.4",
     "@babel/traverse": "^7.23.4",
     "@babel/types": "^7.23.4",
+    "@rollup/plugin-alias": "^5.1.1",
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-typescript": "^12.1.0",
     "@types/babel__traverse": "^7.20.4",
     "@types/mocha": "^10.0.6",
     "@types/node": "^20.4.5",
+    "@types/sm-crypto": "^0.3.4",
     "esbuild": "^0.19.4",
     "glob": "^10.3.10",
     "iconv-lite": "^0.6.3",
     "mocha": "^10.2.0",
+    "puppeteer": "^23.4.1",
     "rimraf": "^5.0.5",
+    "rollup": "^4.22.5",
     "tslib": "^2.6.1",
     "typescript": "^5.3.3"
   },
@@ -53,6 +62,8 @@
     "@types/lodash-es": "^4.17.9",
     "@vope/types": "^1.0.13",
     "csstype": "^3.1.3",
-    "lodash-es": "^4.17.21"
+    "localforage": "^1.10.0",
+    "lodash-es": "^4.17.21",
+    "sm-crypto": "^0.3.13"
   }
 }

package/types/compare/weak-equal.d.ts

@@ -1,4 +1,4 @@
 /**
  * 深度相等性比较(弱比较)
  */
-export declare const deepWeakEqual: (from: any, to: any) => boolean;
+export declare const deepWeakEqual: <A, B>(from: A, to: B, exclude?: (Extract<keyof A, string | number> | Extract<keyof B, string | number>)[] | undefined) => boolean;

package/types/index.d.ts

@@ -24,7 +24,8 @@ export { parseNum } from './parse/num';
 export { deconPowersSum } from './power/decon';
 export { rotateAngle } from './rotate/angle';
 export { rotateRad } from './rotate/rad';
-export { type URLParamsValues, cubeURLParams, type URLParamsFlats, flatURLParams } from './serialize/url-params';
+export { type Serializes, cubeURLParams, flatURLParams } from './serialize/url-params';
+export { type ICrypto, OfflineStorage } from './storage/offline';
 export { type CSSProperties, type StyleValue, css } from './style/css';
 export { type SModel, default as Subscriber } from './subscriber';
 export { FlexTable } from './table/flex';

package/types/serialize/url-params.d.ts

@@ -1,36 +1,43 @@
-import { Assign } from '@vope/types';
-type NativeValue = BooleanConstructor | NumberConstructor | DateConstructor | BigIntConstructor | RegExpConstructor | StringConstructor;
+import { Equal } from '@type-challenges/utils';
+import { UnionToTuple } from '@vope/types';
+type NativeMap = {
+    string: string;
+    boolean: boolean;
+    number: number;
+    bigint: bigint;
+    date: Date;
+    regexp: RegExp;
+    null: null;
+};
+type NativeValue = keyof NativeMap;
 interface AccessorValue<T = any> {
     cube(text: string): T;
-    flat?(value: T): string;
+    flat(value: T): string;
 }
-type SimplifyValue = ((text: string) => any);
-type Value = NativeValue | SimplifyValue | AccessorValue;
+type NativeUnion = UnionToTuple<{
+    [P in NativeValue]: [NativeMap[P], P];
+}[NativeValue]>;
+type Signal<T, U extends any[] = NativeUnion> = U extends [infer A1, ...infer A2] ? A1 extends [infer V, infer K] ? Equal<T, V> extends true ? K : Signal<T, A2> : Signal<T, A2> : never;
 /**
  * 转换套件类型
  */
-type Values = Record<string, Value>;
-export { Values as URLParamsValues };
-type SimplifyBranch<T, Branch extends boolean> = Branch extends true ? T extends object ? Assign<T, {
-    toString?(this: T): string;
-}> : T : T;
-type Cube<T, Branch extends boolean> = [T] extends [DateConstructor] ? Date : [T] extends [NativeValue] ? T extends ((value: string) => infer A) ? A : string : [T] extends [(text: string) => infer S] ? SimplifyBranch<S, Branch> : [T] extends [AccessorValue<infer B>] ? B : string;
-type Cubes<T extends Values, Branch extends boolean = false> = {
-    [P in keyof T]: Cube<T[P], Branch>;
+export type Serializes<T extends object> = {
+    [P in keyof T & string]: Signal<T[P]> | AccessorValue<T[P]>;
+};
+type Cube<T> = [T] extends [NativeValue] ? NativeMap[T] : [T] extends [AccessorValue<infer B>] ? B : never;
+type Cubes<T extends object, S extends Serializes<T>> = {
+    [P in Extract<keyof T, keyof S> & string]: Cube<S[P]>;
 };
 /**
  * 将URL查询参数转换成(复杂)对象
  * @param text URL查询参数字符串
  * @param serializes 转换套件
  */
-export declare const cubeURLParams: <T extends Values>(text: string, serializes: T) => Cubes<T, false>;
-/**
- * 符合套件的(复杂)数据类型
- */
-export type URLParamsFlats<T extends Values> = Cubes<T, true>;
+export declare const cubeURLParams: <T extends object, S extends Serializes<T>>(text: string, serializes: S) => Cubes<T, S>;
 /**
  * 将(复杂)对象转换成URL查询参数
- * @param data 符合套件格式的(复杂)对象
+ * @param data 数据
  * @param serializes 转换套件
  */
-export declare const flatURLParams: <T extends Values>(data: Cubes<T, true>, serializes: T) => string;
+export declare const flatURLParams: <T extends object, S extends Serializes<T>>(data: T, serializes: S) => string;
+export {};

package/types/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/types/url/params.d.ts

@@ -1,12 +1,8 @@
-import { URLParamsFlats, URLParamsValues } from '../serialize/url-params';
-type Param = string | number | boolean | undefined;
-type Params = Param | Param[];
+import { Serializes } from '../serialize/url-params';
 /**
  * url拼接参数
  * @param url
  * @param params 需要让url携带的参数
- * @param serializes 泛型对象(转换套件)，boolean或缺省(是否将undefined会被转成null)
+ * @param serializes 转换套件
  */
-export declare function connectURLParams<T extends URLParamsValues>(url: string, params: URLParamsFlats<T>, serializes: T): string;
-export declare function connectURLParams(url: string, params?: Record<string, Params>, serializes?: boolean): string;
-export {};
+export declare const connectURLParams: <T extends object>(url: string, params: T, serializes: Serializes<T>) => string;