@zajno/common 2.3.18 → 2.4.1

package/types/dates/datex.d.ts

@@ -0,0 +1,23 @@
+import { Granularity } from './types';
+export declare namespace DateX {
+    type DateGranularity = Granularity | 'weekDay';
+    function get(d: Date, g: DateGranularity, local: boolean): number;
+    function set(d: Date, g: 'year', local: boolean, year: number, month?: number, date?: number): number;
+    function set(d: Date, g: 'month', local: boolean, month: number, date?: number): number;
+    function set(d: Date, g: 'week', local: boolean, week: number): number;
+    function set(d: Date, g: 'day', local: boolean, date: number): number;
+    function set(d: Date, g: 'weekDay', local: boolean, weekDay: number): number;
+    function set(d: Date, g: 'hour', local: boolean, hours: number, min?: number, sec?: number, ms?: number): number;
+    function set(d: Date, g: 'minute', local: boolean, min: number, sec?: number, ms?: number): number;
+    function set(d: Date, g: 'second', local: boolean, sec: number, ms?: number): number;
+    function set(d: Date, g: 'millisecond', local: boolean, ms: number): number;
+}
+/**
+ * Allows to set day of week, symmetric to Date.getDay()
+ * @param d Date representation
+ * @param dayOfWeek 0..6 Sunday..Saturday
+ * @param future true - only forward or present, false - only backward or present, null - closest
+ * @param local whether to use local time
+ * @returns Date with the same time as d, but with the updated day of week
+ */
+export declare function setDayOfWeek(d: Date | number, dayOfWeek: number, future?: boolean | null, local?: boolean): Date;

package/types/dates/decompose.d.ts

@@ -0,0 +1,4 @@
+import { Granularity } from './types';
+export type DecomposeGranularity = 'week' | 'day' | 'hour' | 'minute' | 'second';
+export declare function decomposeMs<K extends Granularity & DecomposeGranularity>(ms: number, ...grans: K[]): Record<K, number>;
+export declare function decompose(date: number | Date, local: boolean, ...grans: (Granularity & DecomposeGranularity)[]): Partial<Record<DecomposeGranularity, number>>;

package/types/dates/format.d.ts

@@ -0,0 +1,22 @@
+import { YearDate } from './yearDate';
+export declare namespace Format {
+    const DefaultLocale = "en-US";
+    enum Presets {
+        FullDay_ShortDate = "ddd DD.MM.YYYY",
+        ShortDate_FullTime = "DD.MM.YYYY HH:mm:ss"
+    }
+    namespace Presets {
+        function use(p: Presets, d: Date, local?: boolean): string | undefined;
+    }
+    function timespan(ms: Date | number, local?: boolean): string;
+    /** `YYYY-MM-DD` */
+    function toDatePicker(date: Date | number, local?: boolean): string | null;
+    function toLocalDate(date: Date | number): string | null;
+    function yearDate(yd: YearDate, short?: boolean): string;
+    function toDistance(to: Date, from?: Date): string;
+    namespace Ordinal {
+        /** 'en' locale is used. If you need another locale – grab this as example */
+        function createFormatter(): (n: number) => string;
+        function format(num: number): string;
+    }
+}

package/types/dates/index.d.ts

@@ -0,0 +1,10 @@
+export * from './calc';
+export * from './convert';
+export * from './datex';
+export * from './format';
+export * from './parse';
+export * from './period';
+export * from './shift';
+export * from './types';
+export * from './yearDate';
+export * from './decompose';

package/types/dates/parse.d.ts

@@ -0,0 +1,10 @@
+export declare function getTime(d: null | undefined): null;
+export declare function getTime(d: Date | number | string): number;
+export declare function getTime(d: Date | number | string | null | undefined): number | null;
+export declare function getDate(d: null | undefined): null;
+export declare function getDate(d: Date | number | string): Date;
+export declare function getDate(d: Date | number | string | null | undefined): Date | null;
+export declare namespace Parse {
+    /** `YYYY-MM-DD` */
+    function fromDatePicker(str: string, local?: boolean): Date;
+}

package/types/dates/period.d.ts

@@ -0,0 +1,11 @@
+import { Granularity } from './types';
+export type Period = {
+    amount: number;
+    granularity: Granularity;
+};
+export declare namespace Period {
+    function forward(period: Period, base?: Date | number): Date;
+    function backward(period: Period, base?: Date | number): Date;
+    function toMs(period: Period, now?: Date): number;
+    function format(p: Period): string;
+}

package/types/dates/shift.d.ts

@@ -0,0 +1,8 @@
+import { Granularity } from './types';
+export declare function addDays(start: Date, amount: number, condition: (d: Date) => boolean, maxShift?: number): Date;
+export declare function shiftDate(date: Date | number, amount: number, granularity: Granularity, local?: boolean): Date;
+/** @deprecated Use {@link shiftDate} instead */
+export declare const add: typeof shiftDate;
+export declare function startOf(d: Date | number, g: Granularity, local?: boolean): Date;
+export declare function endOf(d: Date | number, g: Granularity, local?: boolean): Date;
+export declare function isSame(d1: Date | number, d2: Date | number, g: Granularity, local?: boolean): boolean;

package/types/dates/types.d.ts

@@ -0,0 +1,9 @@
+export type Granularity = Granularity.Constant | 'month' | 'year';
+export declare namespace Granularity {
+    type Constant = 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week';
+    namespace Constant {
+        function toMs(g: Granularity.Constant): number;
+        function convert(amount: number, g: Granularity.Constant, to: Granularity.Constant): number;
+        function shift(date: Date | number, amount: number, granularity: Granularity.Constant): Date;
+    }
+}

package/types/dates/tz.d.ts

@@ -0,0 +1,7 @@
+/** This is experimental stuff, so no tests provided, see comments in the code */
+export declare namespace Timezones {
+    const Current: string;
+    const CurrentOffset: number;
+    const getOffset: (timeZone: string) => number;
+    function shiftToTimeZone(date: Date, tz: string | number): Date;
+}

package/types/dates/yearDate.d.ts

@@ -0,0 +1,12 @@
+/** Useful for recurring dates like birthday */
+export type YearDate = {
+    day: number | null;
+    month: number | null;
+};
+export declare namespace YearDate {
+    function isValid(yd: YearDate): yd is YearDate;
+    function matches(yearDate: YearDate, date: Date | number, local?: boolean): boolean;
+    function toDate(yd: YearDate, year?: number): Date | null;
+    function fromDate(date: Date | number): YearDate;
+    function equals(yd1: YearDate, yd2: YearDate): boolean;
+}

package/types/fields/filter.d.ts

@@ -0,0 +1,9 @@
+export type FieldFilter<T> = (value: T[keyof T] | undefined) => boolean;
+export declare function filterFields<T>(source: Partial<T>, ...fields: ((keyof T) | {
+    key: keyof T;
+    filter: FieldFilter<T>;
+})[]): Partial<T>;
+export declare namespace filterFields {
+    function Truethy<T>(): FieldFilter<T>;
+    function NotNull<T>(): FieldFilter<T>;
+}

package/types/fields/index.d.ts

@@ -0,0 +1,3 @@
+export * from './filter';
+export * from './update';
+export * from './transfer';

package/types/fields/skip.d.ts

@@ -0,0 +1,16 @@
+export type SkipOptions = 'falsy' | 'null' | boolean;
+export type SkipKey<K extends string> = `${K}Skip`;
+export type SkipKeysOf<T> = {
+    [K in keyof T]: K extends string ? SkipKey<K> : never;
+}[keyof T];
+export type SkipKeysOfMap<T> = Partial<Record<SkipKeysOf<T>, SkipOptions>>;
+export type SkipKeysMapOf<T> = {
+    [K in keyof T]: K extends string ? SkipKey<K> : never;
+};
+export declare namespace SkipOptions {
+    function shouldSkip<T = any>(v: T | null, skip: SkipOptions): boolean;
+}
+export type SkipCondition<T, TKey extends keyof T = keyof T> = SkipOptions | ((key: TKey, val: T[TKey] | null) => boolean);
+export declare namespace SkipCondition {
+    function shouldSkip<T, TKey extends keyof T = keyof T>(condition: SkipCondition<T, TKey>, key: TKey, val: T[TKey] | null): boolean;
+}

package/types/fields/transfer.d.ts

@@ -0,0 +1,14 @@
+export declare function transferFields<T>(source: T, predicate: (f: keyof T, v: T[keyof T]) => boolean, destination: Partial<T>, ...fields: (keyof T)[]): number;
+export declare namespace transferFields {
+    function truthy<T>(source: T, destination: Partial<T>, ...fields: (keyof T)[]): number;
+    function notNull<T>(source: T, destination: Partial<T>, ...fields: (keyof T)[]): number;
+    function defined<T>(source: T, destination: Partial<T>, ...fields: (keyof T)[]): number;
+    function changed<T>(source: T, compare: T, destination: Partial<T>, ...fields: (keyof T)[]): number;
+}
+export declare function hasChangedFields<T>(left: T, right: T, ...fields: (keyof T)[]): boolean;
+type ExtractChangedFieldsResult<T> = {
+    transferred: number;
+    result: Partial<T>;
+};
+export declare function extractChangedFields<T>(source: Partial<T>, image: T, ...fields: (keyof T)[]): ExtractChangedFieldsResult<T>;
+export {};

package/types/fields/update.d.ts

@@ -0,0 +1,27 @@
+import { Comparator } from '../types';
+export declare namespace Fields {
+    type Getter<T> = (obj: Partial<T>) => (T[keyof T] | undefined);
+    type Setter<T> = (obj: Partial<T>, val: T[keyof T] | undefined) => void;
+    type Comparer<T> = (source: Partial<T>, target: Partial<T>) => boolean;
+    type Updater<T> = (target: T, source: T) => T;
+}
+export declare function updateField<T>(target: T, source: Partial<T>, diff: Partial<T>, key: keyof T, hasChanged?: null | Fields.Comparer<T>): boolean;
+export declare function updateFieldExtended<T>(target: T, source: Partial<T>, diff: Partial<T>, get: Fields.Getter<T>, set: Fields.Setter<T>, hasChanged?: null | Fields.Comparer<T>): boolean;
+export type UpdateArrayOptions<T> = {
+    additive?: boolean;
+    unshift?: boolean;
+    clone?: boolean;
+    comparator?: Comparator<T>;
+    updater?: Fields.Updater<T>;
+    sorter?: Comparator<T, number> | null | undefined;
+    hooks?: UpdateArrayHooks<T>;
+};
+export type UpdateArrayHooks<T> = {
+    onAdded?: (item: T, index?: number) => void;
+    onDeleted?: (item: T, index?: number) => void;
+    onUpdated?: (previous: T | null | undefined, next: T, index?: number) => void;
+};
+export declare function updateArray<T>(target: T[] | null, source: T[] | null, options?: UpdateArrayOptions<T>): {
+    changed: number;
+    result: T[] | null;
+};

package/types/functions/assert.d.ts

@@ -0,0 +1,2 @@
+import { Getter } from '../types';
+export declare function assert(condition: boolean, error: Getter<string | Error>, objectToLog?: Getter<any>): asserts condition;

package/types/functions/disposer.d.ts

@@ -0,0 +1,24 @@
+export interface IDisposable {
+    dispose(): void;
+}
+export type ISymbolDisposable = globalThis.Disposable & IDisposable;
+export interface DisposeFunction {
+    (): void;
+}
+export declare class Disposer {
+    private readonly _disposers;
+    private readonly _map;
+    private _loggerName;
+    constructor(loggerName?: string | null);
+    setLoggerName(loggerName: string): this;
+    add(d: DisposeFunction | IDisposable, id?: string): void;
+    execute(id: string): void;
+    dispose(log?: boolean): void;
+}
+export declare function combineDisposers(...items: DisposeFunction[]): DisposeFunction;
+export declare class Disposable implements IDisposable {
+    protected readonly disposer: Disposer;
+    protected _isDisposed: boolean;
+    constructor(loggerName?: string | null);
+    dispose: () => void;
+}

package/types/functions/disposer.symbols.d.ts

@@ -0,0 +1,6 @@
+import type { IDisposable } from './disposer';
+export declare abstract class SymbolDisposable implements globalThis.Disposable, IDisposable {
+    [Symbol.dispose]: () => void;
+    abstract dispose(): void;
+}
+export declare function makeSymbolDisposable<T extends IDisposable>(obj: T): T & SymbolDisposable;

package/types/functions/safe.d.ts

@@ -0,0 +1,5 @@
+import { Nullable } from '../types';
+type LaxPromise<T> = Promise<T> | T | void;
+export declare function catchPromise(promise: LaxPromise<any>, cb?: (err: any) => void): void;
+export declare function wrapAsync<T, TArgs extends any[]>(fn: Nullable<(...args: TArgs) => LaxPromise<T>>, cb?: (err: any) => void): (...args: TArgs) => void;
+export {};

package/types/functions/throttle.d.ts

@@ -0,0 +1,38 @@
+import { ILogger } from '../logger';
+/** Runs a callback after a timeout, ignoring all consecutive calls until the first is processed.  */
+export declare class ThrottleAction<T = any> {
+    timeout: number;
+    private _timeoutRef;
+    private _postponedCb;
+    private _locked;
+    private _logger;
+    /**
+     * In case previous action has started processing but not finished yet, and the following one is going to start,
+     * this flag allows to run the second in parallel.
+      */
+    private _allowParallelRuns;
+    private _currentRun;
+    constructor(timeout?: number);
+    useParallelRuns(): this;
+    useLogger(logger: ILogger | string | null): this;
+    clear(): void;
+    tryRun(cb: () => T | Promise<T>, restartTimeout?: boolean): Promise<T | undefined>;
+    forceRun: () => Promise<T | undefined>;
+    getPromise(): Promise<T | undefined>;
+}
+type ProcessorResult<T> = {
+    result: T | undefined;
+    index: number;
+};
+export declare class ThrottleProcessor<TSubject, TResult = any> {
+    private readonly process;
+    private readonly _queue;
+    private readonly _action;
+    private _promise;
+    constructor(process: (objs: TSubject[]) => Promise<TResult>, timeout?: number);
+    useLogger(logger: ILogger | string | null): this;
+    push(data: TSubject): Promise<ProcessorResult<TResult>>;
+    private _process;
+    clear(): void;
+}
+export {};

package/types/lazy/light.d.ts

@@ -0,0 +1,2 @@
+import type { ILazy } from './types';
+export declare function createLazy<T>(factory: () => T): ILazy<T>;

package/types/lazy/promise.d.ts

@@ -0,0 +1,23 @@
+import type { IExpireTracker } from '../structures/expire';
+import type { ILazyPromise } from './types';
+export declare class LazyPromise<T> implements ILazyPromise<T> {
+    private readonly _factory;
+    private readonly initial;
+    private _instance;
+    private _busy;
+    private _promise;
+    private _expireTracker;
+    constructor(_factory: () => Promise<T>, initial?: T | undefined);
+    get busy(): boolean | null;
+    get hasValue(): boolean;
+    get promise(): Promise<T>;
+    get value(): NonNullable<T>;
+    /** does not calls factory */
+    get currentValue(): T | undefined;
+    withExpire: (tracker: IExpireTracker | undefined) => this;
+    protected ensureInstanceLoading(): void;
+    protected onResolved(res: T): T;
+    setInstance: (res: T | undefined) => T | undefined;
+    reset: () => void;
+    dispose: () => void;
+}

package/types/lazy/singleton.d.ts

@@ -0,0 +1,21 @@
+import type { IExpireTracker } from '../structures/expire';
+import type { ILazy } from './types';
+export declare class Lazy<T> implements ILazy<T> {
+    protected readonly _factory: (() => T);
+    protected _instance: T | undefined;
+    private _expireTracker;
+    private _disposer?;
+    constructor(_factory: (() => T));
+    get hasValue(): boolean;
+    get value(): NonNullable<T>;
+    get currentValue(): T | undefined;
+    /** Override me: additional way to make sure instance is valid */
+    protected get isValid(): boolean;
+    withDisposer: (disposer: (prev: T) => void) => this;
+    withExpire: (tracker: IExpireTracker | undefined) => this;
+    private ensureInstance;
+    prewarm(): this;
+    setInstance(instance: T | undefined): void;
+    reset(): void;
+    dispose(): void;
+}

package/types/lazy/types.d.ts

@@ -0,0 +1,12 @@
+import { IDisposable } from '../functions/disposer';
+import { IResetableModel } from '../models/types';
+export type ILazy<T> = IDisposable & IResetableModel & {
+    readonly value: T;
+    readonly hasValue: boolean;
+    /** should not call the factory or change the value either way */
+    readonly currentValue: T | undefined;
+};
+export type ILazyPromise<T> = ILazy<T> & {
+    readonly busy: boolean | null;
+    readonly promise: Promise<T>;
+};

package/types/logger/abstractions.d.ts

@@ -0,0 +1,10 @@
+export type LoggerFunction = (...args: any[]) => void;
+export interface ILogger {
+    log: LoggerFunction;
+    warn: LoggerFunction;
+    error: LoggerFunction;
+}
+export interface ILoggerSwitchable {
+    enable(): void;
+    disable(): void;
+}

package/types/logger/batch.d.ts

@@ -0,0 +1,2 @@
+import { ILogger } from './abstractions';
+export declare function batchLoggers(...loggers: ILogger[]): ILogger;

package/types/logger/console.d.ts

@@ -0,0 +1,18 @@
+import { ILogger } from './abstractions';
+import { NamedLogger } from './named';
+export declare const CONSOLE: ILogger;
+export declare class ConsoleLogger extends NamedLogger {
+    protected get implementation(): ILogger;
+}
+export declare class BufferedConsoleLogger implements ILogger {
+    private readonly _name;
+    private readonly _logs;
+    private _level;
+    private _log;
+    constructor(name: string);
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    flush(): void;
+    private _raiseLevel;
+}

package/types/logger/file.d.ts

@@ -0,0 +1,15 @@
+import { ILogger } from './abstractions';
+export declare class FileLoggerNode implements ILogger {
+    readonly extraLogger: ILogger;
+    readonly instantFlush: boolean;
+    private readonly _buffer;
+    private _logFilePath;
+    constructor(extraLogger?: ILogger, instantFlush?: boolean);
+    setLogFilePath(path: string): this;
+    setLogName(name: string): this;
+    private append;
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    flush(): void;
+}

package/types/logger/index.d.ts

@@ -0,0 +1,13 @@
+import { ILogger, LoggerFunction } from './abstractions';
+import { ConsoleLogger } from './console';
+import { batchLoggers } from './batch';
+import { LoggerModes } from './manager';
+export type { ILogger, LoggerFunction };
+export { NamedLogger } from './named';
+export { ConsoleLogger, batchLoggers };
+export declare function createLogger(name: string | undefined, mode?: undefined | LoggerModes): ILogger;
+export declare function detachLogger(instance: ILogger, terminate?: boolean): boolean;
+export declare function setMode(mode: LoggerModes | null | undefined): void;
+export declare function getMode(): LoggerModes;
+declare const logger: ILogger;
+export default logger;

package/types/logger/manager.d.ts

@@ -0,0 +1,22 @@
+import { Getter } from '../types/getter';
+import { ILogger } from './abstractions';
+import { ProxyLogger } from './proxy';
+export type LoggerTypes = 'console';
+export type LoggerModes = LoggerTypes | false | Getter<ILogger>;
+export declare class LoggersManager {
+    private readonly _managed;
+    private readonly _all;
+    private _mode;
+    get mode(): LoggerModes;
+    /** Creates and attaches an logger instance created from the current mode  */
+    create(name: string | undefined, mode?: undefined | LoggerModes): ILogger;
+    /** Attaches existing instance, optionally adds name prefix to it */
+    attach(instance: ILogger, name?: string): boolean;
+    /** Sets the current mode if changed. All internally created loggers implementation will be overridden with a new implementation according to the new mode.  */
+    setMode(mode: LoggerModes | null | undefined): void;
+    recognize(instance: ILogger): ProxyLogger | null;
+    /** Detaches instance so it won't be affected by setting mode later on, optionally disables it */
+    detach(instance: ILogger, terminate?: boolean): boolean;
+    private _findInstance;
+    private _createImplementation;
+}

package/types/logger/named.d.ts

@@ -0,0 +1,13 @@
+import { ILogger, ILoggerSwitchable, LoggerFunction } from './abstractions';
+export declare const EMPTY_FUNCTION: () => void;
+export declare abstract class NamedLogger implements ILogger, ILoggerSwitchable {
+    log: LoggerFunction;
+    warn: LoggerFunction;
+    error: LoggerFunction;
+    private _name;
+    get name(): string | null;
+    protected abstract get implementation(): ILogger;
+    constructor(name?: string);
+    enable(overrideName?: string | null): this;
+    disable(): this;
+}

package/types/logger/proxy.d.ts

@@ -0,0 +1,9 @@
+import { ILogger } from './abstractions';
+import { NamedLogger } from './named';
+export declare const EMPTY_LOGGER: ILogger;
+export declare class ProxyLogger extends NamedLogger {
+    protected get implementation(): ILogger;
+    private _logger;
+    constructor(logger: ILogger | undefined | null, name?: string | undefined);
+    setLogger(logger: ILogger | undefined | null): void;
+}

package/types/math/arrays.d.ts

@@ -0,0 +1,44 @@
+import { Comparator, Getter, Nullable, Predicate } from '../types';
+/** type-safe `Array.isArray` wrapper  */
+export declare function isArray<T>(value: any): value is T[];
+export declare function arrayCompareG<T>(arr: ReadonlyArray<T> | null | undefined, cond: (current: T, previous: T | null) => boolean): T | null;
+export declare function arrayCompare(arr: ReadonlyArray<number> | null | undefined, absolute: boolean, cond: (i: number, t: number) => boolean): number | null;
+export declare function arrayMax(arr: ReadonlyArray<number>, absolute?: boolean): number | null;
+export declare function arrayMin(arr: ReadonlyArray<number>, absolute?: boolean): number | null;
+export declare function arrayAverage(arr: ReadonlyArray<number> | null | undefined, absolute?: boolean): number;
+export declare function arrayCount<T>(arr: ReadonlyArray<T> | null | undefined, condition: (o: T) => boolean): number;
+type KeyOf<T> = {
+    [K in keyof T]: T[K] extends string | number ? K : never;
+}[(string & keyof T)];
+/** @returns count of items in array per key, filtered off by predicate */
+export declare function arrayCountByKey<T, TKey extends KeyOf<T>>(arr: ReadonlyArray<T>, key: TKey, predicate?: Predicate<T>): Record<string | number, number>;
+export declare function arrayFirstResult<T, V>(arr: ReadonlyArray<T> | null | undefined, mapper: (o: T) => V | null | false): V | null | false;
+export declare function arraysCompare<T>(base: ReadonlyArray<T> | null | undefined, target: readonly T[], comparator?: Comparator<T>): {
+    missing: T[];
+    extra: T[];
+    diff: number;
+} | null;
+export declare function arraysCompareDistinct<T>(base: ReadonlyArray<T> | null | undefined, target: ReadonlyArray<T> | null | undefined): {
+    missing: T[];
+    extra: T[];
+    diff: number;
+} | null;
+export declare function arrayDistinct<T>(arr: ReadonlyArray<T> | null | undefined): T[];
+export declare function normalize(arr: number[]): number[];
+export declare function randomArrayItem<T>(arr: ReadonlyArray<T>): T | null;
+export declare function arraySwap<T>(arr: T[], i1: number, i2: number): void;
+export declare function shuffle<T>(arr: null | undefined, slice: any): T[];
+export declare function shuffle<T>(arr: T[], slice: false): T[];
+export declare function shuffle<T>(arr: Nullable<ReadonlyArray<T>>): T[];
+export declare function shuffle<T>(arr: Nullable<ReadonlyArray<T>>, slice: true): T[];
+export declare function groupBy<T, K extends string | number>(arr: ReadonlyArray<T>, grouper: (item: T) => K): Partial<Record<K, T[]>>;
+export declare function groupOneBy<T, K extends string | number>(arr: ReadonlyArray<T>, grouper: (item: T) => K): Partial<Record<K, T>>;
+export declare function arraySplit<T>(arr: ReadonlyArray<T>, predicate: (t: T) => boolean): [T[], T[]];
+export declare function findIndexLeast(num: number, arr: number[], sort?: boolean): number;
+export declare function findLastIndex<T>(arr: Nullable<ReadonlyArray<T>>, predicate: Predicate<T>): number;
+export declare function findLast<T>(arr: Nullable<ReadonlyArray<T>>, predicate: Predicate<T>): T | null;
+type NonFunction<T> = T extends Function ? never : T;
+export declare function removeItem<T>(array: T[], item: NonFunction<T> | Predicate<T>): T | null;
+export declare function arrayRepeat<T>(factory: Getter<T>, count?: number): T[];
+export declare function chunkify<T>(array: T[], size: number): T[][];
+export {};

package/types/math/calc.d.ts

@@ -0,0 +1,17 @@
+export declare function clamp(val: number, min?: number | undefined | null, max?: number | undefined | null, cycle?: boolean): number;
+export declare function clamp01(val: number): number;
+export declare function contains(val: number, from: number, to: number): boolean;
+export declare function getIntersection(start1: number, end1: number, start2: number, end2: number): false | {
+    ranges: number[][];
+    intersection: {
+        start: number;
+        end: number;
+    };
+};
+export declare function isIntersected(start1: number, end1: number, start2: number, end2: number): boolean;
+export type RoundMode = 'floor' | 'ceil' | 'round' | 'trunc';
+export declare function roundByMode(val: number, mode: RoundMode): number;
+export declare function roundNumber(val: number, signs?: number, mode?: RoundMode): number;
+export declare function roundHalf(num: number): number;
+export declare function random(min?: number, max?: number, round?: boolean | RoundMode): number;
+export declare function badRandomString(length?: number): string;

package/types/math/distribution.d.ts

@@ -0,0 +1,5 @@
+export type Distribution<T extends keyof any> = {
+    total: number;
+    byType: Partial<Record<T, number>> | null;
+};
+export declare function extendDistribution<T extends keyof any>(count: number, type: T, current?: Distribution<T>): Distribution<T>;

package/types/math/index.d.ts

@@ -0,0 +1,5 @@
+export * from './calc';
+export * from './arrays';
+export * from './distribution';
+export declare function getNumberSuffix(num: number): "st" | "nd" | "rd" | "th";
+export declare function format(n: number, digits?: number): string;

package/types/math/object/helpers.d.ts

@@ -0,0 +1,7 @@
+import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep';
+import { BasePair, IObjectOps, NumKey } from './types';
+export declare function _getValue<T extends object, TKey extends NumKey<T> = NumKey<T>>(o: DeepReadonlyPartial<T>, key: TKey): T[TKey] | null;
+export declare function _getInnerValue<T extends object, TKey extends string & keyof T>(o: DeepReadonly<T>, key: TKey): DeepReadonly<T[TKey]>;
+export declare function _getInnerValue<T extends object, TKey extends string & keyof T>(o: DeepReadonly<T> | number, key: TKey): DeepReadonly<T[TKey]> | number;
+/** this helpers hides some cumbersome type transformations */
+export declare function doOps<T extends object, TOps extends IObjectOps<any>>(this: void, ops: BasePair<T, string & keyof T, TOps>[], o: DeepReadonly<T>, processor?: (ops: TOps, value: DeepReadonly<T[string & keyof T]>, key: string & keyof T) => T[keyof T] | null): T;

package/types/math/object/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export { ObjectOps } from './ops';
+export { ObjectMath } from './math';
+export { CompositeObjectOps } from './ops.composite';
+export { CompositeObjectMath } from './math.composite';

package/types/math/object/math.composite.d.ts

@@ -0,0 +1,16 @@
+import { AnyObject } from '../../types';
+import { DeepReadonly } from '../../types/deep';
+import { CompositeObjectOps } from './ops.composite';
+import { AbsOptions, IObjectMath, MathPairsMap, RoundOptions } from './types';
+export declare class CompositeObjectMath<T extends AnyObject> extends CompositeObjectOps<T> implements IObjectMath<T> {
+    private readonly _math;
+    constructor(innerMath: MathPairsMap<T>);
+    contains(base: DeepReadonly<T>, target: DeepReadonly<T>): boolean;
+    inverse(o: DeepReadonly<T>): T;
+    abs(o: DeepReadonly<T>, options?: AbsOptions): T | null;
+    round(o: DeepReadonly<T>, options?: RoundOptions): T;
+    add(o1: DeepReadonly<T>, o2: DeepReadonly<T>): T;
+    subtract(base: DeepReadonly<T>, amount: number | DeepReadonly<T>): T;
+    multiply(o1: DeepReadonly<T>, o2: number | DeepReadonly<T>): T;
+    div(o1: DeepReadonly<T>, o2: number | DeepReadonly<T>): number;
+}

package/types/math/object/math.d.ts

@@ -0,0 +1,17 @@
+import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep';
+import { ObjectOps } from './ops';
+import { AbsOptions, DELETE_TYPE, IObjectMath, NumKey, RoundOptions } from './types';
+export declare class ObjectMath<T extends object> extends ObjectOps<T> implements IObjectMath<T> {
+    getTotal(o: DeepReadonlyPartial<T>): number;
+    contains(base: DeepReadonly<T>, target: DeepReadonly<T>): boolean;
+    inverse(o: DeepReadonly<T>): T;
+    div(o1: DeepReadonly<T>, o2: number): T;
+    div(o1: DeepReadonly<T>, o2: DeepReadonly<T>): number;
+    process(o: DeepReadonly<T>, processor: (val: number, key: NumKey<T>) => number | DELETE_TYPE): T | null;
+    abs(c: DeepReadonly<T>, stripNegatives?: AbsOptions): T | null;
+    round(c: DeepReadonly<T>, method?: RoundOptions): T | null;
+    calc(c1: DeepReadonly<T>, c2: DeepReadonly<T> | number, operator: (n: number, n2: number) => number): T;
+    add(c1: DeepReadonly<T>, c2: DeepReadonly<T> | number): T;
+    subtract(base: DeepReadonly<T>, amount: DeepReadonly<T> | number): T;
+    multiply(c1: DeepReadonly<T>, c2: DeepReadonly<T> | number): T;
+}

package/types/math/object/ops.composite.d.ts

@@ -0,0 +1,14 @@
+import { AnyObject } from '../../types';
+import { DeepReadonly } from '../../types/deep';
+import { IObjectOps, OpsPairsMap } from './types';
+export declare class CompositeObjectOps<T extends AnyObject> implements IObjectOps<T> {
+    readonly Empty: Readonly<T>;
+    private readonly _ops;
+    constructor(innerOps: OpsPairsMap<T>);
+    isEmpty(o: DeepReadonly<T>): boolean;
+    getEmpty(): T;
+    clone(o: DeepReadonly<T>): T;
+    isValid(o: DeepReadonly<T>): boolean;
+    isEquals(a: DeepReadonly<T>, b: DeepReadonly<T>): boolean;
+    assign(to: T, other: DeepReadonly<T>): void;
+}