@vope/utils 1.6.0-bate.2 → 1.6.0-bate.3

package/dist/index.mjs

@@ -0,0 +1,73 @@
+import { clamp } from "./clamp";
+import { classnames } from "./classnames";
+import { compareVersion } from "./compare/version";
+import { deepWeakEqual } from "./compare/weak-equal";
+import { hash8json } from "./convert/json";
+import { hash8object } from "./convert/object";
+import { hash8strings } from "./convert/strings";
+import { desensEncrypt, desensDecrypt, desensReplace } from "./desens";
+import { getEncoding } from "./encoding";
+import { inputRegex } from "./input-regex";
+import { isClass } from "./is/class";
+import { isEmpty } from "./is/empty";
+import { isKey } from "./is/key";
+import { isNull } from "./is/null";
+import { loadImage } from "./load/image";
+import { MemoryBasic } from "./memory/basic";
+import { MemoryList } from "./memory/list";
+import { MemoryPower } from "./memory/power";
+import { MemorySimple } from "./memory/simple";
+import { default as default2 } from "./neo4j-anchors";
+import { default as default3 } from "./neo4j";
+import { once } from "./once";
+import { parseNum } from "./parse/num";
+import { deconPowersSum } from "./power/decon";
+import { rotateAngle } from "./rotate/angle";
+import { rotateRad } from "./rotate/rad";
+import { cubeURLParams, flatURLParams } from "./serialize/url-params";
+import { css } from "./style/css";
+import { default as default4 } from "./subscriber";
+import { FlexTable } from "./table/flex";
+import { Union } from "./union";
+import { joinPaths } from "./url/join";
+import { connectURLParams } from "./url/params";
+import { wait } from "./wait";
+export {
+  FlexTable,
+  MemoryBasic,
+  MemoryList,
+  MemoryPower,
+  MemorySimple,
+  default3 as Neo4j,
+  default2 as Neo4jAhchors,
+  default4 as Subscriber,
+  Union,
+  clamp,
+  classnames,
+  compareVersion,
+  connectURLParams,
+  css,
+  cubeURLParams,
+  deconPowersSum,
+  deepWeakEqual,
+  desensDecrypt,
+  desensEncrypt,
+  desensReplace,
+  flatURLParams,
+  getEncoding,
+  hash8json,
+  hash8object,
+  hash8strings,
+  inputRegex,
+  isClass,
+  isEmpty,
+  isKey,
+  isNull,
+  joinPaths,
+  loadImage,
+  once,
+  parseNum,
+  rotateAngle,
+  rotateRad,
+  wait
+};

package/dist/input-regex.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 处理输入文本中的特殊字符，用于转换正则表达式
+ * @param text
+ * @param flags 表示输出正则表达式
+ */
+export declare function inputRegex(text: string, flags?: string): RegExp;
+/**
+ * 处理输入文本中的特殊字符，用于转换正则表达式
+ * @param text
+ * @param flags 表示输出字符串，该字符串将作为正则表达式的一部分
+ */
+export declare function inputRegex(text: string, flags: false): string;

package/dist/input-regex.mjs

@@ -0,0 +1,8 @@
+const RE_REGEX = /[$()*+.[?\\^{|]/g;
+const RE_STRING = /[$()*+.[?\\^{|-]/g;
+function inputRegex(text, flags) {
+  return flags === false ? text.replace(RE_STRING, ($0) => "\\" + $0) : new RegExp(text.replace(RE_REGEX, ($0) => "\\" + $0), flags);
+}
+export {
+  inputRegex
+};

package/dist/is/class.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 检测是否为class
+ */
+export declare const isClass: (value: any, strict?: boolean) => value is new (...args: any) => any;

package/dist/is/class.mjs

@@ -0,0 +1,22 @@
+const re_anonymous = /^function\s+\(|^function\s+anonymous\(/;
+const re_function = /^function\s+[A-Z]/;
+const re_this = /\b\(this\b|\bthis[\.\[]\b/;
+const re_check = /classCallCheck\(this/;
+const re_default = /^function\sdefault_\d+\s*\(/;
+const isClass = (value, strict = true) => {
+  if (typeof value !== "function") return false;
+  const proto = value.prototype;
+  if (!proto || proto.constructor !== value) return false;
+  const str = value.toString();
+  if (str.slice(0, 5) === "class" || Object.getOwnPropertyNames(proto).length >= 2) return true;
+  if (re_anonymous.test(str)) return false;
+  if (strict && re_function.test(str)) return true;
+  if (re_this.test(str)) {
+    if (!strict || re_check.test(str)) return true;
+    return re_default.test(str);
+  }
+  return false;
+};
+export {
+  isClass
+};

package/dist/is/empty.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 检测是否为空(undefined/null/'')
+ */
+export declare const isEmpty: (value: any) => value is undefined | null | "";

package/dist/is/empty.mjs

@@ -0,0 +1,5 @@
+import { isNull } from "./null";
+const isEmpty = (value) => isNull(value) || value === "";
+export {
+  isEmpty
+};

package/dist/is/key.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 检测key是否为对象的属性
+ */
+export declare const isKey: <T extends object>(key: string, data: T) => key is Extract<keyof T, string>;

package/dist/is/key.mjs

@@ -0,0 +1,4 @@
+const isKey = (key, data) => key in data;
+export {
+  isKey
+};

package/dist/is/null.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 检测是否无值(undefined/null)
+ */
+export declare const isNull: (value: any) => value is undefined | null;

package/dist/is/null.mjs

@@ -0,0 +1,4 @@
+const isNull = (value) => value === void 0 || value === null;
+export {
+  isNull
+};

package/dist/load/image.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 加载图片
+ * @param src
+ */
+export declare const loadImage: (src: string) => Promise<HTMLImageElement | null>;

package/dist/load/image.mjs

@@ -0,0 +1,11 @@
+const loadImage = (src) => {
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = () => resolve(null);
+    img.src = src;
+  });
+};
+export {
+  loadImage
+};

package/dist/memory/basic.d.ts

@@ -0,0 +1,79 @@
+import { type Memory } from './type';
+interface Config<Reactor> {
+    /**
+     * 定义数据如何挂载到存储中
+     * @param index 当前存入数据对应的角标
+     * @param reactor 当前存入数据对应存储单元
+     */
+    mount(index: number, reactor?: Reactor): Reactor;
+    /**
+     * 定义存储单元和存储关系
+     * @param reactor 存储单元
+     */
+    reflex(reactor: Reactor): number[];
+}
+/**
+ * 分类存储(通过继承，可用于拓展存储方式)
+ */
+export declare class MemoryBasic<T, Reactor, Type extends Memory.Type> {
+    #private;
+    protected key: Memory.Pitch<T, Type>;
+    protected list: T[];
+    protected memorys: Map<Type, Reactor>;
+    /**
+     * 返回存储长度
+     */
+    get size(): number;
+    /**
+     * @param key 用于对数据进行分类的key
+     * @param config
+     */
+    constructor(key: Memory.Pitch<T, Type>, config: Config<Reactor>);
+    protected getType(data: T): Type;
+    push(...list: T[]): this;
+    /**
+     * 返回位于指定索引处的项
+     */
+    at(index: number): T | undefined;
+    /**
+     * 遍历所有存储数据(按入栈顺序)
+     */
+    forEach(callback: (data: T, index: number) => void): this;
+    /**
+     * 遍历所有存储类型
+     */
+    forType(callback: (data: T[], type: Type) => void): this;
+    /**
+     * some(按入栈顺序)
+     */
+    some(callback: (data: T, index: number) => boolean): boolean;
+    /**
+     * map(按入栈顺序)
+     */
+    map<V>(callback: (data: T, index: number) => V): V[];
+    /**
+     * reduce(按入栈顺序)
+     */
+    reduce<V>(callback: (previousValue: V, currentValue: T, currentIndex: number) => V, initialValue: V): V;
+    /**
+     * 判断存储是否包含指定类型
+     */
+    includes(type: Type): boolean;
+    /**
+     * 获取指定类型存储数据
+     */
+    get(type: Type): T[] | null;
+    /**
+     * 删除指定存储数据
+     */
+    delete(data: T): this;
+    /**
+     * 删除指定类型存储数据
+     */
+    deleteType(type: Type): this;
+    /**
+     * 清理存储
+     */
+    clear(): void;
+}
+export {};

package/dist/memory/basic.mjs

@@ -0,0 +1,167 @@
+import { hash8strings } from "../convert/strings";
+class MemoryBasic {
+  /**
+   * @param key 用于对数据进行分类的key
+   * @param config 
+   */
+  constructor(key, config) {
+    this.key = key;
+    this.#mount = config.mount;
+    this.#reflex = config.reflex;
+  }
+  #mount;
+  #reflex;
+  list = [];
+  memorys = /* @__PURE__ */ new Map();
+  /**
+   * 返回存储长度
+   */
+  get size() {
+    return this.list.length;
+  }
+  getType(data) {
+    const { key } = this;
+    return typeof key === "function" ? key(data) : data[key];
+  }
+  push(...list) {
+    const { memorys } = this;
+    list.forEach((data) => {
+      const type = this.getType(data);
+      const memory = memorys.get(type);
+      const index = this.list.push(data) - 1;
+      const result = this.#mount(index, memory);
+      memory === result || memorys.set(type, result);
+    });
+    return this;
+  }
+  /**
+   * 返回位于指定索引处的项
+   */
+  at(index) {
+    const { list } = this;
+    if (index < 0) {
+      index += list.length;
+    }
+    return this.list.at(index);
+  }
+  /**
+   * 遍历所有存储数据(按入栈顺序)
+   */
+  forEach(callback) {
+    this.list.forEach(callback);
+    return this;
+  }
+  /**
+   * 遍历所有存储类型
+   */
+  forType(callback) {
+    const { memorys, list } = this;
+    for (const [type, memory] of memorys) {
+      const caches = this.#reflex(memory).map((index) => list[index]);
+      callback(caches, type);
+    }
+    return this;
+  }
+  /**
+   * some(按入栈顺序)
+   */
+  some(callback) {
+    return this.list.some(callback);
+  }
+  /**
+   * map(按入栈顺序)
+   */
+  map(callback) {
+    return this.list.map(callback);
+  }
+  /**
+   * reduce(按入栈顺序)
+   */
+  reduce(callback, initialValue) {
+    return this.list.reduce(callback, initialValue);
+  }
+  /**
+   * 判断存储是否包含指定类型
+   */
+  includes(type) {
+    return this.memorys.has(type);
+  }
+  /**
+   * 获取指定类型存储数据
+   */
+  get(type) {
+    const memory = this.memorys.get(type);
+    return memory === void 0 ? null : this.#reflex(memory).map((count) => this.list[count]);
+  }
+  /**
+   * 删除指定存储数据
+   */
+  delete(data) {
+    const { memorys, list } = this;
+    let index = -1;
+    if (!list.some((value, i) => {
+      if (data === value) {
+        index = i;
+        list.splice(index, 1);
+        const type = this.getType(value);
+        const memory = this.#reflex(memorys.get(type));
+        if (memory.length === 1) {
+          memorys.delete(type);
+        } else {
+          memory.some((count, j) => {
+            if (count === i) {
+              memory.splice(j, 1);
+              return true;
+            }
+          });
+        }
+        return true;
+      }
+    })) return this;
+    for (const [type, target] of memorys) {
+      const memory = this.#reflex(target);
+      memory.forEach((value, i) => {
+        if (value >= index) {
+          memory[i] = value - 1;
+        }
+      });
+      if (memory !== target) {
+        let reactor;
+        memory.forEach((count) => {
+          reactor = this.#mount(count, reactor);
+        });
+        memorys.set(type, reactor);
+      }
+    }
+    return this;
+  }
+  /**
+   * 删除指定类型存储数据
+   */
+  deleteType(type) {
+    const { memorys, list } = this;
+    if (!memorys.has(type)) return this;
+    const local = hash8strings(this.#reflex(memorys.get(type)));
+    const Memory = this.constructor;
+    const imitator = new Memory(this.key, {
+      mount: this.#mount,
+      reflex: this.#reflex
+    });
+    list.forEach((data, index) => {
+      index in local || imitator.push(data);
+    });
+    this.list = imitator.list;
+    this.memorys = imitator.memorys;
+    return this;
+  }
+  /**
+   * 清理存储
+   */
+  clear() {
+    this.list = [];
+    this.memorys.clear();
+  }
+}
+export {
+  MemoryBasic
+};

package/dist/memory/list.d.ts

@@ -0,0 +1,8 @@
+import { MemoryBasic } from './basic';
+import { type Memory } from './type';
+/**
+ * 分类存储(基于普通的键值存储)
+ */
+export declare class MemoryList<T, Type extends Memory.Type = Memory.Type> extends MemoryBasic<T, number[], Type> {
+    constructor(key: Memory.Pitch<T, Type>);
+}

package/dist/memory/list.mjs

@@ -0,0 +1,12 @@
+import { MemoryBasic } from "./basic";
+class MemoryList extends MemoryBasic {
+  constructor(key) {
+    super(key, {
+      mount: (index, reactor) => reactor ? (reactor.push(index), reactor) : [index],
+      reflex: (reactor) => reactor
+    });
+  }
+}
+export {
+  MemoryList
+};

package/dist/memory/power.d.ts

@@ -0,0 +1,8 @@
+import { MemoryBasic } from './basic';
+import { type Memory } from './type';
+/**
+ * 分类存储(基于2的n次幂之和构建唯一键进行存储)
+ */
+export declare class MemoryPower<T, Type extends Memory.Type = Memory.Type> extends MemoryBasic<T, number, Type> {
+    constructor(key: Memory.Pitch<T, Type>);
+}

package/dist/memory/power.mjs

@@ -0,0 +1,13 @@
+import { deconPowersSum } from "../power/decon";
+import { MemoryBasic } from "./basic";
+class MemoryPower extends MemoryBasic {
+  constructor(key) {
+    super(key, {
+      mount: (index, reactor) => (reactor || 0) + 2 ** index,
+      reflex: (reactor) => deconPowersSum(reactor, "asc")
+    });
+  }
+}
+export {
+  MemoryPower
+};

package/dist/memory/simple.d.ts

@@ -0,0 +1,60 @@
+import { Assign } from '@vope/types';
+import { MemoryBasic } from './basic';
+import { type Memory } from './type';
+type Transform<T, V> = {
+    [P in keyof T]: T[P] extends (...args: any) => any ? (...args: Parameters<T[P]>) => ReturnType<T[P]> extends T ? V : ReturnType<T[P]> : T[P];
+};
+type Basic<T, V, Type extends Memory.Type> = Assign<Transform<Omit<MemoryBasic<T, V, Type>, 'forType'>, MemorySimple<T, Type>>, {
+    get(type: Type): T | null;
+    at(index: number): T | undefined;
+}>;
+/**
+ * 简易存储(不分类)
+ */
+export declare class MemorySimple<T, Type extends Memory.Type> implements Basic<T, number, Type> {
+    #private;
+    get size(): number;
+    constructor(key: Memory.Pitch<T, Type>);
+    /**
+     * 返回位于指定索引处的项
+     */
+    at(index: number): T | undefined;
+    push(...list: T[]): this;
+    /**
+     * 获取指定类型存储数据
+     */
+    get(type: Type): T | null;
+    /**
+     * 遍历所有存储数据(按入栈顺序)
+     */
+    forEach(callback: (data: T, index: number) => void): this;
+    /**
+     * some(按入栈顺序)
+     */
+    some(callback: (data: T, index: number) => boolean): boolean;
+    /**
+     * map(按入栈顺序)
+     */
+    map<V>(callback: (data: T, index: number) => V): V[];
+    /**
+     * reduce(按入栈顺序)
+     */
+    reduce<V>(callback: (previousValue: V, currentValue: T, currentIndex: number) => V, initialValue: V): V;
+    /**
+     * 判断是否包含指定类型
+     */
+    includes(type: Type): boolean;
+    /**
+     * 删除指定存储数据
+     */
+    delete(data: T): this;
+    /**
+     * 删除指定类型存储数据
+     */
+    deleteType(type: Type): this;
+    /**
+     * 清理存储
+     */
+    clear(): void;
+}
+export {};

package/dist/memory/simple.mjs

@@ -0,0 +1,94 @@
+import { MemoryBasic } from "./basic";
+class MemorySimple {
+  #memory;
+  #key;
+  get size() {
+    return this.#memory.size;
+  }
+  constructor(key) {
+    this.#key = key;
+    this.#memory = new MemoryBasic(key, {
+      mount: (index) => index,
+      reflex: (reactor) => [reactor]
+    });
+  }
+  #getType(data) {
+    const key = this.#key;
+    return typeof key === "function" ? key(data) : data[key];
+  }
+  /**
+   * 返回位于指定索引处的项
+   */
+  at(index) {
+    return this.#memory.at(index);
+  }
+  push(...list) {
+    const memory = this.#memory;
+    list.forEach((data) => {
+      memory.includes(this.#getType(data)) || memory.push(data);
+    });
+    return this;
+  }
+  /**
+   * 获取指定类型存储数据
+   */
+  get(type) {
+    const value = this.#memory.get(type);
+    if (value === null) return value;
+    return value.length ? value[0] : null;
+  }
+  /**
+   * 遍历所有存储数据(按入栈顺序)
+   */
+  forEach(callback) {
+    this.#memory.forEach(callback);
+    return this;
+  }
+  /**
+   * some(按入栈顺序)
+   */
+  some(callback) {
+    return this.#memory.some(callback);
+  }
+  /**
+   * map(按入栈顺序)
+   */
+  map(callback) {
+    return this.#memory.map(callback);
+  }
+  /**
+   * reduce(按入栈顺序)
+   */
+  reduce(callback, initialValue) {
+    return this.#memory.reduce(callback, initialValue);
+  }
+  /**
+   * 判断是否包含指定类型
+   */
+  includes(type) {
+    return this.#memory.includes(type);
+  }
+  /**
+   * 删除指定存储数据
+   */
+  delete(data) {
+    this.#memory.delete(data);
+    return this;
+  }
+  /**
+   * 删除指定类型存储数据
+   */
+  deleteType(type) {
+    this.#memory.deleteType(type);
+    return this;
+  }
+  /**
+   * 清理存储
+   */
+  clear() {
+    this.#memory.clear();
+  }
+}
+export {
+  MemorySimple
+};

package/dist/neo4j-anchors.d.ts

@@ -0,0 +1,50 @@
+import Neo4j from './neo4j';
+interface IBox {
+    centerX: number;
+    centerY: number;
+}
+interface Config {
+    /** 多边之间的间隔弧长 */
+    radOffsetRaidx?: number;
+    getBox(id: string): IBox;
+}
+/**
+ * 图布局之二阶贝塞尔曲线边锚点管理
+ */
+export default class Neo4jAhchors<INode extends object, IEdge extends object> {
+    #private;
+    protected neo4j: Neo4j<INode, IEdge>;
+    protected config: Config;
+    constructor(neo4j: Neo4j<INode, IEdge>, config: Config);
+    protected getDir(start: string, end: string): string;
+    /**
+     * 设置多边间隔弧长
+     */
+    setRaidx(value: number): void;
+    /**
+     * 当图数据准备好后调用
+     */
+    read(): void;
+    protected calcPoints(edge: IEdge, index: number, total: number, type: 1 | -1): number[];
+    /**
+     * 获取指定节点上出入边连接点的坐标
+     */
+    getPoints(id: string): number[][];
+    /**
+     * 查找边连接点的位置
+     */
+    findAnchor(id: string): {
+        source: number;
+        target: number;
+    } | null;
+    /**
+     * 获取指定边控制点距离两端点连线的距离(可理解为控制边的弯曲程度)
+     * @description 返回值是一个相对值，需要乘以一个基数值(基数值应为负值，如-30)
+     */
+    getOffset(id: string): number;
+    /**
+     * 清理数据
+     */
+    clear(): void;
+}
+export {};