@powfix/core-js 0.14.5 → 0.15.0-beta-2

package/dist/{src → client}/utils/CoordinateUtils.d.ts

@@ -1,4 +1,4 @@
-import { Coordinate } from "../interfaces/Coordinate";
+import { Coordinate } from "../interfaces/Coordinate.js";
 export declare class CoordinateUtils {
     static isValidLatitude(latitude: Coordinate['latitude'] | string): boolean;
     static isValidLongitude(longitude: Coordinate['longitude'] | string): boolean;

package/dist/client/utils/CoordinateUtils.js

@@ -0,0 +1,38 @@
+export class CoordinateUtils {
+    static isValidLatitude(latitude) {
+        return /^-?([0-8]?[0-9]|90)(\.[0-9]{1,15})$/.test(latitude.toString());
+    }
+    static isValidLongitude(longitude) {
+        return /^-?([0-9]{1,2}|1[0-7][0-9]|180)(\.[0-9]{1,14})$/.test(longitude.toString());
+    }
+    static isValidLatitudeLongitude(latitude, longitude) {
+        return CoordinateUtils.isValidLatitude(latitude) && CoordinateUtils.isValidLongitude(longitude);
+    }
+    static isValidCoordinate(coordinate) {
+        return this.isValidLatitudeLongitude(coordinate.latitude, coordinate.longitude);
+    }
+    static crowDistance(...coordinates) {
+        if (coordinates.length <= 2) {
+            const toRad = (value) => value * Math.PI / 180;
+            const c1 = coordinates[0];
+            const c2 = coordinates[1];
+            if (!c1 || !c2) {
+                return 0;
+            }
+            const R = 6371e3;
+            const dLat = toRad(c2.latitude - c1.latitude);
+            const dLon = toRad(c2.longitude - c1.longitude);
+            const lat1 = toRad(c1.latitude);
+            const lat2 = toRad(c2.latitude);
+            const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+                Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
+            const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+            return R * c;
+        }
+        let totalDistance = 0;
+        for (let i = 0; i < coordinates.length - 1; ++i) {
+            totalDistance += this.crowDistance(coordinates[i], coordinates[i + 1]);
+        }
+        return totalDistance;
+    }
+}

package/dist/{src → client}/utils/DateUtils.d.ts

@@ -1,5 +1,5 @@
 import { MomentInput, RelativeTimeSpec } from "moment";
-import { DATE } from "../constants/DATE";
+import { DATE } from "../constants/DATE.js";
 export declare class DateUtils {
     static isPositiveInteger(value: unknown, strict?: boolean): boolean;
     static isMilliseconds(value: unknown, strict?: boolean): boolean;

package/dist/client/utils/DateUtils.js

@@ -0,0 +1,303 @@
+import moment from "moment";
+import { DATE } from "../constants/DATE.js";
+export class DateUtils {
+    static isPositiveInteger(value, strict) {
+        if (strict) {
+            if (typeof value !== 'number') {
+                return false;
+            }
+        }
+        if (typeof value === 'bigint') {
+            return value >= 0 && value <= Number.MAX_SAFE_INTEGER;
+        }
+        if (typeof value === 'number') {
+            if (!Number.isSafeInteger(value)) {
+                return false;
+            }
+            return value >= 0 && value <= Number.MAX_SAFE_INTEGER;
+        }
+        if (typeof value === 'string') {
+            if (!/^(0|[1-9]\d*)$/g.test(value)) {
+                return false;
+            }
+            return DateUtils.isPositiveInteger(Number(value), strict);
+        }
+        return false;
+    }
+    static isMilliseconds(value, strict) {
+        return DateUtils.isPositiveInteger(value, strict);
+    }
+    static isSeconds(value, strict) {
+        return DateUtils.isPositiveInteger(value, strict);
+    }
+    static isUnix(value, strict) {
+        return DateUtils.isSeconds(value, strict);
+    }
+    static isISO8601(value) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        if (!/(Z)|(\+\d{2}:\d{2})$/g.test(value)) {
+            return false;
+        }
+        return !Number.isNaN((new Date(value)).getTime());
+    }
+    static isValid(value, format, strict) {
+        var _a;
+        if (format === undefined) {
+            return DateUtils.isSeconds(value, strict) || DateUtils.isMilliseconds(value, strict) || DateUtils.isISO8601(value);
+        }
+        else {
+            switch (format) {
+                case DATE.FORMAT.UNIX: return DateUtils.isUnix(value, strict);
+                case DATE.FORMAT.SECONDS: return DateUtils.isSeconds(value, strict);
+                case DATE.FORMAT.MILLISECONDS: return DateUtils.isMilliseconds(value, strict);
+                case DATE.FORMAT.ISO_8601: return DateUtils.isISO8601(value);
+                default: {
+                    throw new Error(`unknown format: ${format}(${(_a = DATE.FORMAT.toString(format)) !== null && _a !== void 0 ? _a : 'unknown'})`);
+                }
+            }
+        }
+    }
+    static from(value, format, strict) {
+        var _a;
+        if (value instanceof Date) {
+            return value;
+        }
+        if (!DateUtils.isValid(value, format, strict)) {
+            throw new Error('invalid date');
+        }
+        if (format === undefined) {
+            if (DateUtils.isMilliseconds(value, strict)) {
+                return DateUtils.from(value, DATE.FORMAT.MILLISECONDS);
+            }
+            if (DateUtils.isISO8601(value)) {
+                return DateUtils.from(value, DATE.FORMAT.ISO_8601);
+            }
+            throw new Error(`no option to convert value to date`);
+        }
+        switch (format) {
+            case DATE.FORMAT.UNIX: return new Date(Number(value) * 1000);
+            case DATE.FORMAT.SECONDS: return new Date(Number(value) * 1000);
+            case DATE.FORMAT.MILLISECONDS: return new Date(Number(value));
+            case DATE.FORMAT.ISO_8601: return new Date(value);
+            default: {
+                throw new Error(`unknown format: ${format}(${(_a = DATE.FORMAT.toString(format)) !== null && _a !== void 0 ? _a : 'unknown'})`);
+            }
+        }
+    }
+    static fromUnix(value, strict) {
+        return DateUtils.from(value, DATE.FORMAT.UNIX, strict);
+    }
+    static fromSeconds(value, strict) {
+        return DateUtils.from(value, DATE.FORMAT.SECONDS, strict);
+    }
+    static fromMilliseconds(value, strict) {
+        return DateUtils.from(value, DATE.FORMAT.MILLISECONDS, strict);
+    }
+    static fromISO8601(value) {
+        return DateUtils.from(value, DATE.FORMAT.ISO_8601);
+    }
+}
+DateUtils.relativeDate = (input, base = Date.now()) => {
+    // Create new moment instance to apply new locale
+    const datetime = moment.isMoment(input) ? moment(input.toDate()) : moment(input);
+    if (!datetime.isValid()) {
+        console.error('core-js:DateUtils.relativeDate() datetime is invalid', datetime);
+        return '<INVALID DATE>';
+    }
+    return datetime.from(base);
+};
+DateUtils.setLocale = (language) => {
+    const relativeTime = DateUtils.getRelativeTimeSpec(language);
+    if (relativeTime !== undefined) {
+        moment.updateLocale(language, { relativeTime });
+    }
+    moment.locale(language);
+};
+DateUtils.getRelativeTimeSpec = (locale) => {
+    if (locale in DateUtils.relativeTimeSpecs) {
+        return DateUtils.relativeTimeSpecs[locale];
+    }
+    return undefined;
+};
+(function (DateUtils) {
+    DateUtils.relativeTimeSpecs = {
+        ko: {
+            future: "%s 후",
+            past: "%s 전",
+            s: number => `${number}초`,
+            ss: number => `${number}초`,
+            m: number => `${number}분`,
+            mm: number => `${number}분`,
+            h: number => `${number}시간`,
+            hh: number => `${number}시간`,
+            d: number => `${number}일`,
+            dd: number => `${number}일`,
+            M: number => `${number}개월`,
+            MM: number => `${number}개월`,
+            y: number => `${number}년`,
+            yy: number => `${number}년`
+        },
+        en: {
+            future: "in %s",
+            past: "%s ago",
+            s: number => number === 1 ? `${number} second` : `${number} seconds`,
+            ss: number => `${number} seconds`,
+            m: number => number === 1 ? `${number} minute` : `${number} minutes`,
+            mm: number => `${number} minutes`,
+            h: number => number === 1 ? `${number} hour` : `${number} hours`,
+            hh: number => `${number} hours`,
+            d: number => number === 1 ? `${number} day` : `${number} days`,
+            dd: number => `${number} days`,
+            M: number => number === 1 ? `${number} month` : `${number} months`,
+            MM: number => `${number} months`,
+            y: number => number === 1 ? `${number} year` : `${number} years`,
+            yy: number => `${number} years`
+        },
+        ja: {
+            future: "%s後",
+            past: "%s前",
+            s: number => `${number}秒`,
+            ss: number => `${number}秒`,
+            m: number => `${number}分`,
+            mm: number => `${number}分`,
+            h: number => `${number}時`,
+            hh: number => `${number}時`,
+            d: number => `${number}日`,
+            dd: number => `${number}日`,
+            M: number => `${number}月`,
+            MM: number => `${number}月`,
+            y: number => `${number}年`,
+            yy: number => `${number}年`
+        },
+        zh: {
+            future: "%s后",
+            past: "%s前",
+            s: number => `${number}秒`,
+            ss: number => `${number}秒`,
+            m: number => `${number}分钟`,
+            mm: number => `${number}分钟`,
+            h: number => `${number}个小时`,
+            hh: number => `${number}个小时`,
+            d: number => `${number}天`,
+            dd: number => `${number}天`,
+            M: number => `${number}个月`,
+            MM: number => `${number}个月`,
+            y: number => `${number}年`,
+            yy: number => `${number}年`
+        },
+        ru: {
+            future: "через %s",
+            past: "%s назад",
+            s: number => `${number} секунд`,
+            ss: number => `${number} секунд`,
+            m: number => `${number} минута`,
+            mm: number => `${number} минут`,
+            h: number => `${number} час`,
+            hh: number => `${number} часов`,
+            d: number => `${number} день`,
+            dd: number => `${number} дней`,
+            M: number => `${number} месяц`,
+            MM: number => `${number} месяцев`,
+            y: number => `${number} год`,
+            yy: number => `${number} лет`
+        },
+        uz: {
+            future: "%sdan keyin",
+            past: "%s avval",
+            s: number => `${number} soniya`,
+            ss: number => `${number} soniya`,
+            m: number => `${number} daqiqa`,
+            mm: number => `${number} daqiqa`,
+            h: number => `${number} soat`,
+            hh: number => `${number} soat`,
+            d: number => `${number} kun`,
+            dd: number => `${number} kun`,
+            M: number => `${number} oy`,
+            MM: number => `${number} oy`,
+            y: number => `${number} yil`,
+            yy: number => `${number} yil`
+        },
+        de: {
+            future: "in %s",
+            past: "vor %s",
+            s: number => `${number === 1 ? "einer" : number} Sekunde${number === 1 ? "" : "n"}`,
+            ss: number => `${number} Sekunde${number === 1 ? "" : "n"}`,
+            m: number => `${number === 1 ? "einer" : number} Minute${number === 1 ? "" : "n"}`,
+            mm: number => `${number} Minute${number === 1 ? "" : "n"}`,
+            h: number => `${number === 1 ? "einer" : number} Stunde${number === 1 ? "" : "n"}`,
+            hh: number => `${number} Stunde${number === 1 ? "" : "n"}`,
+            d: number => `${number === 1 ? "einem" : number} Tag${number === 1 ? "" : "en"}`,
+            dd: number => `${number} Tag${number === 1 ? "" : "en"}`,
+            M: number => `${number === 1 ? "einem" : number} Monat${number === 1 ? "" : "en"}`,
+            MM: number => `${number} Monat${number === 1 ? "" : "en"}`,
+            y: number => `${number === 1 ? "einem" : number} Jahr${number === 1 ? "" : "en"}`,
+            yy: number => `${number} Jahr${number === 1 ? "" : "en"}`
+        },
+        fr: {
+            future: "dans %s",
+            past: "il y a %s",
+            s: number => `quelques secondes`,
+            ss: number => `${number} secondes`,
+            m: number => `une minute`,
+            mm: number => `${number} minutes`,
+            h: number => `une heure`,
+            hh: number => `${number} heures`,
+            d: number => `un jour`,
+            dd: number => `${number} jours`,
+            M: number => `un mois`,
+            MM: number => `${number} mois`,
+            y: number => `un an`,
+            yy: number => `${number} ans`
+        },
+        vi: {
+            future: "sau %s",
+            past: "%s trước",
+            s: number => `${number} giây`,
+            ss: number => `${number} giây`,
+            m: number => `${number} phút`,
+            mm: number => `${number} phút`,
+            h: number => `${number} giờ`,
+            hh: number => `${number} giờ`,
+            d: number => `${number} ngày`,
+            dd: number => `${number} ngày`,
+            M: number => `${number} tháng`,
+            MM: number => `${number} tháng`,
+            y: number => `${number} năm`,
+            yy: number => `${number} năm`
+        },
+        th: {
+            future: "ใน %s",
+            past: "%s ที่แล้ว",
+            s: number => `${number} วินาที`,
+            ss: number => `${number} วินาที`,
+            m: number => `${number} นาที`,
+            mm: number => `${number} นาที`,
+            h: number => `${number} ชั่วโมง`,
+            hh: number => `${number} ชั่วโมง`,
+            d: number => `${number} วัน`,
+            dd: number => `${number} วัน`,
+            M: number => `${number} เดือน`,
+            MM: number => `${number} เดือน`,
+            y: number => `${number} ปี`,
+            yy: number => `${number} ปี`
+        },
+        fil: {
+            future: "sa loob ng %s",
+            past: "%s ang nakalipas",
+            s: number => `${number} segundo`,
+            ss: number => `${number} segundo`,
+            m: number => `${number} minuto`,
+            mm: number => `${number} minuto`,
+            h: number => `${number} oras`,
+            hh: number => `${number} oras`,
+            d: number => `${number} araw`,
+            dd: number => `${number} araw`,
+            M: number => `${number} buwan`,
+            MM: number => `${number} buwan`,
+            y: number => `${number} taon`,
+            yy: number => `${number} taon`
+        },
+    };
+})(DateUtils || (DateUtils = {}));

package/dist/client/utils/JuminNumberUtils.js

@@ -0,0 +1,46 @@
+import { between } from "./global/between.js";
+export class JuminNumberUtils {
+    static calculateX(juminNumber) {
+        const replacedJuminNumber = juminNumber.replace(/\D/g, '');
+        if (!between(replacedJuminNumber.length, 12, 13)) {
+            throw new Error('Jumin number length must be 12 to 13(without dash)');
+        }
+        const numbers = replacedJuminNumber.split('').map(e => parseInt(e, 10));
+        const sum = 2 * numbers[0] + 3 * numbers[1] + 4 * numbers[2] + 5 * numbers[3]
+            + 6 * numbers[4] + 7 * numbers[5] + 8 * numbers[6] + 9 * numbers[7]
+            + 2 * numbers[8] + 3 * numbers[9] + 4 * numbers[10] + 5 * numbers[11];
+        return (11 - (sum % 11)) % 10;
+    }
+    static isValid(juminNumber) {
+        const replacedJuminNumber = juminNumber.replace(/\D/g, '');
+        if (replacedJuminNumber.length !== 13) {
+            return false;
+        }
+        // 연도에 해당하는 숫자와 성별에 해당하는 숫자 비교
+        const TODAY_YEAR = parseInt(new Date().getFullYear().toString().slice(-2), 10);
+        const yearNum = parseInt(replacedJuminNumber.slice(0, 2), 10);
+        const sexNum = replacedJuminNumber.slice(6, 7); // 대시 있는경우 7로 변경
+        if (sexNum === '1' || sexNum === '2') {
+            if (yearNum < TODAY_YEAR)
+                return false;
+        }
+        else if (sexNum === '3' || sexNum === '4') {
+            if (yearNum > TODAY_YEAR)
+                return false;
+        }
+        else
+            return false;
+        // 월과 일에 해당하는 숫자 조건 검사 (정규식으로)
+        const regex = /^\d{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1])\d{7}$/;
+        if (!regex.test(replacedJuminNumber))
+            return false;
+        // Validation X
+        const currentX = parseInt(replacedJuminNumber.slice(-1), 10);
+        const calculatedX = JuminNumberUtils.calculateX(replacedJuminNumber);
+        if (currentX !== calculatedX) {
+            console.log('Invalid X', currentX, calculatedX);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/client/utils/NumberUtils.js

@@ -0,0 +1,21 @@
+export class NumberUtils {
+    static formatWithThousandsSeparator(value, separator = ',') {
+        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+    }
+    static formatBigNumber(value, precision = 2) {
+        const map = [
+            { suffix: 'Qi', threshold: 1e18 },
+            { suffix: 'Q', threshold: 1e15 },
+            { suffix: 'T', threshold: 1e12 },
+            { suffix: 'B', threshold: 1e9 },
+            { suffix: 'M', threshold: 1e6 },
+            { suffix: 'K', threshold: 1e3 },
+            { suffix: '', threshold: 1 },
+        ];
+        const found = map.find(e => Math.abs(value) >= e.threshold);
+        if (found) {
+            return Number((value / found.threshold).toFixed(precision)) + found.suffix;
+        }
+        return value.toString();
+    }
+}

package/dist/client/utils/ObjectIdUtils.js

@@ -0,0 +1,20 @@
+import { UuidUtils } from "./UuidUtils.js";
+export class ObjectIdUtils {
+    static toUuid(objectId, pad = 'start') {
+        const result = Buffer.alloc(16);
+        Buffer.from(objectId, 'hex').copy(result, pad === 'start' ? 4 : 0);
+        return UuidUtils.toString(result);
+    }
+    static fromUuid(uuid, pad) {
+        const buffer = UuidUtils.toBuffer(uuid);
+        const isPadEnd = buffer.subarray(buffer.length - 4).every(byte => byte === 0);
+        if (isPadEnd || pad === 'end') {
+            return buffer.subarray(0, buffer.length - 4).toString('hex');
+        }
+        const isPadStart = buffer.subarray(0, 4).every(byte => byte === 0);
+        if (!isPadStart) {
+            console.warn('buffer is not pad start and pad end');
+        }
+        return buffer.subarray(4).toString('hex');
+    }
+}

package/dist/{src → client}/utils/Point3Utils.d.ts

@@ -1,4 +1,4 @@
-import { Point3 } from "../interfaces/Point3";
+import { Point3 } from "../interfaces/Point3.js";
 export declare class Point3Utils {
     static distance(p1: Point3, p2: Point3): number;
 }

package/dist/client/utils/Point3Utils.js

@@ -0,0 +1,8 @@
+export class Point3Utils {
+    static distance(p1, p2) {
+        const dx = p1.x - p2.x;
+        const dy = p1.y - p2.y;
+        const dz = p1.z - p2.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+}

package/dist/client/utils/RandomUtils.js

@@ -0,0 +1,60 @@
+export class RandomUtils {
+    static randomNumber(min, max) {
+        min = Math.ceil(min);
+        max = Math.floor(max);
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+    static randomLatinStrings(length) {
+        const strings = [];
+        for (let i = 0; i < length; ++i) {
+            const isLowerCase = RandomUtils.randomNumber(0, 1);
+            if (isLowerCase) {
+                strings.push(String.fromCharCode(RandomUtils.randomNumber(97, 122)));
+            }
+            else {
+                strings.push(String.fromCharCode(RandomUtils.randomNumber(65, 90)));
+            }
+        }
+        return strings.join('');
+    }
+    static randomLatinLowercaseStrings(length) {
+        const strings = [];
+        for (let i = 0; i < length; ++i) {
+            strings.push(String.fromCharCode(RandomUtils.randomNumber(97, 122)));
+        }
+        return strings.join('');
+    }
+    static randomLatinUppercaseStrings(length) {
+        const strings = [];
+        for (let i = 0; i < length; ++i) {
+            strings.push(String.fromCharCode(RandomUtils.randomNumber(65, 90)));
+        }
+        return strings.join('');
+    }
+    static randomNumberStrings(length) {
+        const strings = [];
+        for (let i = 0; i < length; ++i) {
+            strings.push(String.fromCharCode(RandomUtils.randomNumber(48, 57)));
+        }
+        return strings.join('');
+    }
+    static randomStrings(length) {
+        const strings = [];
+        for (let i = 0; i < length; ++i) {
+            const isNumber = RandomUtils.randomNumber(0, 1);
+            if (isNumber) {
+                strings.push(String.fromCharCode(RandomUtils.randomNumber(48, 57)));
+            }
+            else {
+                const isLowerCase = RandomUtils.randomNumber(0, 1);
+                if (isLowerCase) {
+                    strings.push(String.fromCharCode(RandomUtils.randomNumber(97, 122)));
+                }
+                else {
+                    strings.push(String.fromCharCode(RandomUtils.randomNumber(65, 90)));
+                }
+            }
+        }
+        return strings.join('');
+    }
+}

package/dist/client/utils/Sequencer.js

@@ -0,0 +1,141 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import moment from "moment/moment.js";
+import EventEmitter3 from 'eventemitter3';
+export var SequencerStatus;
+(function (SequencerStatus) {
+    SequencerStatus[SequencerStatus["IDLE"] = 0] = "IDLE";
+    SequencerStatus[SequencerStatus["RUNNING"] = 1] = "RUNNING";
+    SequencerStatus[SequencerStatus["ERROR"] = 2] = "ERROR";
+    SequencerStatus[SequencerStatus["DONE"] = 3] = "DONE";
+})(SequencerStatus || (SequencerStatus = {}));
+export var SequencerEvent;
+(function (SequencerEvent) {
+    SequencerEvent["START"] = "START";
+    SequencerEvent["END"] = "END";
+    SequencerEvent["SEQUENCE_START"] = "SEQUENCE_START";
+    SequencerEvent["SEQUENCE_END"] = "SEQUENCE_END";
+})(SequencerEvent || (SequencerEvent = {}));
+export class Sequencer {
+    constructor(option) {
+        this.sequences = [];
+        this.status = SequencerStatus.IDLE;
+        this.minimumExecutionTime = 0;
+        // Reset variables task is done
+        this.currentSequence = null;
+        this.startTimestamp = null;
+        this.endTimestamp = null;
+        // Emitter
+        this.eventEmitter = new EventEmitter3();
+        this.pushSequence = (sequence) => {
+            this.sequences.push(sequence);
+        };
+        this.start = () => __awaiter(this, void 0, void 0, function* () {
+            if (this.status === SequencerStatus.RUNNING) {
+                console.warn('Sequencer status is', this.status);
+                return;
+            }
+            this.status = SequencerStatus.RUNNING;
+            this.currentSequence = null;
+            this.startTimestamp = this.getCurrentTimeStamp;
+            this.endTimestamp = null;
+            console.log(`Sequence started, started at ${this.startTimestamp}, MINIMUM_EXECUTION_TIME is ${this.minimumExecutionTime}`);
+            for (let sequence of this.sequences) {
+                console.log('Currently total execution time', this.executionTime);
+                const sequenceStartTimeStamp = this.getCurrentTimeStamp;
+                this.currentSequence = sequence;
+                // Emitter
+                this.eventEmitter.emit(SequencerEvent.SEQUENCE_START, sequence);
+                try {
+                    yield new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        try {
+                            console.log(`Sequence ${sequence.key} start`);
+                            yield ((_a = sequence.task) === null || _a === void 0 ? void 0 : _a.call(sequence));
+                            const sequenceEndTimeStamp = this.getCurrentTimeStamp;
+                            const sequenceExecutionTime = sequenceEndTimeStamp - sequenceStartTimeStamp;
+                            console.log(`✅ Sequence ${sequence.key} done at`, sequenceEndTimeStamp);
+                            console.log('Sequence execution time', sequenceExecutionTime, 'ms');
+                            if (sequence.minimumExecutionTime) {
+                                console.log(`Sequence has minimumExecutionTime`, sequence.minimumExecutionTime, 'ms');
+                                if (sequenceExecutionTime < sequence.minimumExecutionTime) {
+                                    const delay = sequence.minimumExecutionTime - sequenceExecutionTime;
+                                    console.log(`Sequence will delay`, delay, 'ms');
+                                    let dotInterpreterBlocked = false;
+                                    const dotInterpreter = setInterval(() => {
+                                        if (dotInterpreterBlocked) {
+                                            console.log('!');
+                                            return;
+                                        }
+                                        console.log('.');
+                                    }, 100);
+                                    setTimeout(() => {
+                                        dotInterpreterBlocked = true;
+                                        clearInterval(dotInterpreter);
+                                        console.log('done');
+                                        resolve();
+                                    }, delay);
+                                    return;
+                                }
+                                console.log('Sequence execution time is greater than minimum execution time');
+                                resolve();
+                                return;
+                            }
+                            resolve();
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    }));
+                    console.log('Out of Promise');
+                    // Emitter
+                    this.eventEmitter.emit(SequencerEvent.SEQUENCE_END, sequence);
+                }
+                catch (e) {
+                    if (sequence.required) {
+                        console.error(`🚫 Sequence ${sequence.key} failed`, e);
+                        this.status = SequencerStatus.ERROR;
+                        this.currentSequence = null;
+                        this.endTimestamp = this.currentSequence;
+                        // IMPORTANT
+                        return Promise.reject({
+                            sequence,
+                            reason: e,
+                        });
+                    }
+                    console.log(`Sequence ${sequence.key} failed`, e);
+                    // Emitter
+                    this.eventEmitter.emit(SequencerEvent.SEQUENCE_END, sequence);
+                }
+            }
+            this.status = SequencerStatus.DONE;
+            this.currentSequence = null;
+            this.endTimestamp = this.currentSequence;
+        });
+        if (option === null || option === void 0 ? void 0 : option.sequences) {
+            this.sequences.push(...option.sequences);
+        }
+    }
+    get getCurrentTimeStamp() {
+        return parseInt(moment().format('x'), 10);
+    }
+    get executionTime() {
+        if (this.status === SequencerStatus.IDLE) {
+            return null;
+        }
+        if (!this.startTimestamp) {
+            return null;
+        }
+        if (this.startTimestamp && this.endTimestamp) {
+            return this.endTimestamp - this.startTimestamp;
+        }
+        return this.getCurrentTimeStamp - this.startTimestamp;
+    }
+}