@powfix/core-js 0.21.6 → 0.22.0

package/dist/browser/esm/shared/utils/DateUtils.mjs

@@ -1,303 +0,0 @@
-import moment from "moment";
-import { DATE } from "../constants/DATE.mjs";
-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/browser/esm/shared/utils/Enum.mjs

@@ -1,32 +0,0 @@
-export class Enum {
-    static entries(e) {
-        return Object.entries(e).filter(([key, value]) => !/^-?\d+$/g.test(key) && typeof value !== 'function');
-    }
-    static keys(e) {
-        return Enum.entries(e).map(([key,]) => key);
-    }
-    static values(e) {
-        return Enum.entries(e).map(([, value]) => value);
-    }
-    static from(e) {
-        return new Enum(e);
-    }
-    constructor(e) {
-        this._e = e;
-        this._entries = Enum.entries(e);
-        this._keys = Enum.keys(e);
-        this._values = Enum.values(e);
-    }
-    value() {
-        return this._e;
-    }
-    entries() {
-        return this._entries;
-    }
-    keys() {
-        return this._keys;
-    }
-    values() {
-        return this._values;
-    }
-}

package/dist/browser/esm/shared/utils/Enum.types.mjs

@@ -1 +0,0 @@
-export {};

package/dist/browser/esm/shared/utils/I18nUtils.mjs

@@ -1,6 +0,0 @@
-import deepmerge from "deepmerge";
-export class I18nUtils {
-    static mergeResources(...resources) {
-        return resources.reduce((acc, resource) => deepmerge(acc, resource), {});
-    }
-}

package/dist/browser/esm/shared/utils/JuminNumberUtils.mjs

@@ -1,46 +0,0 @@
-import { between } from "./global/between.mjs";
-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/browser/esm/shared/utils/NumberUtils.mjs

@@ -1,21 +0,0 @@
-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/browser/esm/shared/utils/ObjectIdUtils.mjs

@@ -1,26 +0,0 @@
-import { UuidUtils } from "./UuidUtils.mjs";
-import { Uint8ArrayUtils } from "./Uint8ArrayUtils.mjs";
-export class ObjectIdUtils {
-    static toUuid(objectId, pad = 'start') {
-        const src = Uint8ArrayUtils.fromHex(objectId);
-        if (src.length !== 12) {
-            throw new Error(`objectId must be 12 bytes (24 hex), got ${src.length} bytes`);
-        }
-        const result = new Uint8Array(16);
-        const offset = pad === 'start' ? 4 : 0;
-        result.set(src, offset);
-        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/browser/esm/shared/utils/Point3Utils.mjs

@@ -1,8 +0,0 @@
-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/browser/esm/shared/utils/RandomUtils.mjs

@@ -1,60 +0,0 @@
-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/browser/esm/shared/utils/Sequencer.mjs

@@ -1,141 +0,0 @@
-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";
-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;
-    }
-}