@nemigo/helpers 0.13.2 → 0.13.3

package/dist/async/space.d.ts

@@ -1,5 +1,6 @@
+import { AsyncLocalStorage } from "async_hooks";
 export declare abstract class AsyncSpace<TX> {
-    private async_storage;
+    __async_storage: AsyncLocalStorage<TX[]>;
     getTX(): TX[];
     space<T>(call: (tx: TX[]) => Promise<T>, auto?: boolean): Promise<T>;
     commit(): Promise<void>;

package/dist/async/space.js

@@ -1,19 +1,19 @@
 import { AsyncLocalStorage } from "async_hooks";
 export class AsyncSpace {
-    async_storage = new AsyncLocalStorage();
+    __async_storage = new AsyncLocalStorage();
     getTX() {
-        const ctx = this.async_storage.getStore();
+        const ctx = this.__async_storage.getStore();
         if (ctx)
             return ctx;
         throw new Error("getTX() called outside of space()");
     }
     async space(call, auto = true) {
-        const ctx = this.async_storage.getStore();
+        const ctx = this.__async_storage.getStore();
         if (ctx)
             return call(ctx);
         // Создаем новое пространство
         const tx = [];
-        const result = await this.async_storage.run(tx, () => call(tx));
+        const result = await this.__async_storage.run(tx, () => call(tx));
         // Автоматически выполняем транзакции, если они есть и включен автокоммит
         if (auto && tx.length > 0) {
             await this.submit(tx);
@@ -22,7 +22,7 @@ export class AsyncSpace {
         return result;
     }
     async commit() {
-        const ctx = this.async_storage.getStore();
+        const ctx = this.__async_storage.getStore();
         if (!ctx)
             throw new Error("commit() called outside of space()");
         await this.submit(ctx);

package/dist/future.d.ts

@@ -47,4 +47,5 @@ export declare class Future {
      * Функция будет обёрнута в {@link boundary} при вызове
      */
     run(call: () => CanBePromise, { type, key, delay }?: FutureOptions): void;
+    has(type: FutureType, key: RID): boolean;
 }

package/dist/future.js

@@ -47,7 +47,15 @@ export class Future {
     run(call, { type = "timer", key = Symbol(), delay = this.delay } = {}) {
         if (type === "timer") {
             this.reset(type, this.timers, key);
-            const timer = setTimeout(call, delay);
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            const timer = setTimeout(async () => {
+                try {
+                    await call();
+                }
+                finally {
+                    this.timers.delete(key);
+                }
+            }, delay);
             this.timers.set(key, timer);
         }
         else {
@@ -56,4 +64,8 @@ export class Future {
             this.intervals.set(key, timer);
         }
     }
+    has(type, key) {
+        const map = this.get(type);
+        return map.has(key);
+    }
 }

package/dist/lru.d.ts

@@ -1,4 +1,4 @@
-import type { RID } from "./types.js";
+import type { RID, Timestamp } from "./types.js";
 /**
  * LRU (Least Recently Used) кэш с поддержкой TTL (time-to-live)
  *
@@ -20,12 +20,12 @@ export declare class LRU<V = unknown, K extends RID = string> {
     /**
      * Максимальное количество элементов в кэше
      */
-    private readonly max;
+    readonly max: number;
     /**
      * Глобальный TTL (time-to-live) для каждого элемента в {@link Timestamp}.
      * Если не задан (`undefined`), элементы не устаревают глобально
      */
-    private readonly ttl?;
+    readonly ttl?: Timestamp;
     /**
      * Внутреннее хранилище кэша.
      * Хранит значения вместе с информацией о времени истечения срока их действия

package/dist/omitter.d.ts

@@ -64,7 +64,10 @@ export type MergeOmitSchemas<S1, S2> = {
  */
 export declare class Omitter<Source, OmitSchema> {
     #private;
-    private readonly structure;
+    readonly __structure: {
+        keys: Set<KEYS<OmitSchema>>;
+        nested: Map<KEYS<OmitSchema>, Omitter<any, any>>;
+    };
     readonly schema: OmitSchema;
     readonly zip: ZIP;
     constructor(schema: OmitSchema);

package/dist/omitter.js

@@ -12,7 +12,7 @@ import { zipper } from "./zipper.js";
  * const result = omitter.run(source); // { a: 1, b: { d: 3 }, e: 4 }
  */
 export class Omitter {
-    structure;
+    __structure;
     schema;
     zip;
     constructor(schema) {
@@ -27,19 +27,19 @@ export class Omitter {
             }
             return true;
         }));
-        this.structure = { keys, nested };
+        this.__structure = { keys, nested };
     }
     /**
      * Получение хэша вложенного эмиттера
      */
     into(key) {
-        return this.structure.nested.get(key)?.zip;
+        return this.__structure.nested.get(key)?.zip;
     }
     /**
      * Проверяет, останется ли ключ в итоговом объекте
      */
     left(key) {
-        return !this.structure.keys.has(key);
+        return !this.__structure.keys.has(key);
     }
     /**
      * Рекурсивно удаляет ключи из объекта на основе структуры
@@ -58,7 +58,7 @@ export class Omitter {
             structure.nested.forEach((omitter, key) => {
                 const nested = obj[key];
                 if (nested && typeof nested === "object")
-                    omitter.#process(nested, omitter.structure);
+                    omitter.#process(nested, omitter.__structure);
             });
         }
         else {
@@ -72,7 +72,7 @@ export class Omitter {
                     if (omitter) {
                         const nested = obj[key];
                         if (nested && typeof nested === "object") {
-                            omitter.#process(nested, omitter.structure);
+                            omitter.#process(nested, omitter.__structure);
                         }
                     }
                 }
@@ -86,7 +86,7 @@ export class Omitter {
      * @returns Объект с удалёнными ключами
      */
     run(source) {
-        this.#process(source, this.structure);
+        this.#process(source, this.__structure);
         return source;
     }
 }

package/dist/promoter.d.ts

@@ -3,7 +3,10 @@ import type { RID } from "./types.js";
  * Класс для создания простого механизма подписок
  */
 export declare class Promoter<Data> {
-    private __subs;
+    __subs: Map<RID, {
+        call: (data: Data) => void;
+        once?: boolean;
+    }>;
     /**
      * Вызывает подписчиков
      */

package/dist/queue.d.ts

@@ -16,12 +16,13 @@ export declare abstract class Queue<T> {
      * Добавляет элемент в очередь и запускает обработку
      *
      * @param item - Элемент для добавления в очередь
+     * @param run - Запуск очереди
      */
-    protected push(item: T): void;
+    protected push(item: T, run?: boolean): void;
     /**
      * Запускает обработку очереди с задержкой
      */
-    private run;
+    run(): void;
     /**
      * Метод для обработки элемента очереди
      *

package/dist/queue.js

@@ -18,10 +18,12 @@ export class Queue {
      * Добавляет элемент в очередь и запускает обработку
      *
      * @param item - Элемент для добавления в очередь
+     * @param run - Запуск очереди
      */
-    push(item) {
+    push(item, run = true) {
         this._queue.push(item);
-        this.run();
+        if (run)
+            this.run();
     }
     /**
      * Запускает обработку очереди с задержкой

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nemigo/helpers",
-	"version": "0.13.2",
+	"version": "0.13.3",
 	"private": false,
 	"author": {
 		"name": "Vlad Logvin",