@vope/utils 1.4.12 → 1.4.14

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,79 @@ 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;
+  }
+  /**
+   * 获取指定类型存储数据
+   */
+  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;
@@ -527,6 +605,7 @@ var css = (...args) => {
 // src/subscriber.ts
 var Subscriber = class {
   #listeners = {};
+  #once = {};
   $on(name, listener) {
     const listeners = this.#listeners;
     if (name in listeners) {
@@ -536,23 +615,52 @@ var Subscriber = class {
     }
     return this;
   }
+  $once(name, listener) {
+    this.$on(name, listener);
+    const index = this.#listeners[name].length - 1;
+    const once2 = this.#once;
+    if (name in once2) {
+      once2[name].push(index);
+    } else {
+      once2[name] = [index];
+    }
+    return this;
+  }
   $emit(name, ...args) {
-    this.#listeners[name]?.forEach((listener) => listener(...args));
+    const listeners = this.#listeners[name];
+    if (!listeners)
+      return this;
+    const once2 = hash8strings(this.#once[name] || []);
+    this.#listeners[name] = listeners.reduce((list, listener, index) => {
+      listener(...args);
+      index in once2 || list.push(listener);
+      return list;
+    }, []);
+    delete this.#once[name];
     return this;
   }
   $off(name, listener) {
     const listeners = this.#listeners;
+    const once2 = this.#once;
     if (name in listeners === false)
       return this;
     if (listener) {
+      let count;
       listeners[name].some((value, index) => {
         if (value === listener) {
+          count = index;
+          listeners[name].splice(index, 1);
+          return true;
+        }
+      }) && once2[name].some((value, index) => {
+        if (value === count) {
           listeners[name].splice(index, 1);
           return true;
         }
       });
     } else {
       delete listeners[name];
+      delete this.#once[name];
     }
     return this;
   }

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,75 @@
+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;
+  }
+  /**
+   * 获取指定类型存储数据
+   */
+  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/lib/subscriber.js

@@ -1,5 +1,7 @@
+import { hash8strings } from "./convert/strings";
 class Subscriber {
   #listeners = {};
+  #once = {};
   $on(name, listener) {
     const listeners = this.#listeners;
     if (name in listeners) {
@@ -9,23 +11,52 @@ class Subscriber {
     }
     return this;
   }
+  $once(name, listener) {
+    this.$on(name, listener);
+    const index = this.#listeners[name].length - 1;
+    const once = this.#once;
+    if (name in once) {
+      once[name].push(index);
+    } else {
+      once[name] = [index];
+    }
+    return this;
+  }
   $emit(name, ...args) {
-    this.#listeners[name]?.forEach((listener) => listener(...args));
+    const listeners = this.#listeners[name];
+    if (!listeners)
+      return this;
+    const once = hash8strings(this.#once[name] || []);
+    this.#listeners[name] = listeners.reduce((list, listener, index) => {
+      listener(...args);
+      index in once || list.push(listener);
+      return list;
+    }, []);
+    delete this.#once[name];
     return this;
   }
   $off(name, listener) {
     const listeners = this.#listeners;
+    const once = this.#once;
     if (name in listeners === false)
       return this;
     if (listener) {
+      let count;
       listeners[name].some((value, index) => {
         if (value === listener) {
+          count = index;
+          listeners[name].splice(index, 1);
+          return true;
+        }
+      }) && once[name].some((value, index) => {
+        if (value === count) {
           listeners[name].splice(index, 1);
           return true;
         }
       });
     } else {
       delete listeners[name];
+      delete this.#once[name];
     }
     return this;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vope/utils",
-  "version": "1.4.12",
+  "version": "1.4.14",
   "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,6 +12,7 @@ interface Config<Reactor> {
      */
     reflex(reactor: Reactor): number[];
 }
+export type _LV<T> = (T | _LV<T>)[];
 /**
  * 分类存储(通过继承，可用于拓展存储方式)
  */
@@ -30,7 +31,7 @@ export declare class MemoryBasic<V, Reactor, Type extends Memory.Type> {
      */
     constructor(key: Memory.Pitch<V, Type>, config: Config<Reactor>);
     protected getType(data: V): Type;
-    push(...list: V[]): this;
+    push(...list: _LV<V>): this;
     /**
      * 遍历所有存储数据(按入栈顺序)
      */

package/types/memory/simple.d.ts

@@ -0,0 +1,35 @@
+import { _LV } from './basic';
+import { Memory } from './type';
+/**
+ * 简易存储(不分类)
+ */
+export declare class MemorySimple<T, Type extends Memory.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;
+    /**
+     * 获取指定类型存储数据
+     */
+    includes(type: Type): boolean;
+    /**
+     * 删除指定存储数据
+     */
+    delete(data: T): this;
+    /**
+     * 删除指定类型存储数据
+     */
+    deleteType(type: Type): this;
+    /**
+     * 清理存储
+     */
+    clear(): void;
+}

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

package/types/rotate/angle.d.ts

@@ -1,8 +1,8 @@
-import { _Point } from './rad';
+import { Point2Tuple } from '@vope/types';
 /**
  * 返回点被旋转指定角度后新的位置
  * @param from 旋转点
  * @param angle 旋转角度
  * @param visit 旋转原点
  */
-export declare const rotateAngle: (from: _Point, angle: number, visit?: _Point) => _Point;
+export declare const rotateAngle: (from: Point2Tuple, angle: number, visit?: Point2Tuple) => Point2Tuple;

package/types/rotate/rad.d.ts

@@ -1,8 +1,8 @@
-export type _Point = [number, number];
+import { Point2Tuple } from '@vope/types';
 /**
  * 返回点被旋转指定弧度后新的位置
  * @param from 旋转点
  * @param rad 旋转弧度
  * @param visit 旋转原点
  */
-export declare const rotateRad: (from: _Point, rad: number, visit?: _Point) => _Point;
+export declare const rotateRad: (from: Point2Tuple, rad: number, visit?: Point2Tuple) => Point2Tuple;

package/types/subscriber.d.ts

@@ -1,9 +1,10 @@
 /**
  * 订阅
  */
-export default class Subscriber<T extends Record<string, (...args: any[]) => void>> {
+export default class Subscriber<T extends Record<keyof any, (...args: any[]) => void>> {
     #private;
     $on<K extends keyof T>(name: K, listener: T[K]): this;
+    $once<K extends keyof T>(name: K, listener: T[K]): this;
     $emit<K extends keyof T>(name: K, ...args: Parameters<T[K]>): this;
     $off<K extends keyof T>(name: K, listener?: T[K]): this;
 }