dequanto 0.0.1

package/src/utils/$date.ts

@@ -0,0 +1,473 @@
+import * as Formatter from 'atma-formatter';
+
+
+export class DateTool {
+    protected constructor (public date: Date = new Date()) {
+
+    }
+    /**
+     * - DD-MM-YYYYY (HH:mm)?
+     * - DD.MM.YYYYY (HH:mm)?
+     * - ISODate
+     * - Ticks
+     */
+    static with (mix: string | number | Date) {
+        let date: Date;
+        if (typeof mix === 'string' || typeof mix === 'number') {
+            date = $date.parse(mix);
+        } else {
+            date = mix;
+        }
+        return new DateTool(date);
+    }
+    static withNow () {
+        return new DateTool();
+    }
+    clone () {
+        this.date = new Date(this.date);
+        return this;
+    }
+    add (x: string | number) {
+        this.date = $date.additive(this.date, x)
+        return this;
+    }
+    dayStart () {
+        this.date = $date.dayStart(this.date);
+        return this;
+    }
+    dayEnd () {
+        this.date = $date.dayEnd(this.date);
+        return this;
+    }
+    weekStart () {
+        this.date = $date.weekStart(this.date);
+        return this;
+    }
+    weekEnd () {
+        this.date = $date.weekEnd(this.date);
+        return this;
+    }
+    monthStart () {
+        this.date = $date.monthStart(this.date);
+        return this;
+    }
+    monthEnd () {
+        this.date = $date.monthEnd(this.date);
+        return this;
+    }
+
+    daysBetween (b: Date) {
+        return $date.daysBetween(this.date, b);
+    }
+    /** e.g. yyyy-MM-dd HH:mm */
+    format (format: string) {
+        return $date.format(this.date, format);
+    }
+    setMilliseconds (v: number) {
+        this.date.setMilliseconds(v);
+        return this;
+    }
+    setSeconds (v: number) {
+        this.date.setSeconds(v);
+        return this;
+    }
+    setMinutes (v: number) {
+        this.date.setMinutes(v);
+        return this;
+    }
+    setHours (h: number, min?: number, sec?: number, ms?: number) {
+        this.date.setHours(h);
+        if (min != null) this.date.setMinutes(min);
+        if (sec != null) this.date.setSeconds(sec);
+        if (ms != null) this.date.setMilliseconds(ms);
+        return this;
+    }
+    /** Sets the numeric day-of-the-month value of the Date object using local time. */
+    setDate (v: number) {
+        this.date.setDate(v);
+        return this;
+    }
+    setMonth (v: number) {
+        this.date.setMonth(v);
+        return this;
+    }
+    setFullYear (v: number) {
+        this.date.setFullYear(v);
+        return this;
+    }
+
+    nextDay (h?: number, min?: number, s?: number, ms?: number) {
+        this.date = $date.additive(this.date, '1d');
+        if (h != null) {
+            this.date.setHours(h);
+        }
+        if (min != null) {
+            this.date.setMinutes(min);
+        }
+        if (s != null) {
+            this.date.setSeconds(s);
+        }
+        if (ms != null) {
+            this.date.setMilliseconds(ms);
+        }
+        return this;
+    }
+
+    toUnixTimestamp (): number {
+        return $date.toUnixTimestamp(this.date);
+    }
+}
+export namespace $date {
+
+    export function tool (date: Date = new Date()) {
+        return DateTool.with(date);
+    }
+
+    /** e.g. yyyy-MM-dd HH:mm */
+    export function format (date: number | string | Date, format: string) {
+        if (typeof date === 'string' || typeof date === 'number') {
+            date = parse(date);
+        }
+        return Formatter.formatDate(date, format);
+    }
+
+    export function formatTimespan (ms: number) {
+        let str = '';
+        let SECOND = 1000;
+        let MINUTE = 60 * SECOND;
+        let HOUR = 60 * MINUTE;
+        let DAY = 24 * HOUR;
+
+        if (DAY < ms) {
+            let days = Math.floor(ms / DAY);
+            str += `${days}d`;
+            ms -= days * DAY;
+        }
+        if (HOUR < ms) {
+            let hours = Math.floor(ms / HOUR);
+            str += ` ${hours}h`;
+            ms -= hours * HOUR;
+        }
+        if (MINUTE < ms) {
+            let minutes = Math.floor(ms / MINUTE);
+            str += ` ${minutes}min`;
+            ms -= minutes * MINUTE;
+        }
+        if (SECOND < ms) {
+            let seconds = Math.floor(ms / SECOND);
+            str += ` ${seconds}s`;
+            ms -= seconds * SECOND;
+        }
+        if (0 < ms) {
+            str += ` ${ms}ms`;
+        }
+        return str.trim();
+    }
+
+    export function dayStart(date = new Date()) {
+        let result = new Date(date);
+        result.setHours(0, 0, 0, 0);
+        return result;
+    }
+    export function hourStart(date = new Date()) {
+        let result = new Date(date);
+        result.setMinutes(0, 0, 0);
+        return result;
+    }
+    export function dayEnd(date = new Date()) {
+        let result = new Date(date);
+        result.setHours(23, 59, 59, 999);
+        return result;
+    }
+    export function weekStart (date = new Date()) {
+        let result = new Date(date);
+        let day = result.getDay() - 1;
+        if (day === -1) {
+            day = 6;
+        }
+        result.setDate(result.getDate() - day);
+        result.setHours(0, 0, 0, 0);
+        return result;
+    }
+    export function weekEnd (date = new Date()) {
+        let result = new Date(date);
+        let day = result.getDay() - 1;
+        if (day === -1) {
+            day = 6;
+        }
+        result.setDate(result.getDate() + (6 - day));
+        result.setHours(23, 59, 59, 999);
+        return result;
+    }
+    export function monthStart (date = new Date()) {
+        let result = new Date(date);
+        result.setDate(1);
+        result.setHours(0, 0, 0, 0);
+        return result;
+    }
+    export function monthEnd (date = new Date()) {
+        let result = new Date(date);
+        result.setMonth(result.getMonth() + 1);
+        result.setDate(1);
+        result.setHours(0, 0, 0, -1);
+        return result;
+    }
+
+
+    /** date1 + X === date2 */
+    export function daysBetween (a: Date, b: Date, abs: boolean = true) {
+        let aStart = dayStart(a);
+        let bStart = dayStart(b);
+        let diff = bStart.valueOf() - aStart.valueOf();
+        if (abs) diff = Math.abs(diff);
+        return Math.floor(diff / (24 * 60 * 60 * 1000));
+    }
+
+    /** hour1 + X === hour2 */
+    export function hoursBetween (a: Date, b: Date, abs: boolean = true) {
+        let aStart = hourStart(a);
+        let bStart = hourStart(b);
+        let diff = bStart.valueOf() - aStart.valueOf();
+        if (abs) diff = Math.abs(diff);
+        return Math.floor(diff / (60 * 60 * 1000));
+    }
+
+    export function minsBetween (a: Date | string, b: Date | string, abs: boolean = true) {
+        if (typeof a === 'string') {
+            a = parse(a);
+        }
+        if (typeof b === 'string') {
+            b = parse(b);
+        }
+
+        let ms = b.valueOf() - a.valueOf()
+        if (abs) ms = Math.abs(ms);
+        return Math.floor(ms / (60 * 1000));
+    }
+
+    /**
+     * - DD-MM-YYYYY (HH:mm)?
+     * - DD.MM.YYYYY (HH:mm)?
+     * - ISODate
+     * - Ticks
+     */
+    export function parse(mix: Date | number | string, default_?: Date) {
+        if (mix instanceof Date) {
+            return mix;
+        }
+        if (typeof mix === 'number') {
+            return new Date(mix);
+        }
+        if (mix == null || mix === '') {
+            return null;
+        }
+        if (mix.includes('T') || mix.includes('Z')) {
+            return new Date(mix);
+        }
+
+        let format = mix;
+        let H = 0;
+        let Min = 0;
+        let hours = /(\d{2}):(\d{2})/.exec(format);
+        if (hours) {
+            H = Number(hours[1]);
+            Min = Number(hours[2]);
+        }
+        let Y = 0;
+        let M = 1;
+        let D = 1;
+
+        let dateMatch = /(\d{2})[\.\-](\d{2})[\.\-](\d{4})/.exec(format);
+        if (dateMatch) {
+            D = Number(dateMatch[1]);
+            M = Number(dateMatch[2]);
+            Y = Number(dateMatch[3]);
+        } else {
+            dateMatch = /(\d{4})[\.\-](\d{2})[\.\-](\d{2})/.exec(format);
+            if (dateMatch) {
+                Y = Number(dateMatch[1]);
+                M = Number(dateMatch[2]);
+                D = Number(dateMatch[3]);
+            }
+        }
+        if (Y === 0) {
+            if (arguments.length > 1) {
+                return default_;
+            }
+            throw new Error(`Invalid format ${format}`);
+        }
+        return new Date(Y, M - 1, D, H, Min);
+    }
+
+    /**
+     * s|sec|seconds|m|mins?|h|hours?|d|days?|w|weeks?|months?|y|years?
+     * e.g: 2h
+     * @param str
+     * @param opts Default: ms
+     */
+    export function parseTimespan (str: string, opts?: { get?: 'ms' | 's', anchor?: Date }): number {
+
+        let direction = str[0] === '-' ? -1 : +1;
+        if (direction === -1) {
+            str = str.substring(1);
+        }
+
+        let rgx = /^([\d\.]+)(s|sec|seconds|m|mins?|h|hours?|d|days?|w|weeks?|months?|y|years?)$/
+        let match = rgx.exec(str);
+        if (match == null) {
+            throw new Error(`Invalid Humanize seconds. Pattern: ${rgx.toString()}. Got: ${str}`);
+        }
+        let val = parseFloat(match[1]);
+        let unit = match[2];
+        let MS = 1000;
+        if (opts?.get === 's') {
+            MS = 1;
+        }
+        MS *= direction;
+
+        switch (unit) {
+            case 's':
+            case 'sec':
+                return val * MS;
+            case 'm':
+            case 'min':
+            case 'mins':
+                return val * 60 * MS;
+            case 'h':
+            case 'hour':
+            case 'hours':
+                return val * 60 * 60 * MS;
+            case 'd':
+            case 'day':
+            case 'days':
+                return val * 60 * 60 * 24 * MS;
+            case 'w':
+            case 'week':
+            case 'weeks':
+                return val * 60 * 60 * 24 * 7 * MS;
+            case 'month':
+            case 'months':
+                if (opts?.anchor) {
+                    let date = new Date(opts.anchor);
+                    date.setMonth(date.getMonth() + val * direction);
+                    let result = date.valueOf() - opts.anchor.valueOf();
+                    if (opts?.get === 's') {
+                        result = Math.round(result / 1000);
+                    }
+                    return result;
+                }
+                return val * 60 * 60 * 24 * 31 * MS;
+            case 'y':
+            case 'year':
+            case 'years':
+                if (opts?.anchor) {
+                    let date = new Date(opts.anchor);
+                    date.setFullYear(date.getFullYear() + val * direction);
+                    let result = date.valueOf() - opts.anchor.valueOf();
+                    if (opts?.get === 's') {
+                        result = Math.round(result / 1000);
+                    }
+                    return result;
+                }
+                return val * 60 * 60 * 24 * 365 * MS;
+        }
+        throw new Error(`Invalid units ${str}`);
+    }
+
+
+    export function additive (date: Date | number | string, x: string | number) {
+        let d = parse(date);
+        let timestamp = d.getTime();
+        if (typeof x === 'number') {
+            return new Date(timestamp + x);
+        }
+
+        let ms = parseTimespan(x, { anchor: d });
+        let target = new Date(timestamp + ms);
+
+        let offset = d.getTimezoneOffset();
+        var diff = offset - target.getTimezoneOffset();
+        if (diff !== 0) {
+            const h = diff / 60 | 0;
+            target.setHours(target.getHours() - h);
+        }
+        return target;
+    }
+
+    export function equal (a: Date, b: Date, precision: 'year' | 'month' | 'date' | 'hour' | 'minute' | 'second' | 'ms' = 'ms') {
+        let aYear = a.getFullYear();
+        let bYear = b.getFullYear();
+        if (aYear !== bYear) {
+            return false;
+        }
+        if (precision === 'year') {
+            return true;
+        }
+        let aMonth = a.getMonth();
+        let bMonth = b.getMonth();
+        if (aMonth !== bMonth) {
+            return false;
+        }
+        if (precision === 'month') {
+            return true;
+        }
+        let aDate = a.getDate();
+        let bDate = b.getDate();
+        if (aDate !== bDate) {
+            return false;
+        }
+        if (precision === 'date') {
+            return true;
+        }
+        let aHours = a.getHours();
+        let bHours = b.getHours();
+        if (aHours !== bHours) {
+            return false;
+        }
+        if (precision === 'hour') {
+            return true;
+        }
+
+        let aMins = a.getMinutes();
+        let bMins = b.getMinutes();
+        if (aMins !== bMins) {
+            return false;
+        }
+        if (precision === 'minute') {
+            return true;
+        }
+
+        let aSec = a.getSeconds();
+        let bSec = b.getSeconds();
+        if (aSec !== bSec) {
+            return false;
+        }
+        if (precision === 'second') {
+            return true;
+        }
+        let aMs = a.getMilliseconds();
+        let bMs = b.getMilliseconds();
+        if (aMs !== bMs) {
+            return false;
+        }
+        return true;
+    }
+
+    export function isSameDay(a: Date, b: Date) {
+        if (a.getFullYear() !== b.getFullYear()) {
+            return false;
+        }
+        if (a.getMonth() !== b.getMonth()) {
+            return false;
+        }
+        if (a.getDate() !== b.getDate()) {
+            return false;
+        }
+        return true;
+    }
+
+    export function toUnixTimestamp (date: Date): number {
+        return Math.floor(date.getTime() / 1000);
+    }
+}
+

package/src/utils/$fn.ts

@@ -0,0 +1,134 @@
+import { $promise } from './$promise';
+
+export namespace $fn {
+    export function retriable<T extends TRetriableMethod> (fn: T, ctx: any)  {
+        return new Retriable(fn, ctx);
+    }
+
+    export function timeoutPromise<T extends Promise<any>> (promise: T, ms: number): T {
+        let err = new Error(`Promise timeouted in ${ms}ms`)
+
+        return new Promise((resolve, reject) => {
+            let completed = false;
+            let timeout = setTimeout(() => {
+                if (completed) {
+                    return;
+                }
+                completed = true;
+                reject(err);
+            }, ms);
+
+            promise.then(
+                result => {
+                    completed = true;
+                    clearTimeout(timeout);
+                    resolve(result);
+                },
+                err => {
+                    completed = true;
+                    clearTimeout(timeout);
+                    reject(err);
+                }
+            );
+        }) as T;
+    }
+
+    export function waitForObject<T>(check: () => Promise<[Error, T?]>, opts?: {
+        intervalMs?: number
+        timeoutMs?: number
+        timeoutMessage?: string | (() => string)
+    }): Promise<T>  {
+        let start = Date.now();
+        let completed = false;
+        let intervalMs = opts?.intervalMs ?? 500;
+        let timeoutMs  = opts?.timeoutMs ?? null;
+        let timeoutMessage = opts?.timeoutMessage ?? `Waiting for object timeouted`;
+
+        return new Promise(async (resolve, reject) => {
+            async function tick () {
+                let [ error, result ] = (await check()) ?? [ null, null ];
+                if (result != null) {
+                    completed = true;
+                    resolve(result);
+                    return;
+                }
+                if (error != null) {
+                    completed = true;
+                    reject(error);
+                    return;
+                }
+                if (timeoutMs != null && (Date.now() - start) > timeoutMs) {
+                    completed = true;
+                    let message = typeof timeoutMessage === 'function'
+                        ? timeoutMessage()
+                        : timeoutMessage;
+
+                    reject(new Error(message));
+                    return;
+                }
+            }
+
+            while (true) {
+                try {
+                    await tick ();
+                } finally {}
+                if (completed === true) {
+                    break;
+                }
+                await $promise.wait(intervalMs);
+            }
+        });
+    }
+
+    type TRetriableMethod = (...args) => Promise<any>
+
+    interface IRetriableOptions<T extends TRetriableMethod> {
+        timeout?: number
+        retries?: number
+        onError?: (error, ...args) => Promise<Parameters<T>> | void
+    }
+    class Retriable<T extends TRetriableMethod> {
+
+        private _retries: number = 0;
+        private _options: IRetriableOptions<T> = {
+            timeout: null as number,
+            retries: null as number,
+            onError: null as (error, ...args) => Promise<Parameters<T>>
+        }
+
+        constructor (public fn: T, public ctx) {
+
+        }
+        options (opts: IRetriableOptions<T>): this {
+            this._options = opts;
+            return this;
+        }
+        call(...args: Parameters<T>): ReturnType<T> {
+            return this.tick(...args);
+        }
+
+        private async tick (...args: Parameters<T>) {
+            try {
+                let result = await this.fn.apply(this.ctx, args);
+                return result;
+            } catch (error) {
+                let { timeout, retries = 3, onError } = this._options;
+
+                if (timeout != null) {
+                    await $promise.wait(timeout);
+                }
+                if (++this._retries > retries) {
+                    throw error;
+                }
+                if (onError) {
+                    error.message += ` Will be re-executed ${this._retries}/${retries}`;
+                    let overridenArgs = await onError(error);
+                    if (Array.isArray(overridenArgs)) {
+                        args = overridenArgs;
+                    }
+                }
+                return this.tick(...args);
+            }
+        }
+    }
+}

package/src/utils/$is.ts

@@ -0,0 +1,37 @@
+import { TAddress } from '@dequanto/models/TAddress';
+
+export namespace $is {
+    export function Number <T> (val: T, message: string = 'Invalid.', opts?: { min?: number, max?: number}): T {
+        if (typeof val !== 'number') {
+            throw new Error(`Value is not a number. ${message}`);
+        }
+        if (opts?.min != null && val < opts.min) {
+            throw new Error(`Value ${val} is less than ${opts.min}. ${message}`);
+        }
+        if (opts?.max != null && val > opts.max) {
+            throw new Error(`Value ${val} is greater than ${opts.max}. ${message}`);
+        }
+
+        return val;
+    }
+
+    export function notNull<T> (val: T, message: string): T {
+        if (val == null) {
+            throw new Error(`Value is undefined. ${message}`);
+        }
+        return val;
+    }
+    export function BigInt<T> (val: T, message?: string): bigint {
+        if (typeof val !== 'bigint') {
+            throw new Error(`Value is undefined. ${message}`);
+        }
+        return val as any as bigint;
+    }
+
+    export function Address (val: TAddress, message?: string): boolean {
+        if (typeof val !== 'string') {
+            return false;
+        }
+        return /^0x[a-fA-F0-9]{40}$/g.test(val);
+    }
+}

package/src/utils/$logger.ts

@@ -0,0 +1,10 @@
+import { $date } from './$date';
+
+export namespace $logger {
+    export function log (...args: any) {
+        console.log($date.format(new Date(), 'HH:mm:ss'), ...args);
+    }
+    export function warn (...args: any) {
+        console.warn($date.format(new Date(), 'HH:mm:ss'), ...args);
+    }
+}