@softsky/utils 2.5.5 → 2.6.0

package/README.md

@@ -150,7 +150,7 @@ __function__ `createThrottledFunction` - Create throttled function. Basically li
 
 ---
 __function__ `createDelayedFunction` - Create debounced function. Basically create function that will be called with delay,
-but if another call comes in, we reset the timer.
+but if another call comes in, we reset the timer (previous function isn't called).
 
 ---
 __class__ `ImmediatePromise` - Promise that accepts no callback, but exposes `resolve` and `reject` methods
@@ -158,6 +158,9 @@ __class__ `ImmediatePromise` - Promise that accepts no callback, but exposes `re
 ---
 __function__ `wait` - setTimeout promisify
 
+---
+__function__ `timeout` - Reject after specified time
+
 ---
 __function__ `noop` - Empty function that does nothing
 
@@ -167,6 +170,37 @@ __async function__ `concurrentRun` - Run array of async tasks concurrently
 ---
 __class__ `SimpleEventSource` - Create simple event source. Consider using `signal()` for reactive state managment.
 
+---
+__class__ `Semaphore` - Semaphore is used to limit concurrent tasks by delaying promise.
+
+```ts
+const semaphore = new Semaphore(2);
+
+async function task() {
+await semaphore.acquire();
+try {
+// This code can only be executed by two tasks at the same time
+} finally {
+semaphore.release();
+}
+}
+task();
+task();
+task(); // This task will wait until one of the previous tasks releases the semaphore.
+
+// === SHORTHAND ===
+semaphore.run(()=>{
+// Your code
+})
+semaphore.run(()=>{
+// Your code
+})
+// ...
+```
+
+---
+__async function__ `withTimeout` - Add timeout to a promise
+
 ---
 
 
@@ -175,6 +209,9 @@ Custom errors, finding errors and error handling.
 
 __class__ `ValidationError` - Use as intended error. Basically 4** errors in HTTP
 
+---
+__class__ `TimeoutError` - Use as intended error. Basically 4** errors in HTTP
+
 ---
 __function__ `findErrorText` - Find error inside anything recursively.
 Good for finding human-readable errors.
@@ -274,6 +311,27 @@ __function__ `factorial` - Factorial
 ---
 __function__ `fib` - Fibonacci
 
+---
+__function__ `clamp` - Clamp numbers to max and min
+
+---
+__function__ `inRange` - Is number in range. Inclusive.
+
+---
+__function__ `mean` - Calucalate avarage from array of numbers
+
+---
+__function__ `round` - Round with precision.
+
+```ts
+round(1.2345); // 1
+round(1.2345, 2); // 1.23
+round(1.2345, 10); // 1.2345
+```
+
+---
+__function__ `sum` - Sum of array of numbers
+
 ---
 
 
@@ -352,7 +410,7 @@ Effects are simplest way to react to signal changes.
 Returned data from handler function will be passed to it on next signal change.
 Returns a function that will clear the effect.
 
-```ts
+
 // Will print signal on change
 effect(()=>{
 console.log($mySignal())
@@ -363,7 +421,6 @@ const mySignal = $mySignal()
 if(last>mySignal) console.log('Increment!')
 return mySignal;
 })
-```
 
 ---
 __function__ `untrack` - __SIGNALS SYSTEM__
@@ -513,19 +570,16 @@ __type__ `Concat` - Concat types of array or objects
 
 ---
 __type__ `Prettify` - Visual only overhaul. Shows final type result on hover.
+
 ```ts
 type a = {a: '1'}
 type b = Prettify<a & { b: 'b' }>
-```
-On hovering b it will show
-```ts
+// On hovering b it will show
 type b = {
 a: "1";
 b: "b";
 }
-```
-instead of
-```ts
+// instead of
 type b = a & {
 b: "b";
 }

package/dist/control.d.ts

@@ -26,7 +26,7 @@ export declare function extractUUIDDate(uuid: string): Date;
  *  hash
  * ]
  */
-export declare function createCashedFunction<T, V extends JSONSerializable[]>(function_: (...arguments_: V) => T): readonly [(...arguments_: V) => T, (...arguments_: V) => boolean, Map<string, T>];
+export declare function createCashedFunction<T, V extends JSONSerializable[]>(run: (...data: V) => T): readonly [(...data: V) => T, (...data: V) => boolean, Map<string, T>];
 /**
  * Creates cached function. All arguments/results are cached. Will store in cache resolved data.
  * Returns [
@@ -35,16 +35,16 @@ export declare function createCashedFunction<T, V extends JSONSerializable[]>(fu
  *  hash
  * ]
  */
-export declare function createCashedAsyncFunction<T, V extends JSONSerializable[]>(function_: (...arguments_: V) => Promise<T>): readonly [(...arguments_: V) => Promise<T>, (...arguments_: V) => boolean, Map<string, T>];
+export declare function createCashedAsyncFunction<T, V extends JSONSerializable[]>(run: (...data: V) => Promise<T>): readonly [(...data: V) => Promise<T>, (...data: V) => boolean, Map<string, T>];
 /** Retry async function */
-export declare function retry<T>(function_: () => Promise<T>, retries?: number, interval?: number | number[], ignore?: (error: unknown) => boolean): Promise<T>;
+export declare function retry<T>(run: () => Promise<T>, retries?: number, interval?: number | number[], ignore?: (error: unknown) => boolean): Promise<T>;
 /** Create debounced function. Basically adds cooldown to function. Warning: throws! */
-export declare function createDebouncedFunction<T, V extends unknown[]>(function_: (...arguments_: V) => T, time: number): (...arguments_: V) => T;
+export declare function createDebouncedFunction<T, V extends unknown[]>(run: (...data: V) => T, time: number): (...data: V) => T;
 /** Create throttled function. Basically limits function calls in time period. Warning: throws! */
-export declare function createThrottledFunction<T, V extends unknown[]>(function_: (...arguments_: V) => T, calls: number, time: number): (...arguments_: V) => T;
+export declare function createThrottledFunction<T, V extends unknown[]>(run: (...data: V) => T, calls: number, time: number): (...data: V) => T;
 /** Create debounced function. Basically create function that will be called with delay,
- * but if another call comes in, we reset the timer. */
-export declare function createDelayedFunction<T, V extends unknown[]>(function_: (...arguments_: V) => T, time: number): (...arguments_: V) => Promise<T>;
+ * but if another call comes in, we reset the timer (previous function isn't called). */
+export declare function createDelayedFunction<T, V extends unknown[]>(run: (...data: V) => T, time: number): (...data: V) => Promise<T>;
 type ResolveFunction<T> = undefined extends T ? (value?: T | PromiseLike<T>) => void : (value: T | PromiseLike<T>) => void;
 /** Promise that accepts no callback, but exposes `resolve` and `reject` methods */
 export declare class ImmediatePromise<T> extends Promise<T> {
@@ -56,6 +56,8 @@ export declare class ImmediatePromise<T> extends Promise<T> {
 export default function deepPromiseAll<T>(input: T): Promise<AwaitedObject<T>>;
 /** setTimeout promisify */
 export declare function wait(time: number): Promise<unknown>;
+/** Reject after specified time */
+export declare function timeout(time: number): Promise<never>;
 /** Empty function that does nothing */
 export declare function noop(): void;
 /** Run array of async tasks concurrently */
@@ -75,4 +77,50 @@ export declare class SimpleEventSource<EVENTS extends Record<string, unknown>> {
         off: <T extends keyof EVENTS>(name: T, handler: (data: EVENTS[T]) => unknown) => void;
     };
 }
+/**
+ * Semaphore is used to limit concurrent tasks by delaying promise.
+ *
+ * ```ts
+ * const semaphore = new Semaphore(2);
+ *
+ * async function task() {
+ *   await semaphore.acquire();
+ *   try {
+ *     // This code can only be executed by two tasks at the same time
+ *   } finally {
+ *     semaphore.release();
+ *   }
+ * }
+ * task();
+ * task();
+ * task(); // This task will wait until one of the previous tasks releases the semaphore.
+ *
+ * // === SHORTHAND ===
+ * semaphore.run(()=>{
+ *    // Your code
+ * })
+ * semaphore.run(()=>{
+ *    // Your code
+ * })
+ * // ...
+ * ```
+ */
+export declare class Semaphore {
+    /** The maximum number of concurrent operations allowed.*/
+    capacity: number;
+    /** Tasks running. */
+    running: number;
+    protected deferredTasks: (() => void)[];
+    constructor(
+    /** The maximum number of concurrent operations allowed.*/
+    capacity: number);
+    /** Acquires a semaphore, blocking if necessary until one is available. */
+    acquire(): Promise<void>;
+    /** Releases a semaphore, allowing one more operation to proceed. */
+    release(): void;
+    /** Shorthand for running functions */
+    run<T>(run: () => T): Promise<T>;
+}
+/** Add timeout to a promise */
+export declare function withTimeout<T>(run: () => Promise<T>, ms: number): Promise<T>;
 export {};

package/dist/control.js

@@ -2,6 +2,7 @@
  * Utils related to code execution flow.
  */
 import { removeFromArray } from './arrays';
+import { DelayedError, TimeoutError } from './errors';
 let lastIncId = Math.floor(Math.random() * 0x1_00_00);
 /** Id generated only once per session */
 export const SESSION_ID = Math.floor(Math.random() * 0x10_00_00_00_00_00_00)
@@ -38,19 +39,19 @@ export function extractUUIDDate(uuid) {
  *  hash
  * ]
  */
-export function createCashedFunction(function_) {
+export function createCashedFunction(run) {
     const hash = new Map();
     return [
-        (...arguments_) => {
-            const key = JSON.stringify(arguments_);
+        (...data) => {
+            const key = JSON.stringify(data);
             const value = hash.get(key);
             if (value)
                 return value;
-            const newValue = function_(...arguments_);
+            const newValue = run(...data);
             hash.set(key, newValue);
             return newValue;
         },
-        (...arguments_) => hash.delete(JSON.stringify(arguments_)),
+        (...data) => hash.delete(JSON.stringify(data)),
         hash,
     ];
 }
@@ -62,26 +63,26 @@ export function createCashedFunction(function_) {
  *  hash
  * ]
  */
-export function createCashedAsyncFunction(function_) {
+export function createCashedAsyncFunction(run) {
     const hash = new Map();
     return [
-        async (...arguments_) => {
-            const key = JSON.stringify(arguments_);
+        async (...data) => {
+            const key = JSON.stringify(data);
             const value = hash.get(key);
             if (value)
                 return value;
-            const newValue = await function_(...arguments_);
+            const newValue = await run(...data);
             hash.set(key, newValue);
             return newValue;
         },
-        (...arguments_) => hash.delete(JSON.stringify(arguments_)),
+        (...data) => hash.delete(JSON.stringify(data)),
         hash,
     ];
 }
 /** Retry async function */
-export async function retry(function_, retries = 5, interval = 0, ignore) {
+export async function retry(run, retries = 5, interval = 0, ignore) {
     try {
-        return await function_();
+        return await run();
     }
     catch (error) {
         if (retries === 0 || ignore?.(error))
@@ -89,46 +90,46 @@ export async function retry(function_, retries = 5, interval = 0, ignore) {
         await wait(typeof interval === 'number'
             ? interval
             : interval[interval.length - retries]);
-        return retry(function_, retries - 1, interval);
+        return retry(run, retries - 1, interval);
     }
 }
 /** Create debounced function. Basically adds cooldown to function. Warning: throws! */
-export function createDebouncedFunction(function_, time) {
+export function createDebouncedFunction(run, time) {
     let nextExec = 0;
-    return (...arguments_) => {
+    return (...data) => {
         const now = Date.now();
         if (nextExec > now)
-            throw new Error('Debounced');
+            throw new DelayedError();
         nextExec = now + time;
-        return function_(...arguments_);
+        return run(...data);
     };
 }
 /** Create throttled function. Basically limits function calls in time period. Warning: throws! */
-export function createThrottledFunction(function_, calls, time) {
+export function createThrottledFunction(run, calls, time) {
     let nextClear = 0;
     let amount = 0;
-    return (...arguments_) => {
+    return (...data) => {
         const now = Date.now();
         if (nextClear <= now) {
             nextClear = now + time;
             amount = 0;
         }
         if (amount === calls)
-            throw new Error('Throttled');
+            throw new DelayedError();
         amount++;
-        return function_(...arguments_);
+        return run(...data);
     };
 }
 /** Create debounced function. Basically create function that will be called with delay,
- * but if another call comes in, we reset the timer. */
-export function createDelayedFunction(function_, time) {
+ * but if another call comes in, we reset the timer (previous function isn't called). */
+export function createDelayedFunction(run, time) {
     let timeout;
     let activePromise;
-    return (...arguments_) => {
+    return (...data) => {
         activePromise ??= new ImmediatePromise();
         clearTimeout(timeout);
         timeout = setTimeout(() => {
-            activePromise?.resolve(function_(...arguments_));
+            activePromise?.resolve(run(...data));
             activePromise = undefined;
         }, time);
         return activePromise;
@@ -169,37 +170,19 @@ export default async function deepPromiseAll(input) {
 export function wait(time) {
     return new Promise((r) => setTimeout(r, time));
 }
+/** Reject after specified time */
+export function timeout(time) {
+    return new Promise((_, reject) => setTimeout(() => {
+        reject(new TimeoutError());
+    }, time));
+}
 /** Empty function that does nothing */
 // eslint-disable-next-line @typescript-eslint/no-empty-function
 export function noop() { }
 /** Run array of async tasks concurrently */
 export async function concurrentRun(tasks, concurrency = 4) {
-    return new Promise((resolve, reject) => {
-        const results = new Array(tasks.length);
-        let inProgress = 0;
-        let index = 0;
-        let completed = 0;
-        function runNext() {
-            if (completed === tasks.length) {
-                resolve(results);
-                return;
-            }
-            while (inProgress < concurrency && index < tasks.length) {
-                const currentIndex = index++;
-                const task = tasks[currentIndex];
-                inProgress++;
-                task()
-                    .then((result) => {
-                    results[currentIndex] = result;
-                    inProgress--;
-                    completed++;
-                    runNext();
-                })
-                    .catch(reject);
-            }
-        }
-        runNext();
-    });
+    const semaphore = new Semaphore(concurrency);
+    return Promise.all(tasks.map(semaphore.run.bind(semaphore)));
 }
 /** Create simple event source. Consider using `signal()` for reactive state managment. */
 export class SimpleEventSource {
@@ -239,3 +222,69 @@ export class SimpleEventSource {
         };
     }
 }
+/**
+ * Semaphore is used to limit concurrent tasks by delaying promise.
+ *
+ * ```ts
+ * const semaphore = new Semaphore(2);
+ *
+ * async function task() {
+ *   await semaphore.acquire();
+ *   try {
+ *     // This code can only be executed by two tasks at the same time
+ *   } finally {
+ *     semaphore.release();
+ *   }
+ * }
+ * task();
+ * task();
+ * task(); // This task will wait until one of the previous tasks releases the semaphore.
+ *
+ * // === SHORTHAND ===
+ * semaphore.run(()=>{
+ *    // Your code
+ * })
+ * semaphore.run(()=>{
+ *    // Your code
+ * })
+ * // ...
+ * ```
+ */
+export class Semaphore {
+    capacity;
+    /** Tasks running. */
+    running = 0;
+    deferredTasks = [];
+    constructor(
+    /** The maximum number of concurrent operations allowed.*/
+    capacity) {
+        this.capacity = capacity;
+    }
+    /** Acquires a semaphore, blocking if necessary until one is available. */
+    async acquire() {
+        if (this.running === this.capacity)
+            return new Promise((resolve) => {
+                this.deferredTasks.push(resolve);
+            });
+        this.running++;
+    }
+    /** Releases a semaphore, allowing one more operation to proceed. */
+    release() {
+        this.running--;
+        this.deferredTasks.shift()?.();
+    }
+    /** Shorthand for running functions */
+    async run(run) {
+        await this.acquire();
+        try {
+            return await run();
+        }
+        finally {
+            this.release();
+        }
+    }
+}
+/** Add timeout to a promise */
+export async function withTimeout(run, ms) {
+    return Promise.race([run(), timeout(ms)]);
+}

package/dist/errors.d.ts

@@ -7,6 +7,17 @@
 export declare class ValidationError extends Error {
     name: string;
 }
+/**
+ *  Use as intended error. Basically 4** errors in HTTP
+ */
+export declare class TimeoutError extends Error {
+    name: string;
+    constructor();
+}
+export declare class DelayedError extends Error {
+    name: string;
+    constructor();
+}
 /**
  * Find error inside anything recursively.
  * Good for finding human-readable errors.

package/dist/errors.js

@@ -8,6 +8,21 @@ import { getPropertyNames } from './objects';
 export class ValidationError extends Error {
     name = 'ValidationError';
 }
+/**
+ *  Use as intended error. Basically 4** errors in HTTP
+ */
+export class TimeoutError extends Error {
+    name = 'TimeoutError';
+    constructor() {
+        super('The operation has timed out');
+    }
+}
+export class DelayedError extends Error {
+    name = 'DelayedError';
+    constructor() {
+        super('The operation is delayed and can not be executed now');
+    }
+}
 const defaultPriorityErrorKeys = [
     'message',
     'messages',

package/dist/numbers.d.ts

@@ -8,3 +8,21 @@ export declare function parseFloat(parameter: unknown): number;
 export declare function factorial(n: number): number;
 /** Fibonacci */
 export declare function fib(n: number): bigint;
+/** Clamp numbers to max and min */
+export declare function clamp(value: number, min?: number, max?: number): number;
+/** Is number in range. Inclusive. */
+export declare function inRange(value: number, min?: number, max?: number): boolean;
+/** Calucalate avarage from array of numbers */
+export declare function mean(array: number[]): number;
+/**
+ * Round with precision.
+ *
+ * ```ts
+ * round(1.2345); // 1
+ * round(1.2345, 2); // 1.23
+ * round(1.2345, 10); // 1.2345
+ * ```
+ */
+export declare function round(value: number, precision?: number): number;
+/** Sum of array of numbers */
+export declare function sum(array: number[]): number;

package/dist/numbers.js

@@ -4,8 +4,8 @@
 import { ValidationError } from './errors';
 /** Random number between min and max. May enable float */
 export function random(min, max, float) {
-    const number_ = Math.random() * (max - min) + min;
-    return float ? number_ : Math.round(number_);
+    const number = Math.random() * (max - min) + min;
+    return float ? number : Math.round(number);
 }
 /** Same as Number.parseInt but throws if NaN or not safe */
 export function parseInt(parameter, radix) {
@@ -44,3 +44,42 @@ export function fib(n) {
     }
     return a;
 }
+/** Clamp numbers to max and min */
+export function clamp(value, min = -Infinity, max = Infinity) {
+    if (value > max)
+        return max;
+    if (value < min)
+        return min;
+    return value;
+}
+/** Is number in range. Inclusive. */
+export function inRange(value, min = -Infinity, max = Infinity) {
+    return value <= max && value >= min;
+}
+/** Calucalate avarage from array of numbers */
+export function mean(array) {
+    let sum = 0;
+    for (let index = 0; index < array.length; index++)
+        sum += array[index];
+    return sum / array.length;
+}
+/**
+ * Round with precision.
+ *
+ * ```ts
+ * round(1.2345); // 1
+ * round(1.2345, 2); // 1.23
+ * round(1.2345, 10); // 1.2345
+ * ```
+ */
+export function round(value, precision = 0) {
+    const mult = 10 ** precision;
+    return Math.round(value * mult) / mult;
+}
+/** Sum of array of numbers */
+export function sum(array) {
+    let result = 0;
+    for (let index = 0; index < array.length; index++)
+        result += array[index];
+    return result;
+}

package/dist/objects.d.ts

@@ -1,15 +1,15 @@
 /**
  * [object Object]
  */
-import { Constructor, ObjectAddPrefix } from './types';
+import { AnyFunction, Constructor, ObjectAddPrefix } from './types';
 /** Get all prorerty names, including in prototype */
 export declare function getPropertyNames(object: object, keys?: Set<unknown>): Set<unknown>;
 /** Map function like for arrays, but for objects */
-export declare function objectMap<T extends object>(object: T, function_: (key: keyof T, value: T[keyof T]) => [string, unknown]): {
+export declare function objectMap<T extends object>(object: T, run: (key: keyof T, value: T[keyof T]) => [string, unknown]): {
     [k: string]: unknown;
 };
 /** Filter function like for arrays, but for objects */
-export declare function objectFilter<T extends object>(object: T, function_: (key: keyof T, value: T[keyof T]) => unknown): {
+export declare function objectFilter<T extends object>(object: T, run: (key: keyof T, value: T[keyof T]) => unknown): {
     [k: string]: any;
 };
 /** Adds prefix to every key in object */
@@ -45,12 +45,36 @@ export declare function pick<T extends object, K extends keyof T>(object: T, key
  * ```
  */
 export declare class Base {
+    /** Id of last AUTOMATICALLY created object id */
     static lastId: number;
+    /** Map of class instances by they ids */
     static idMap: Map<number, Base>;
+    /** Map of subclasses of base class by their name */
     static subclasses: Map<string, Constructor<Base>>;
+    /** Functions in this array will be run on instance destroy */
+    runOnDestroy: AnyFunction[];
     private _id;
     get id(): number;
     set id(value: number);
     constructor(id?: number);
+    /**
+     * Include next lines when extending this class:
+     * ```js
+     * static {
+     *   this.registerSubclass()
+     * }
+     * ```
+     */
     static registerSubclass(): void;
+    /**
+     * Destroy instance. Will run all `runOnDestroy` functions
+     * and remove istance from idMap.
+     * If class is garbage collected automatically runs this.
+     * */
+    destroy(): void;
+    /**
+     * Register autocleared event handler.
+     * If using classes methods don't forget to `bind(this)`
+     */
+    protected registerEvent(target: EventTarget, type: string, listener: EventListener, options?: AddEventListenerOptions): void;
 }

package/dist/objects.js

@@ -12,12 +12,12 @@ export function getPropertyNames(object, keys = new Set()) {
     return keys;
 }
 /** Map function like for arrays, but for objects */
-export function objectMap(object, function_) {
-    return Object.fromEntries(Object.entries(object).map(([key, value]) => function_(key, value)));
+export function objectMap(object, run) {
+    return Object.fromEntries(Object.entries(object).map(([key, value]) => run(key, value)));
 }
 /** Filter function like for arrays, but for objects */
-export function objectFilter(object, function_) {
-    return Object.fromEntries(Object.entries(object).filter(([key, value]) => function_(key, value)));
+export function objectFilter(object, run) {
+    return Object.fromEntries(Object.entries(object).filter(([key, value]) => run(key, value)));
 }
 /** Adds prefix to every key in object */
 export function addPrefixToObject(object, prefix) {
@@ -118,9 +118,14 @@ export function pick(object, keys) {
  * ```
  */
 export class Base {
+    /** Id of last AUTOMATICALLY created object id */
     static lastId = 0;
+    /** Map of class instances by they ids */
     static idMap = new Map();
+    /** Map of subclasses of base class by their name */
     static subclasses = new Map();
+    /** Functions in this array will be run on instance destroy */
+    runOnDestroy = [];
     _id;
     get id() {
         return this._id;
@@ -134,7 +139,36 @@ export class Base {
         this._id = id;
         Base.idMap.set(id, this);
     }
+    /**
+     * Include next lines when extending this class:
+     * ```js
+     * static {
+     *   this.registerSubclass()
+     * }
+     * ```
+     */
     static registerSubclass() {
         Base.subclasses.set(this.name, this);
     }
+    /**
+     * Destroy instance. Will run all `runOnDestroy` functions
+     * and remove istance from idMap.
+     * If class is garbage collected automatically runs this.
+     * */
+    destroy() {
+        Base.idMap.delete(this._id);
+        for (let index = 0; index < this.runOnDestroy.length; index++)
+            this.runOnDestroy[index]();
+    }
+    /**
+     * Register autocleared event handler.
+     * If using classes methods don't forget to `bind(this)`
+     */
+    registerEvent(target, type, listener, options = {}) {
+        options.passive ??= true;
+        target.addEventListener(type, listener, options);
+        this.runOnDestroy.push(() => {
+            target.removeEventListener(type, listener);
+        });
+    }
 }

package/dist/signals.d.ts

@@ -31,7 +31,7 @@ export declare function signal<T>(value: T): Signal<T>;
  * Returned data from handler function will be passed to it on next signal change.
  * Returns a function that will clear the effect.
  *
- * ```ts
+ *
  * // Will print signal on change
  * effect(()=>{
  *   console.log($mySignal())
@@ -42,7 +42,6 @@ export declare function signal<T>(value: T): Signal<T>;
  *   if(last>mySignal) console.log('Increment!')
  *   return mySignal;
  * })
- * ```
  */
 export declare function effect<T>(handler: (argument: T | undefined) => T, initialValue?: T): () => void;
 /**

package/dist/signals.js

@@ -7,9 +7,9 @@ const effectsMap = new WeakMap();
 let batchedEffects;
 export function signal(value) {
     const subscribers = new Set();
-    return (...arguments_) => {
-        if (arguments_.length === 1) {
-            const argument = arguments_[0];
+    return (...data) => {
+        if (data.length === 1) {
+            const argument = data[0];
             value =
                 typeof argument === 'function'
                     ? argument(value)
@@ -47,7 +47,7 @@ function clearEffect(handler) {
  * Returned data from handler function will be passed to it on next signal change.
  * Returns a function that will clear the effect.
  *
- * ```ts
+ *
  * // Will print signal on change
  * effect(()=>{
  *   console.log($mySignal())
@@ -58,7 +58,6 @@ function clearEffect(handler) {
  *   if(last>mySignal) console.log('Increment!')
  *   return mySignal;
  * })
- * ```
  */
 export function effect(handler, initialValue) {
     let lastValue = initialValue;

package/dist/time.d.ts

@@ -3,7 +3,7 @@
  */
 import { AnyFunction } from './types';
 /** Measure performance of a function */
-export declare function measurePerformance(function_: () => unknown, timeCheck?: number): number;
+export declare function measurePerformance(run: () => unknown, timeCheck?: number): number;
 /**
  * Original setTimeout and setIntval known for accumulating delay
  * and causing problem with timeouts bigger than 32bit integer.
@@ -21,7 +21,7 @@ export declare function setSafeInterval(handler: AnyFunction, delay: number): ()
 /** Like setInterval but with cron.
  *  Returns clear function.
  *  For cron string syntax check __getNextCron()__ description */
-export declare function cronInterval(function_: () => unknown, cronString: string): () => void;
+export declare function cronInterval(run: () => unknown, cronString: string): () => void;
 /** Find next cron date after passed date.
  *
  *  This function __DOES NOT__ implement regular CRON 1 to 1.

package/dist/time.js

@@ -4,11 +4,11 @@
 import { HOUR_MS } from './consts';
 import { ValidationError } from './errors';
 /** Measure performance of a function */
-export function measurePerformance(function_, timeCheck = 16.6) {
+export function measurePerformance(run, timeCheck = 16.6) {
     const endTime = performance.now() + timeCheck;
     let executions = 0;
     while (performance.now() < endTime) {
-        function_();
+        run();
         executions++;
     }
     return executions;
@@ -61,7 +61,7 @@ export function setSafeInterval(handler, delay) {
 /** Like setInterval but with cron.
  *  Returns clear function.
  *  For cron string syntax check __getNextCron()__ description */
-export function cronInterval(function_, cronString) {
+export function cronInterval(run, cronString) {
     let timeout;
     let next = getNextCron(cronString).getTime();
     const r = () => {
@@ -70,7 +70,7 @@ export function cronInterval(function_, cronString) {
         if (d < 1) {
             next = getNextCron(cronString).getTime();
             d = next - now;
-            function_();
+            run();
         }
         timeout = setTimeout(r, Math.min(d, HOUR_MS));
     };

package/dist/types.d.ts

@@ -4,7 +4,7 @@
 /** Values that are copied by value, not by reference */
 export type Primitive = string | number | bigint | boolean | symbol | null | undefined;
 /** Function with any arguments or return type */
-export type AnyFunction = (...arguments_: any[]) => any;
+export type AnyFunction = (...data: any[]) => any;
 /** Values that convert to false */
 export type Falsy = false | '' | 0 | null | undefined;
 /** Make keys in object optional */
@@ -41,19 +41,16 @@ export type ObjectSnakeToCamel<T> = {
 export type Concat<T, U> = T extends any[] ? U extends any[] ? [...T, ...U] : never : T & U;
 /**
  * Visual only overhaul. Shows final type result on hover.
+ *
  * ```ts
  * type a = {a: '1'}
  * type b = Prettify<a & { b: 'b' }>
- * ```
- * On hovering b it will show
- * ```ts
+ * // On hovering b it will show
  * type b = {
  *   a: "1";
  *   b: "b";
  * }
- * ```
- * instead of
- * ```ts
+ * // instead of
  * type b = a & {
  *   b: "b";
  * }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softsky/utils",
-  "version": "2.5.5",
+  "version": "2.6.0",
   "description": "JavaScript/TypeScript utilities",
   "main": "dist/index.js",
   "scripts": {
@@ -20,8 +20,8 @@
   },
   "homepage": "https://github.com/SoundOfTheSky/utils#readme",
   "devDependencies": {
-    "@softsky/configs": "^1.3.3",
-    "@types/bun": "^1.2.16"
+    "@softsky/configs": "^1.3.4",
+    "@types/bun": "^1.2.19"
   },
   "files": ["dist/**/*"]
 }