@softsky/utils 1.0.0

package/README.md

@@ -0,0 +1,135 @@
+# Sky utils
+**JavaScript/TypeScript utilities**
+
+Basically library, but it's too simple to be on npm.
+
+## arrays
+Everything array related.
+### function randomFromArray
+Returns random element from non-empty array
+### function shuffleArray
+Create new shuffled array
+### function swap
+Swap two elements in array
+### function binarySearch
+Binary search in sorted array.
+Compare function should compare your needed value with value on index passed to it.
+If compare returns 0 it means we found target.
+If compare returns > 0 it means we have to cut out bigger side of array.
+If compare returns < 0 it means we have to cut out smaller side of array.
+### function chunk
+Split array into sub arrays of spicified size
+
+## consts
+Some useful consts. That's it.
+
+## control
+Utils related to code execution flow.
+### const UUID
+Get unique id
+### async function retry
+Retry async function
+### function createDebouncedFunction
+Create debounced function. Basically adds cooldown to function. Warning: throws!
+### function createThrottledFunction
+Create throttled function. Basically limits function calls in time period. Warning: throws!
+### function createDelayedFunction
+Create debounced function. Basically create function that will be called with delay,
+but if another call comes in, we reset the timer.
+### class ImmediatePromise
+Promise that accepts no callback, but exposes `resolve` and `reject` methods
+### const wait
+setTimeout promisify
+### const noop
+Empty function that does nothing
+
+## errors
+Custom errors, finding errors and error handling.
+### class ValidationError
+Use as intended error. Basically 4** errors in HTTP
+### function findErrorText
+Find error inside anything recursively.
+Good for finding human-readable errors.
+Tries priority keys first.
+Parses JSON automatically.
+Returns undefind if nothing found.
+
+## formatting
+Anything related to formatting and logging.
+### function formatTime
+Milliseconds to human readable time. Minimum accuracy, if set to 1000 will stop at seconds
+### const camelToSnakeCase
+thisCase to this_case
+### const snakeToCamelCase
+this_case to thisCase
+### function formatBytes
+Bytes to KB,MB,GB,TB
+### function log
+Format logging
+### class ProgressLoggerTransform
+Can pass streams through to log a progress
+
+## numbers
+Numbers, math, etc.
+### function random
+Random number between min and max. May enable float
+### function parseInt
+Same as parseInt but throws
+### function parseFloat
+Same as parseFloat but throws
+
+## objects
+[object Object]
+### function getPropertyNames
+Get all prorerty names, including in prototype
+### const objectMap
+Map function like for arrays, but for objects
+### const objectFilter
+Filter function like for arrays, but for objects
+### function addPrefixToObject
+Adds prefix to every key in object
+### function deepEquals
+Check if objects are deep equal
+
+**Supports:**
+- All primitives (String, Number, BigNumber, Null, undefined, Symbol)
+- Objects
+- Iterables (Arrays, Map, Sets, Queries, etc.)
+- Dates
+
+**Not supported:**
+- Functions
+- Async iterables
+- Promises
+- etc
+
+Behavior with object above are not defined, but
+it will still check them by reference.
+
+## time
+Timers, CRON, etc.
+### function cronInterval
+Like setInterval but with cron. Returns clear function.
+### function getNextCron
+Find next cron tick after passed date
+
+## types
+Damn, I **love** TypeScript.
+### type Optional
+Make keys in object optional
+### type AwaitedObject
+Recursively resolves promises in objects and arrays
+### type JSONSerializable
+Anything that can be serialized to JSON
+### type ObjectAddPrefix
+Adds prefix to all keys in object
+### type CamelToSnakeCase
+Convert type of thisCase to this_case
+### type ObjectCamelToSnakeCase
+Convert object keys of thisCase to this_case
+### type SnakeToCamel
+Convert type of this-case to thisCase
+### type ObjectSnakeToCamel
+Convert object keys of this-case to thisCase
+### type Concat
+Concat types of array or objects

package/dist/arrays.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Everything array related.
+ */
+/** Returns random element from non-empty array */
+export declare function randomFromArray<T>(array: T[]): T;
+/** Create new shuffled array */
+export declare function shuffleArray<T>(array_: T[]): T[];
+/** Swap two elements in array */
+export declare function swap<T>(array: T[], index: number, index2: number): T[];
+/**
+ * Binary search in sorted array.
+ * Compare function should compare your needed value with value on index passed to it.
+ * If compare returns 0 it means we found target.
+ * If compare returns > 0 it means we have to cut out bigger side of array.
+ * If compare returns < 0 it means we have to cut out smaller side of array.
+ */
+export declare function binarySearch(size: number, compare: (index: number) => number): number;
+/** Split array into sub arrays of spicified size */
+export declare function chunk<T>(array: T[], chunkSize: number): T[][];

package/dist/arrays.js

@@ -0,0 +1,60 @@
+/**
+ * Everything array related.
+ */
+/** Returns random element from non-empty array */
+export function randomFromArray(array) {
+    if (array.length === 0)
+        throw new Error('Can not return random element from empty array');
+    return array[Math.trunc(Math.random() * array.length)];
+}
+/** Create new shuffled array */
+export function shuffleArray(array_) {
+    const array = [...array_];
+    for (let index = 0; index < array.length; index++) {
+        const index2 = Math.trunc(Math.random() * array.length);
+        const buf = array[index2];
+        array[index2] = array[index];
+        array[index] = buf;
+    }
+    return array;
+}
+/** Swap two elements in array */
+export function swap(array, index, index2) {
+    const temporary = array[index2];
+    array[index2] = array[index];
+    array[index] = temporary;
+    return array;
+}
+/**
+ * Binary search in sorted array.
+ * Compare function should compare your needed value with value on index passed to it.
+ * If compare returns 0 it means we found target.
+ * If compare returns > 0 it means we have to cut out bigger side of array.
+ * If compare returns < 0 it means we have to cut out smaller side of array.
+ */
+export function binarySearch(size, compare) {
+    let low = 0;
+    let high = size - 1;
+    let position = -1;
+    while (low <= high) {
+        const mid = Math.trunc((low + high) / 2);
+        const compared = compare(mid);
+        if (compared === 0) {
+            position = mid;
+            break;
+        }
+        else if (compared > 0)
+            high = mid - 1;
+        else
+            low = mid + 1;
+    }
+    return position;
+}
+/** Split array into sub arrays of spicified size */
+export function chunk(array, chunkSize) {
+    const copy = [...array];
+    const result = [];
+    while (copy.length > 0)
+        result.push(copy.splice(0, chunkSize));
+    return result;
+}

package/dist/consts.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Some useful consts. That's it.
+ */
+export declare const DAY_MS = 86400000;
+export declare const HOUR_MS = 3600000;
+export declare const MIN_MS = 60000;
+export declare const SEC_MS = 1000;

package/dist/consts.js

@@ -0,0 +1,7 @@
+/**
+ * Some useful consts. That's it.
+ */
+export const DAY_MS = 86_400_000;
+export const HOUR_MS = 3_600_000;
+export const MIN_MS = 60_000;
+export const SEC_MS = 1000;

package/dist/control.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Utils related to code execution flow.
+ */
+import { AwaitedObject, JSONSerializable } from './types';
+/** Get unique id */
+export declare const UUID: () => number;
+/**
+ * Creates cached function. All arguments/results are cached.
+ * Returns [
+ *  fn [cached function],
+ *  delete [delete cached result for arguments]
+ *  hash
+ * ]
+ */
+export declare function createCashedFunction<T, V extends JSONSerializable[]>(function_: (...arguments_: V) => T): readonly [(...arguments_: V) => T, (...arguments_: V) => boolean, Map<string, T>];
+/**
+ * Creates cached function. All arguments/results are cached. Will store in cache resolved data.
+ * Returns [
+ *  fn [cached function],
+ *  delete [delete cached result for arguments]
+ *  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>];
+/** Retry async function */
+export declare function retry<T>(function_: () => Promise<T>, retries?: number, interval?: number | number[]): 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;
+/** 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;
+/** 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>;
+/** Promise that accepts no callback, but exposes `resolve` and `reject` methods */
+export declare class ImmediatePromise<T> extends Promise<T> {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+    constructor();
+}
+/** Recursively resolves promises in objects and arrays */
+export default function deepPromiseAll<T>(input: T): Promise<AwaitedObject<T>>;
+/** setTimeout promisify */
+export declare const wait: (time: number) => Promise<unknown>;
+/** Empty function that does nothing */
+export declare const noop: () => void;

package/dist/control.js

@@ -0,0 +1,144 @@
+/**
+ * Utils related to code execution flow.
+ */
+let _uuid = Date.now() * 1000;
+/** Get unique id */
+export const UUID = () => _uuid++;
+/**
+ * Creates cached function. All arguments/results are cached.
+ * Returns [
+ *  fn [cached function],
+ *  delete [delete cached result for arguments]
+ *  hash
+ * ]
+ */
+export function createCashedFunction(function_) {
+    const hash = new Map();
+    return [
+        (...arguments_) => {
+            const key = JSON.stringify(arguments_);
+            const value = hash.get(key);
+            if (value)
+                return value;
+            const newValue = function_(...arguments_);
+            hash.set(key, newValue);
+            return newValue;
+        },
+        (...arguments_) => hash.delete(JSON.stringify(arguments_)),
+        hash,
+    ];
+}
+/**
+ * Creates cached function. All arguments/results are cached. Will store in cache resolved data.
+ * Returns [
+ *  fn [cached function],
+ *  delete [delete cached result for arguments]
+ *  hash
+ * ]
+ */
+export function createCashedAsyncFunction(function_) {
+    const hash = new Map();
+    return [
+        async (...arguments_) => {
+            const key = JSON.stringify(arguments_);
+            const value = hash.get(key);
+            if (value)
+                return value;
+            const newValue = await function_(...arguments_);
+            hash.set(key, newValue);
+            return newValue;
+        },
+        (...arguments_) => hash.delete(JSON.stringify(arguments_)),
+        hash,
+    ];
+}
+/** Retry async function */
+export async function retry(function_, retries = 5, interval = 0) {
+    try {
+        return await function_();
+    }
+    catch (error) {
+        if (retries === 0)
+            throw error;
+        await wait(typeof interval === 'number'
+            ? interval
+            : interval[interval.length - retries]);
+        return retry(function_, retries - 1, interval);
+    }
+}
+/** Create debounced function. Basically adds cooldown to function. Warning: throws! */
+export function createDebouncedFunction(function_, time) {
+    let nextExec = 0;
+    return (...arguments_) => {
+        const now = Date.now();
+        if (nextExec > now)
+            throw new Error('Debounced');
+        nextExec = now + time;
+        return function_(...arguments_);
+    };
+}
+/** Create throttled function. Basically limits function calls in time period. Warning: throws! */
+export function createThrottledFunction(function_, calls, time) {
+    let nextClear = 0;
+    let amount = 0;
+    return (...arguments_) => {
+        const now = Date.now();
+        if (nextClear <= now) {
+            nextClear = now + time;
+            amount = 0;
+        }
+        if (amount === calls)
+            throw new Error('Throttled');
+        amount++;
+        return function_(...arguments_);
+    };
+}
+/** 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) {
+    let timeout;
+    let activePromise;
+    return (...arguments_) => {
+        activePromise ??= new ImmediatePromise();
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            activePromise?.resolve(function_(...arguments_));
+            activePromise = undefined;
+        }, time);
+        return activePromise;
+    };
+}
+/** Promise that accepts no callback, but exposes `resolve` and `reject` methods */
+export class ImmediatePromise extends Promise {
+    resolve;
+    reject;
+    constructor() {
+        let resolve = noop;
+        let reject = noop;
+        super((r, index) => {
+            resolve = r;
+            reject = index;
+        });
+        this.resolve = resolve;
+        this.reject = reject;
+    }
+}
+/** Recursively resolves promises in objects and arrays */
+export default async function deepPromiseAll(input) {
+    if (input instanceof Promise)
+        return deepPromiseAll(await input);
+    if (Array.isArray(input))
+        return Promise.all(input.map(item => deepPromiseAll(item)));
+    if (typeof input === 'object' && input !== null) {
+        return Object.fromEntries(await Promise.all(Object.entries(input).map(async ([key, value]) => [
+            key,
+            await deepPromiseAll(value),
+        ])));
+    }
+    return input;
+}
+/** setTimeout promisify */
+export const wait = (time) => new Promise(r => setTimeout(r, time));
+/** Empty function that does nothing */
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export const noop = () => { };

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Custom errors, finding errors and error handling.
+ */
+/**
+ *  Use as intended error. Basically 4** errors in HTTP
+ */
+export declare class ValidationError extends Error {
+    name: string;
+}
+/**
+ * Find error inside anything recursively.
+ * Good for finding human-readable errors.
+ * Tries priority keys first.
+ * Parses JSON automatically.
+ * Returns undefind if nothing found.
+ */
+export declare function findErrorText(error: unknown, priorityErrorKeys?: string[], stack?: Set<unknown>): string | undefined;

package/dist/errors.js

@@ -0,0 +1,78 @@
+/**
+ * Custom errors, finding errors and error handling.
+ */
+import { getPropertyNames } from './objects';
+/**
+ *  Use as intended error. Basically 4** errors in HTTP
+ */
+export class ValidationError extends Error {
+    name = 'ValidationError';
+}
+const defaultPriorityErrorKeys = [
+    'message',
+    'messages',
+    'msg',
+    'msgs',
+    'text',
+    'txt',
+    'error',
+    'errors',
+    'err',
+    'e',
+];
+/**
+ * Find error inside anything recursively.
+ * Good for finding human-readable errors.
+ * Tries priority keys first.
+ * Parses JSON automatically.
+ * Returns undefind if nothing found.
+ */
+export function findErrorText(error, priorityErrorKeys = defaultPriorityErrorKeys, stack = new Set()) {
+    if (!error || stack.has(error))
+        return;
+    stack.add(error);
+    if (stack.size > 1000)
+        throw new Error('Stack overflow');
+    if (typeof error === 'string')
+        return findErrorTextInString(error, priorityErrorKeys, stack);
+    if (typeof error === 'object') {
+        if (Symbol.iterator in error && !Array.isArray(error))
+            return findErrorTextInObject({ obj: error, iteratorResult: [...error] }, priorityErrorKeys, stack);
+        return findErrorTextInObject(error, priorityErrorKeys, stack);
+    }
+}
+/** Find string that looks like a human-readable error using some simple heuristics */
+function findErrorTextInString(error, priorityErrorKeys = defaultPriorityErrorKeys, stack = new Set()) {
+    try {
+        return findErrorText(JSON.parse(error), priorityErrorKeys, stack);
+    }
+    catch {
+        if (error.length < 4 || error === '[object Object]')
+            return;
+        return error;
+    }
+}
+function findErrorTextInObject(error, priorityErrorKeys = defaultPriorityErrorKeys, stack = new Set()) {
+    const keys = [...getPropertyNames(error)]
+        .map((key) => {
+        let score = priorityErrorKeys.indexOf(key);
+        if (score === -1) {
+            if (!Number.isNaN(key))
+                score = priorityErrorKeys.length;
+            else if (typeof error[key] === 'function') {
+                score = Number.MAX_SAFE_INTEGER - 1;
+            }
+            else {
+                score = Number.MAX_SAFE_INTEGER;
+            }
+        }
+        return [key, score];
+    })
+        .sort(([, v], [, v2]) => v - v2)
+        .map(([k]) => k);
+    for (const key of keys) {
+        const result = findErrorText(error[key], priorityErrorKeys, stack);
+        if (result)
+            return result;
+    }
+}

package/dist/formatting.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Anything related to formatting and logging.
+ */
+/** Milliseconds to human readable time. Minimum accuracy, if set to 1000 will stop at seconds  */
+export declare function formatTime(time: number, min?: number, ranges?: [number, string][]): string;
+/** thisCase to this_case */
+export declare const camelToSnakeCase: (string_: string) => string;
+/** this_case to thisCase */
+export declare const snakeToCamelCase: (string_: string) => string;
+/** Bytes to KB,MB,GB,TB */
+export declare function formatBytes(bytes: number): string;
+/** Format logging */
+export declare function log(...agrs: unknown[]): void;
+/** Can pass streams through to log a progress */
+export declare class ProgressLoggerTransform<T extends {
+    length: number;
+}> extends TransformStream<T> {
+    constructor(string_: string, logInterval: number, maxSize?: number);
+}

package/dist/formatting.js

@@ -0,0 +1,75 @@
+/**
+ * Anything related to formatting and logging.
+ */
+/** Milliseconds to human readable time. Minimum accuracy, if set to 1000 will stop at seconds  */
+export function formatTime(time, min = 0, ranges = [
+    [31_536_000_000, 'y'],
+    [86_400_000, 'd'],
+    [3_600_000, 'h'],
+    [60_000, 'm'],
+    [1000, 's'],
+    [1, 'ms'],
+]) {
+    let output = '';
+    for (const [ms, title] of ranges) {
+        if (min && time < min)
+            break;
+        if (time < ms)
+            continue;
+        const value = Math.trunc(time / ms);
+        if (value !== 0)
+            output += ` ${value}${title}`;
+        time %= ms;
+    }
+    return output;
+}
+/** thisCase to this_case */
+export const camelToSnakeCase = (string_) => string_.replaceAll(/[A-Z]+/g, letter => `_${letter.toLowerCase()}`);
+/** this_case to thisCase */
+export const snakeToCamelCase = (string_) => string_.replaceAll(/_[a-z]/g, letter => letter[1].toUpperCase());
+/** Bytes to KB,MB,GB,TB */
+export function formatBytes(bytes) {
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    if (bytes === 0)
+        return `0B`;
+    const pow = Math.trunc(Math.log(bytes) / Math.log(1024));
+    const maxPow = Math.min(pow, sizes.length - 1);
+    return `${Number.parseFloat((bytes / Math.pow(1024, maxPow)).toFixed(2))}${sizes[maxPow]}`;
+}
+/** Format logging */
+export function log(...agrs) {
+    console.log(new Date().toLocaleString('ru'), ...agrs);
+}
+/** Can pass streams through to log a progress */
+export class ProgressLoggerTransform extends TransformStream {
+    constructor(string_, logInterval, maxSize) {
+        let bytes = 0;
+        const start = Date.now();
+        let lastBytes = 0;
+        super({
+            transform(chunk, controller) {
+                controller.enqueue(chunk);
+                bytes += chunk.length;
+            },
+            flush() {
+                clearInterval(interval);
+                log('Done!');
+            },
+        });
+        const interval = setInterval(() => {
+            let message = string_;
+            const speed = (bytes - lastBytes) / logInterval;
+            message = message
+                .replace('%b', formatBytes(bytes))
+                .replace('%t', formatTime(Date.now() - start, 1000))
+                .replace('%s', formatBytes(speed));
+            if (maxSize)
+                message = message
+                    .replace('%lt', formatTime(Math.trunc((maxSize - bytes) / speed) * 1000))
+                    .replace('%p', Math.trunc((bytes / maxSize) * 100).toString())
+                    .replace('%s', formatBytes(maxSize));
+            log(message);
+            lastBytes = bytes;
+        }, logInterval * 1000);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './arrays';
+export * from './consts';
+export * from './control';
+export * from './errors';
+export * from './formatting';
+export * from './numbers';
+export * from './objects';
+export * from './time';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from './arrays';
+export * from './consts';
+export * from './control';
+export * from './errors';
+export * from './formatting';
+export * from './numbers';
+export * from './objects';
+export * from './time';
+export * from './types';

package/dist/numbers.d.ts

@@ -0,0 +1,6 @@
+/** Random number between min and max. May enable float */
+export declare function random(min: number, max: number, float?: boolean): number;
+/** Same as parseInt but throws */
+export declare function parseInt(parameter: unknown, radix?: number): number;
+/** Same as parseFloat but throws */
+export declare function parseFloat(parameter: unknown): number;

package/dist/numbers.js

@@ -0,0 +1,25 @@
+/**
+ * Numbers, math, etc.
+ */
+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_);
+}
+/** Same as parseInt but throws */
+export function parseInt(parameter, radix) {
+    const n = Number.parseInt(parameter, radix);
+    if (Number.isNaN(n) || !Number.isSafeInteger(n))
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        throw new ValidationError(`Can not parse "${parameter}" to integer`);
+    return n;
+}
+/** Same as parseFloat but throws */
+export function parseFloat(parameter) {
+    const n = Number.parseFloat(parameter);
+    if (Number.isNaN(n) || !Number.isFinite(n))
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        throw new ValidationError(`Can not parse "${parameter}" to float`);
+    return n;
+}

package/dist/objects.d.ts

@@ -0,0 +1,34 @@
+/**
+ * [object Object]
+ */
+import { 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 const objectMap: (object: object, function_: (key: string, value: unknown) => [string, unknown]) => {
+    [k: string]: unknown;
+};
+/** Filter function like for arrays, but for objects */
+export declare const objectFilter: (object: object, function_: (key: string, value: unknown) => unknown) => {
+    [k: string]: any;
+};
+/** Adds prefix to every key in object */
+export declare function addPrefixToObject<T extends Record<string, unknown>, P extends string>(object: Record<string, T>, prefix: P): ObjectAddPrefix<T, P>;
+/** Check if objects are deep equal
+ *
+ * **Supports:**
+ * - All primitives (String, Number, BigNumber, Null, undefined, Symbol)
+ * - Objects
+ * - Iterables (Arrays, Map, Sets, Queries, etc.)
+ * - Dates
+ *
+ * **Not supported:**
+ * - Functions
+ * - Async iterables
+ * - Promises
+ * - etc
+ *
+ * Behavior with object above are not defined, but
+ * it will still check them by reference.
+ */
+export declare function deepEquals(a: unknown, b: unknown, stack?: WeakSet<WeakKey>): boolean;

package/dist/objects.js

@@ -0,0 +1,89 @@
+/**
+ * [object Object]
+ */
+/** Get all prorerty names, including in prototype */
+export function getPropertyNames(object, keys = new Set()) {
+    const own = Object.getOwnPropertyNames(object);
+    for (let index = 0; index < own.length; index++)
+        keys.add(own[index]);
+    const proto = Object.getPrototypeOf(object);
+    if (proto)
+        getPropertyNames(proto, keys);
+    return keys;
+}
+/** Map function like for arrays, but for objects */
+export const objectMap = (object, function_) => Object.fromEntries(Object.entries(object).map(([key, value]) => function_(key, value)));
+/** Filter function like for arrays, but for objects */
+export const objectFilter = (object, function_) => Object.fromEntries(Object.entries(object).filter(([key, value]) => function_(key, value)));
+/** Adds prefix to every key in object */
+export function addPrefixToObject(object, prefix) {
+    const n = {};
+    for (const key in object)
+        n[prefix + key] = object[key];
+    return n;
+}
+/** Check if objects are deep equal
+ *
+ * **Supports:**
+ * - All primitives (String, Number, BigNumber, Null, undefined, Symbol)
+ * - Objects
+ * - Iterables (Arrays, Map, Sets, Queries, etc.)
+ * - Dates
+ *
+ * **Not supported:**
+ * - Functions
+ * - Async iterables
+ * - Promises
+ * - etc
+ *
+ * Behavior with object above are not defined, but
+ * it will still check them by reference.
+ */
+export function deepEquals(a, b, stack = new WeakSet()) {
+    // Primitives
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b
+        || typeof a !== 'object'
+        || typeof b !== 'object'
+        || a === null
+        || b === null)
+        return false;
+    // Assume that already checked objects are equal
+    if (stack.has(a) || stack.has(b))
+        return true;
+    stack.add(a);
+    stack.add(b);
+    // Arrays
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || a.length !== b.length)
+            return false;
+        for (let index = 0; index < a.length; index++)
+            if (!deepEquals(a[index], b[index], stack))
+                return false;
+        return true;
+    }
+    if (Array.isArray(b))
+        return false;
+    // Dates
+    if (a instanceof Date)
+        return b instanceof Date && a.getTime() === b.getTime();
+    if (b instanceof Date)
+        return false;
+    // Iterables
+    if (Symbol.iterator in a)
+        return (Symbol.iterator in b
+            && deepEquals([...a], [...b], stack));
+    if (Symbol.iterator in b)
+        return false;
+    // Other objects
+    const aKeys = getPropertyNames(a);
+    const bKeys = getPropertyNames(b);
+    if (aKeys.size !== bKeys.size)
+        return false;
+    for (const property of getPropertyNames(a))
+        if (!bKeys.has(property)
+            || !deepEquals(a[property], b[property], stack))
+            return false;
+    return true;
+}

package/dist/time.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Timers, CRON, etc.
+ */
+/** Like setInterval but with cron. Returns clear function. */
+export declare function cronInterval(function_: () => unknown, cronString: string): () => void;
+/** Find next cron tick after passed date */
+export declare function getNextCron(cronString: string, datetime?: Date): Date;

package/dist/time.js

@@ -0,0 +1,124 @@
+/**
+ * Timers, CRON, etc.
+ */
+import { HOUR_MS } from './consts';
+import { ValidationError } from './errors';
+/** Like setInterval but with cron. Returns clear function. */
+export function cronInterval(function_, cronString) {
+    let timeout;
+    let next = getNextCron(cronString).getTime();
+    const r = () => {
+        const d = Date.now() - next;
+        if (d < 1) {
+            next = getNextCron(cronString).getTime();
+            function_();
+        }
+        timeout = setTimeout(r, Math.min(d, HOUR_MS));
+    };
+    r();
+    return () => {
+        clearTimeout(timeout);
+    };
+}
+/** Find next cron tick after passed date */
+export function getNextCron(cronString, datetime = new Date()) {
+    const cron = cronString.split(' ');
+    if (cron.length !== 5)
+        throw new ValidationError('Only 5 cron params supported');
+    const dt = new Date(datetime);
+    dt.setSeconds(0, 0);
+    const items = [
+        [
+            parseCronItem(cron[4], 0, 6),
+            dt.getDay.bind(dt),
+            (x) => dt.setDate(dt.getDate()
+                + (dt.getDay() < x ? x - dt.getDay() : 7 - dt.getDay() + x)),
+        ],
+        [
+            parseCronItem(cron[3], 1, 12),
+            () => dt.getMonth() + 1,
+            (x) => dt.setMonth(x - 1),
+        ],
+        [parseCronItem(cron[2], 1, 31), dt.getDate.bind(dt), dt.setDate.bind(dt)],
+        [
+            parseCronItem(cron[1], 0, 23),
+            dt.getHours.bind(dt),
+            dt.setHours.bind(dt),
+        ],
+        [
+            parseCronItem(cron[0], 0, 59),
+            dt.getMinutes.bind(dt),
+            dt.setMinutes.bind(dt),
+        ],
+    ];
+    function r() {
+        for (let index = 0; index < items.length; index++) {
+            const [ok, getN, setN] = items[index];
+            const n = getN();
+            // If OK continue
+            if (ok.includes(n))
+                continue;
+            // If not ok, change every possible lower value lowest ok
+            for (let index2 = index === 0 ? 3 : index + 1; index2 < items.length; index2++) {
+                const [ok, , setN] = items[index2];
+                setN(ok[0]);
+            }
+            const found = ok.find(x => x > n);
+            if (found)
+                setN(found);
+            else {
+                // Set lowest value, increase item before and recheck everything
+                setN(ok[0]);
+                if (index > 1) {
+                    const [, getN, setN] = items[index - 1];
+                    setN(getN() + 1);
+                    r();
+                }
+                break;
+            }
+        }
+    }
+    r();
+    return dt;
+}
+function parseCronItem(cronString, min, max) {
+    const cron = cronString.split(',');
+    const ok = new Set();
+    const error = new ValidationError(`Can't parse CRON string: ${cronString}`);
+    for (const item of cron) {
+        // If everything add every possible value and skip others
+        if (item === '*') {
+            for (let index = min; index <= max; index++)
+                ok.add(index);
+            break;
+        }
+        // If range
+        let split = item.split('-');
+        if (split.length === 2) {
+            const a = Number.parseInt(split[0]);
+            const b = Number.parseInt(split[1]);
+            if (Number.isNaN(a) || Number.isNaN(b) || a < min || a > b || b > max)
+                throw error;
+            for (let index = a; index <= b; index++)
+                ok.add(index);
+            continue;
+        }
+        // If stepped
+        split = item.split('/');
+        if (split.length === 2) {
+            const step = Number.parseInt(split[1]);
+            if (Number.isNaN(step))
+                throw error;
+            const items = parseCronItem(split[0], min, max);
+            for (let index = 0; index < items.length; index += step)
+                ok.add(items[index]);
+            continue;
+        }
+        // If everything else failed check for simple number
+        const n = Number.parseInt(item);
+        if (Number.isNaN(n) || n < min || n > max)
+            throw error;
+        ok.add(n);
+    }
+    return [...ok].sort((a, b) => a - b);
+}

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Damn, I **love** TypeScript.
+ */
+/** Make keys in object optional */
+export type Optional<T, K extends keyof any> = Omit<T, K & keyof T> & Partial<Pick<T, K & keyof T>>;
+/** Recursively resolves promises in objects and arrays */
+export type AwaitedObject<T> = {
+    [K in keyof T]: T[K] extends Promise<infer U> ? U : T[K] extends object ? AwaitedObject<T[K]> : T[K];
+};
+/** Anything that can be serialized to JSON */
+export type JSONSerializable = string | number | boolean | null | undefined | {
+    [key: string]: JSONSerializable;
+} | JSONSerializable[];
+/** Adds prefix to all keys in object */
+export type ObjectAddPrefix<T, P extends string> = {
+    [K in keyof T as `${P}${string & K}`]: T[K];
+};
+/** Convert type of thisCase to this_case */
+export type CamelToSnakeCase<S extends string> = S extends `${infer T}${infer U}` ? U extends Uncapitalize<U> ? `${Lowercase<T>}${CamelToSnakeCase<U>}` : `${Lowercase<T>}_${CamelToSnakeCase<Uncapitalize<U>>}` : S;
+/** Convert object keys of thisCase to this_case */
+export type ObjectCamelToSnakeCase<T> = {
+    [K in keyof T as CamelToSnakeCase<string & K>]: T[K];
+};
+/** Convert type of this-case to thisCase */
+export type SnakeToCamel<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<SnakeToCamel<U>>}` : S;
+/** Convert object keys of this-case to thisCase */
+export type ObjectSnakeToCamel<T> = {
+    [K in keyof T as SnakeToCamel<string & K>]: T[K];
+};
+/** Concat types of array or objects */
+export type Concat<T, U> = T extends any[] ? U extends any[] ? [...T, ...U] : never : T & U;

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Damn, I **love** TypeScript.
+ */
+export {};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@softsky/utils",
+  "version": "1.0.0",
+  "description": "JavaScript/TypeScript utilities",
+  "main": "dist/index.js",
+  "scripts": {
+    "lint": "eslint \"./src/**/*.ts\" --fix && tsc",
+    "gen-readme": "bun ./generate-readme.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SoundOfTheSky/utils.git"
+  },
+  "author": "SoundOfTheSky",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/SoundOfTheSky/utils/issues"
+  },
+  "homepage": "https://github.com/SoundOfTheSky/utils#readme",
+  "devDependencies": {
+    "@softsky/configs": "^1.0.4",
+    "@types/bun": "^1.1.12"
+  },
+  "files": ["dist/**/*"]
+}