@vope/utils 1.4.13 → 1.4.15

package/cjs/index.js

@@ -24,6 +24,7 @@ __export(src_exports, {
   MemoryBasic: () => MemoryBasic,
   MemoryList: () => MemoryList,
   MemoryPower: () => MemoryPower,
+  MemorySimple: () => MemorySimple,
   Subscriber: () => Subscriber,
   Union: () => Union,
   clamp: () => clamp,
@@ -331,11 +332,15 @@ var MemoryBasic = class {
   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);
+      if (Array.isArray(data)) {
+        this.push(...data);
+      } else {
+        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;
   }
@@ -480,6 +485,89 @@ var MemoryPower = class extends MemoryBasic {
   }
 };
 
+// src/memory/simple.ts
+var MemorySimple = class {
+  #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];
+  }
+  push(...list) {
+    const memory = this.#memory;
+    list.forEach((data) => {
+      if (Array.isArray(data)) {
+        this.push(...data);
+      } else if (!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;
+  }
+  /**
+   * map(按入栈顺序)
+   */
+  map(callback) {
+    const list = [];
+    this.#memory.forEach((data, index) => {
+      list.push(callback(data, index));
+    });
+    return list;
+  }
+  /**
+   * 获取指定类型存储数据
+   */
+  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();
+  }
+};
+
 // src/once.ts
 var once = (func, thisArg) => {
   let local;

package/lib/index.js

@@ -16,6 +16,7 @@ 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 { once } from "./once";
 import { deconPowersSum } from "./power/decon";
 import { rotateAngle } from "./rotate/angle";
@@ -32,6 +33,7 @@ export {
   MemoryBasic,
   MemoryList,
   MemoryPower,
+  MemorySimple,
   default2 as Subscriber,
   Union,
   clamp,

package/lib/memory/basic.js

@@ -26,11 +26,15 @@ class MemoryBasic {
   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);
+      if (Array.isArray(data)) {
+        this.push(...data);
+      } else {
+        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;
   }

package/lib/memory/simple.js

@@ -0,0 +1,85 @@
+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];
+  }
+  push(...list) {
+    const memory = this.#memory;
+    list.forEach((data) => {
+      if (Array.isArray(data)) {
+        this.push(...data);
+      } else if (!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;
+  }
+  /**
+   * map(按入栈顺序)
+   */
+  map(callback) {
+    const list = [];
+    this.#memory.forEach((data, index) => {
+      list.push(callback(data, index));
+    });
+    return list;
+  }
+  /**
+   * 获取指定类型存储数据
+   */
+  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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vope/utils",
-  "version": "1.4.13",
+  "version": "1.4.15",
   "description": "",
   "type": "module",
   "publishConfig": {

package/types/index.d.ts

@@ -16,6 +16,7 @@ export { loadImage } from './load/image';
 export { MemoryBasic } from './memory/basic';
 export { MemoryList } from './memory/list';
 export { MemoryPower } from './memory/power';
+export { MemorySimple } from './memory/simple';
 export { once } from './once';
 export { deconPowersSum } from './power/decon';
 export { rotateAngle } from './rotate/angle';

package/types/memory/basic.d.ts

@@ -12,13 +12,14 @@ interface Config<Reactor> {
      */
     reflex(reactor: Reactor): number[];
 }
+export type _LV<T> = (T | _LV<T>)[];
 /**
  * 分类存储(通过继承，可用于拓展存储方式)
  */
-export declare class MemoryBasic<V, Reactor, Type extends Memory.Type> {
+export declare class MemoryBasic<T, Reactor, Type extends Memory.Type> {
     #private;
-    protected key: Memory.Pitch<V, Type>;
-    protected list: V[];
+    protected key: Memory.Pitch<T, Type>;
+    protected list: T[];
     protected memorys: Map<Type, Reactor>;
     /**
      * 返回存储长度
@@ -28,17 +29,17 @@ export declare class MemoryBasic<V, Reactor, Type extends Memory.Type> {
      * @param key 用于对数据进行分类的key
      * @param config
      */
-    constructor(key: Memory.Pitch<V, Type>, config: Config<Reactor>);
-    protected getType(data: V): Type;
-    push(...list: V[]): this;
+    constructor(key: Memory.Pitch<T, Type>, config: Config<Reactor>);
+    protected getType(data: T): Type;
+    push(...list: _LV<T>): this;
     /**
      * 遍历所有存储数据(按入栈顺序)
      */
-    forEach(callback: (data: V, index: number) => void): this;
+    forEach(callback: (data: T, index: number) => void): this;
     /**
      * 遍历所有存储类型
      */
-    forType(callback: (data: V[], type: Type) => void): this;
+    forType(callback: (data: T[], type: Type) => void): this;
     /**
      * 检测存储是否包含某种类型
      */
@@ -46,11 +47,11 @@ export declare class MemoryBasic<V, Reactor, Type extends Memory.Type> {
     /**
      * 获取指定类型存储数据
      */
-    get(type: Type): V[] | null;
+    get(type: Type): T[] | null;
     /**
      * 删除指定存储数据
      */
-    delete(data: V): this;
+    delete(data: T): this;
     /**
      * 删除指定类型存储数据
      */

package/types/memory/list.d.ts

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

package/types/memory/power.d.ts

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

package/types/memory/simple.d.ts

@@ -0,0 +1,47 @@
+import { Assign } from '@vope/types';
+import { MemoryBasic, _LV } from './basic';
+import { 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;
+}>;
+/**
+ * 简易存储(不分类)
+ */
+export declare class MemorySimple<T, Type extends Memory.Type> implements Basic<T, number, Type> {
+    #private;
+    get size(): number;
+    constructor(key: Memory.Pitch<T, Type>);
+    push(...list: _LV<T>): this;
+    /**
+     * 获取指定类型存储数据
+     */
+    get(type: Type): T | null;
+    /**
+     * 遍历所有存储数据(按入栈顺序)
+     */
+    forEach(callback: (data: T, index: number) => void): this;
+    /**
+     * map(按入栈顺序)
+     */
+    map<V>(callback: (data: T, index: number) => V): V[];
+    /**
+     * 获取指定类型存储数据
+     */
+    includes(type: Type): boolean;
+    /**
+     * 删除指定存储数据
+     */
+    delete(data: T): this;
+    /**
+     * 删除指定类型存储数据
+     */
+    deleteType(type: Type): this;
+    /**
+     * 清理存储
+     */
+    clear(): void;
+}
+export {};

package/types/memory/type.d.ts

@@ -1,7 +1,7 @@
 import { GetGivenProps } from '@vope/types'
 
 export namespace Memory { 
-  type Type = string | number
+  type Type = string | number | symbol
 
   type Pitch<Data, Type> = (
     Data extends object