@nemigo/helpers 2.8.3 → 2.10.0

package/dist/aggregator.d.ts

@@ -1,5 +1,5 @@
-import type { CanBePromise } from "./types.js";
-export type AFunc = () => CanBePromise;
+import type { CanBeNullable, CanBePromise } from "./types.js";
+export type AFunc = CanBeNullable<() => CanBePromise>;
 /**
  * Aggregator для группового выполнения функций
  *

package/dist/aggregator.js

@@ -32,12 +32,12 @@ export class Aggregator {
         if (promise) {
             return (async () => {
                 // oxlint-disable-next-line eslint/require-await
-                await Promise.allSettled(this.__calls.map(async (f) => f()));
+                await Promise.allSettled(this.__calls.map(async (f) => f?.()));
                 this.__calls.length = 0;
             })();
         }
         for (const call of this.__calls)
-            void call();
+            void call?.();
         this.__calls.length = 0;
     }
 }

package/dist/async/index.d.ts

@@ -39,12 +39,15 @@ export declare const useStateGuard: <F extends AnyFunc>(func: F, state: IState<b
  *   * Аргументы обновляются
  * - `"urgent"`:
  *   * Первый вызов исполняется сразу
- *   * Повторные вызовы возвращают тот же промис в течение `ms`
+ *   * Повторные вызовы возвращают тот же промис в течение `ms` (задержка до следующего вызова, без учёта времени на выполнение)
  *   * Аргументы обновляются, но не влияют, если функция уже выполняется
  */
 export type ThrottleMode = "urgent" | "delay";
 export interface ThrottleOptions {
-    state?: IState<boolean>;
+    /**
+     * Общее состояние (и выполнение функции и задержка)
+     */
+    state?: (v: boolean, step: "start" | "delay" | "running" | "reset") => void;
     /**
      * @default "urgent"
      */

package/dist/async/index.js

@@ -74,25 +74,28 @@ export const throttle = (func, { mode = "urgent", ms = 250, state }) => {
     const call = async () => await func(..._args);
     const reset = () => {
         _promise = null;
-        state?.set(false);
+        state?.(false, "reset");
     };
     return (...args) => {
         _args = args;
         if (_promise)
             return _promise;
-        state?.set(true);
+        state?.(true, "start");
         const { resolve, reject, promise } = createManualPromise();
         _promise = promise;
         if (mode === "delay") {
+            state?.(true, "delay");
             setTimeout(() => {
+                state?.(true, "running");
                 call().then(resolve).catch(reject).finally(reset);
             }, ms);
         }
         else {
+            state?.(true, "running");
             call()
                 .then(resolve)
                 .catch(reject)
-                .finally(() => void delay(ms).then(reset));
+                .finally(() => (state?.(true, "delay"), void delay(ms).then(reset)));
         }
         return _promise;
     };

package/dist/emitter.js

@@ -6,11 +6,14 @@
 export class Emitter {
     __listeners = new Map();
     dispatch(event, data) {
-        for (const [key, handler] of this.__listeners.entries()) {
-            if (event === handler.event)
+        for (const [key, handler] of Array.from(this.__listeners.entries())) {
+            if (!this.__listeners.has(key))
+                continue; // мог быть снят другим хендлером
+            if (handler.event === event) {
                 handler.callback(data);
-            if (handler.once)
-                this.__listeners.delete(key);
+                if (handler.once)
+                    this.__listeners.delete(key);
+            }
         }
     }
     /**

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { AnyFunc } from "./types.js";
+import type { AnyFunc, CanBeNullable, CanBePromise } from "./types.js";
 /**
  * Преобразует число в строку, добавляя ведущие нули для достижения указанной длины
  *
@@ -14,10 +14,14 @@ export declare const pad: (v: number, l?: number) => string;
  * Если значение не `object` - возвращается как есть
  */
 export declare const parsify: <T>(v: T) => T;
+/**
+ * С осознанным игнором undefined и для простых типов
+ */
+export declare const isDataEqual: (a: any, b: any) => boolean;
 /**
  * Агрегация функций в одну
  */
-export declare const aggregate: (...args: (() => void)[]) => (() => void);
+export declare const aggregate: (...args: CanBeNullable<() => CanBePromise>[]) => (() => void);
 /**
  * Проверяет, является ли значение объектом
  *

package/dist/index.js

@@ -17,12 +17,47 @@ export const parsify = (v) => {
         return v;
     return JSON.parse(JSON.stringify(v));
 };
+/**
+ * С осознанным игнором undefined и для простых типов
+ */
+export const isDataEqual = (a, b) => {
+    // oxlint-disable-next-line unicorn/no-abusive-eslint-disable (тут лучше так)
+    // oxlint-disable-next-line eslint/eqeqeq eslint/no-eq-null (тут лучше так)
+    // eslint-disable-next-line no-eq-null,eqeqeq
+    if (a == null || b == null || typeof a !== "object" || typeof b !== "object")
+        return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    let lenA = 0, lenB = 0;
+    // Один проход: считаем defined ключи и сразу проверяем наличие в другом объекте
+    for (const k of keysA) {
+        if (a[k] !== undefined) {
+            lenA++;
+            if (!(k in b) || b[k] === undefined)
+                return false;
+        }
+    }
+    for (const k of keysB) {
+        if (b[k] !== undefined) {
+            lenB++;
+            if (!(k in a) || a[k] === undefined)
+                return false;
+        }
+    }
+    if (lenA !== lenB)
+        return false;
+    // Рекурсия только по подтверждённо существующим defined ключам
+    for (const k of keysA)
+        if (a[k] !== undefined && !isDataEqual(a[k], b[k]))
+            return false;
+    return true;
+};
 /**
  * Агрегация функций в одну
  */
 export const aggregate = (...args) => () => {
     for (const call of args)
-        call();
+        void call?.();
 };
 //...
 /**

package/dist/promoter.js

@@ -4,7 +4,9 @@
 export class Promoter {
     __subs = new Map();
     notify(event) {
-        for (const [key, { callback, once }] of this.__subs.entries()) {
+        for (const [key, { callback, once }] of Array.from(this.__subs.entries())) {
+            if (!this.__subs.has(key))
+                continue; // мог быть снят другим хендлером
             callback(event);
             if (once)
                 this.__subs.delete(key);

package/dist/types.d.ts

@@ -152,6 +152,12 @@ export type Exist<T> = Exclude<T, undefined>;
  * ```
  */
 export type KEYS<O> = keyof O extends infer Key ? (Key extends string ? Key : never) : never;
+/**
+ * Убирает все never-значения из объекта
+ */
+export type NeverKeysFilterType<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
 /**
  * Примитив для всех записей с идентификатором
  */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nemigo/helpers",
-	"version": "2.8.3",
+	"version": "2.10.0",
 	"private": false,
 	"license": "MPL-2.0",
 	"author": {