chz-telegram-bot 0.0.1

package/dist/entities/actions/commandAction.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const storage_1 = __importDefault(require("../../services/storage"));
+const transactionResult_1 = __importDefault(require("../transactionResult"));
+const moment_1 = __importDefault(require("moment"));
+const logger_1 = __importDefault(require("../../services/logger"));
+const toArray_1 = __importDefault(require("../../helpers/toArray"));
+const commandTriggerCheckResult_1 = __importDefault(require("../commandTriggerCheckResult"));
+const timeConvertions_1 = require("../../helpers/timeConvertions");
+class CommandAction {
+    constructor(trigger, handler, name, active, cooldown, chatsBlacklist, allowedUsers, condition, stateConstructor) {
+        this.triggers = (0, toArray_1.default)(trigger);
+        this.handler = handler;
+        this.name = name;
+        this.cooldownInSeconds = cooldown;
+        this.active = active;
+        this.chatsBlacklist = chatsBlacklist;
+        this.allowedUsers = allowedUsers;
+        this.condition = condition;
+        this.stateConstructor = stateConstructor;
+        this.key = `command:${this.name.replace('.', '-')}`;
+    }
+    async exec(ctx) {
+        if (!this.active || this.chatsBlacklist.includes(ctx.chatId))
+            return;
+        const isConditionMet = await this.condition(ctx);
+        if (!isConditionMet)
+            return;
+        const state = await storage_1.default.getActionState(this, ctx.chatId);
+        const { shouldTrigger, matchResults, skipCooldown } = this.triggers
+            .map((x) => this.checkTrigger(ctx, x, state))
+            .reduce((acc, curr) => acc.mergeWith(curr), commandTriggerCheckResult_1.default.DoNotTrigger);
+        if (!shouldTrigger)
+            return;
+        logger_1.default.logWithTraceId(ctx.botName, ctx.traceId, ctx.chatName, ` - Executing [${this.name}] in ${ctx.chatId}`);
+        ctx.matchResults = matchResults;
+        await this.handler(ctx, state);
+        if (skipCooldown) {
+            ctx.startCooldown = false;
+        }
+        if (ctx.startCooldown) {
+            state.lastExecutedDate = (0, moment_1.default)().valueOf();
+        }
+        ctx.updateActions.forEach((action) => action(state));
+        await storage_1.default.commitTransactionForAction(this, ctx.chatId, new transactionResult_1.default(state, ctx.startCooldown && shouldTrigger));
+    }
+    checkTrigger(ctx, trigger, state) {
+        let shouldTrigger = false;
+        const matchResults = [];
+        if (!ctx.fromUserId)
+            return commandTriggerCheckResult_1.default.DontTriggerAndSkipCooldown;
+        const isUserAllowed = this.allowedUsers.length == 0 ||
+            this.allowedUsers.includes(ctx.fromUserId);
+        const cooldownInMilliseconds = (0, timeConvertions_1.secondsToMilliseconds)(this.cooldownInSeconds);
+        const notOnCooldown = (0, moment_1.default)().valueOf() - state.lastExecutedDate >=
+            cooldownInMilliseconds;
+        if (isUserAllowed && notOnCooldown) {
+            if (typeof trigger == 'string') {
+                shouldTrigger = ctx.messageText.toLowerCase() == trigger;
+            }
+            else {
+                let matchCount = ctx.messageText.match(trigger)?.length ?? 0;
+                if (matchCount > 0) {
+                    for (; matchCount > 0; matchCount--) {
+                        const execResult = trigger.exec(ctx.messageText);
+                        if (execResult)
+                            matchResults.push(execResult);
+                    }
+                    shouldTrigger = true;
+                }
+            }
+        }
+        return new commandTriggerCheckResult_1.default(shouldTrigger, matchResults, !isUserAllowed);
+    }
+}
+exports.default = CommandAction;

package/dist/entities/actions/scheduledAction.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const storage_1 = __importDefault(require("../../services/storage"));
+const transactionResult_1 = __importDefault(require("../transactionResult"));
+const moment_1 = __importDefault(require("moment"));
+const logger_1 = __importDefault(require("../../services/logger"));
+const taskScheduler_1 = __importDefault(require("../../services/taskScheduler"));
+const async_sema_1 = require("async-sema");
+const actionStateBase_1 = __importDefault(require("../states/actionStateBase"));
+const timeConvertions_1 = require("../../helpers/timeConvertions");
+class ScheduledAction {
+    constructor(name, handler, timeinHours, active, whitelist, cachedStateFactories) {
+        this.cachedState = new Map();
+        this.stateConstructor = () => new actionStateBase_1.default();
+        this.name = name;
+        this.handler = handler;
+        this.timeinHours = timeinHours;
+        this.active = active;
+        this.chatsWhitelist = whitelist;
+        this.cachedStateFactories = cachedStateFactories;
+        this.key = `scheduled:${this.name.replace('.', '-')}`;
+    }
+    async exec(ctx) {
+        if (!this.active || !this.chatsWhitelist.includes(ctx.chatId))
+            return;
+        const state = await storage_1.default.getActionState(this, ctx.chatId);
+        const isAllowedToTrigger = this.shouldTrigger(state);
+        if (isAllowedToTrigger) {
+            logger_1.default.logWithTraceId(ctx.botName, ctx.traceId, ctx.chatName, ` - Executing [${this.name}] in ${ctx.chatId}`);
+            await this.handler(ctx, (key) => this.getCachedValue(key, ctx.botName));
+            state.lastExecutedDate = (0, moment_1.default)().valueOf();
+            await storage_1.default.commitTransactionForAction(this, ctx.chatId, new transactionResult_1.default(state, isAllowedToTrigger));
+        }
+    }
+    async getCachedValue(key, botName) {
+        if (!this.cachedStateFactories.has(key)) {
+            throw new Error(`No shared cache was set up for the key [${key}] in action '${this.name}'`);
+        }
+        await ScheduledAction.semaphore.acquire();
+        try {
+            if (this.cachedState.has(key)) {
+                return this.cachedState.get(key);
+            }
+            const cachedItemFactory = this.cachedStateFactories.get(key);
+            const value = await cachedItemFactory.getValue();
+            this.cachedState.set(key, value);
+            taskScheduler_1.default.createOnetimeTask(`Drop cached value [${this.name} : ${key}]`, () => this.cachedState.delete(key), (0, timeConvertions_1.hoursToMilliseconds)(cachedItemFactory.invalidationTimeoutInHours), botName);
+            return value;
+        }
+        finally {
+            ScheduledAction.semaphore.release();
+        }
+    }
+    shouldTrigger(state) {
+        const today = (0, moment_1.default)().startOf('day').valueOf();
+        const isAllowedToTrigger = (0, moment_1.default)().hour().valueOf() >= this.timeinHours;
+        const hasTriggeredToday = state.lastExecutedDate >= today;
+        return isAllowedToTrigger && !hasTriggeredToday;
+    }
+}
+ScheduledAction.semaphore = new async_sema_1.Sema(1);
+exports.default = ScheduledAction;

package/dist/entities/bot.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const telegraf_1 = require("telegraf");
+const telegramApi_1 = __importDefault(require("../services/telegramApi"));
+const incomingMessage_1 = __importDefault(require("./incomingMessage"));
+const taskScheduler_1 = __importDefault(require("../services/taskScheduler"));
+const logger_1 = __importDefault(require("../services/logger"));
+const timeConvertions_1 = require("../helpers/timeConvertions");
+const storage_1 = __importDefault(require("../services/storage"));
+class Bot {
+    constructor(name, token, commands, scheduled, chats) {
+        this.messageQueue = [];
+        this.name = name;
+        this.commands = commands;
+        this.scheduled = scheduled;
+        this.chats = chats;
+        logger_1.default.logWithTraceId(this.name, `System:Bot-${this.name}-Start`, 'System', 'Starting bot...');
+        this.telegraf = new telegraf_1.Telegraf(token);
+        this.api = new telegramApi_1.default(this.name, this.telegraf, this.chats);
+        this.telegraf.on('message', async (ctx) => {
+            const msg = new incomingMessage_1.default(ctx.update.message);
+            const messageContent = msg.text || '<non-text message>';
+            const messageFromName = msg.from?.first_name ?? 'Unknown';
+            const messageFromId = msg.from?.id ?? 'Unknown';
+            logger_1.default.logWithTraceId(this.name, msg.traceId, msg.chatName, `${messageFromName} (${messageFromId}): ${messageContent}`);
+            if (msg.text) {
+                this.messageQueue.push(msg);
+            }
+        });
+        this.telegraf.launch();
+        taskScheduler_1.default.createTask('MessageProcessing', async () => {
+            while (this.messageQueue.length > 0) {
+                await this.processMessages();
+            }
+        }, (0, timeConvertions_1.secondsToMilliseconds)(0.3), false, this.name);
+        taskScheduler_1.default.createTask('ScheduledProcessing', async () => {
+            await this.runScheduled();
+        }, (0, timeConvertions_1.hoursToMilliseconds)(0.5), true, this.name);
+        storage_1.default.saveMetadata([...this.commands, ...this.scheduled], this.name);
+    }
+    stop(code) {
+        logger_1.default.logWithTraceId(this.name, `System:Bot-${this.name}-Stop`, 'System', 'Stopping bot...');
+        this.telegraf.stop(code);
+    }
+    async runScheduled() {
+        for (const [chatName, chatId] of this.chats.entries()) {
+            for (const trig of this.scheduled) {
+                const ctx = this.api.createContextForChat(chatId, trig.name);
+                try {
+                    await trig.exec(ctx);
+                }
+                catch (error) {
+                    console.dir(error);
+                    logger_1.default.errorWithTraceId(ctx.botName, ctx.traceId, chatName, error, ctx);
+                }
+            }
+        }
+    }
+    async processMessages() {
+        const msg = this.messageQueue.pop();
+        for (const cmd of this.commands) {
+            const ctx = this.api.createContextForMessage(msg);
+            try {
+                await cmd.exec(ctx);
+            }
+            catch (error) {
+                logger_1.default.errorWithTraceId(ctx.botName, ctx.traceId, ctx.chatName, error, ctx);
+            }
+        }
+    }
+}
+exports.default = Bot;

package/dist/entities/cachedStateFactory.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CachedStateFactory {
+    constructor(itemFactory, invalidationTimeout) {
+        this.getValue = itemFactory;
+        this.invalidationTimeoutInHours = invalidationTimeout;
+    }
+}
+exports.default = CachedStateFactory;

package/dist/entities/commandTriggerCheckResult.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CommandTriggerCheckResult {
+    static get DontTriggerAndSkipCooldown() {
+        return new CommandTriggerCheckResult(false, [], true);
+    }
+    static get DoNotTrigger() {
+        return new CommandTriggerCheckResult(false, [], false);
+    }
+    constructor(shouldTrigger, matchResults, skipCooldown) {
+        this.shouldTrigger = shouldTrigger;
+        this.matchResults = matchResults;
+        this.skipCooldown = skipCooldown;
+    }
+    mergeWith(other) {
+        this.shouldTrigger = this.shouldTrigger || other.shouldTrigger;
+        this.matchResults = this.matchResults.concat(other.matchResults);
+        this.skipCooldown = this.skipCooldown || other.skipCooldown;
+        return this;
+    }
+}
+exports.default = CommandTriggerCheckResult;

package/dist/entities/context/chatContext.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const imageMessage_1 = __importDefault(require("../responses/imageMessage"));
+const textMessage_1 = __importDefault(require("../responses/textMessage"));
+const videoMessage_1 = __importDefault(require("../responses/videoMessage"));
+const path_1 = require("path");
+class ChatContext {
+    constructor(botName, interactions, chatId, chatName, traceId) {
+        this.botName = botName;
+        this.interactions = interactions;
+        this.chatId = chatId;
+        this.chatName = chatName;
+        this.traceId = traceId;
+    }
+    sendTextToChat(text) {
+        this.interactions.respond(new textMessage_1.default(text, this.chatId, undefined, this.traceId));
+    }
+    sendImageToChat(name) {
+        const filePath = `./content/${name}.png`;
+        this.interactions.respond(new imageMessage_1.default({ source: (0, path_1.resolve)(filePath) }, this.chatId, undefined, this.traceId));
+    }
+    sendVideoToChat(name) {
+        const filePath = `./content/${name}.mp4`;
+        this.interactions.respond(new videoMessage_1.default({ source: (0, path_1.resolve)(filePath) }, this.chatId, undefined, this.traceId));
+    }
+}
+exports.default = ChatContext;

package/dist/entities/context/messageContext.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const actionStateBase_1 = __importDefault(require("../states/actionStateBase"));
+const imageMessage_1 = __importDefault(require("../responses/imageMessage"));
+const textMessage_1 = __importDefault(require("../responses/textMessage"));
+const videoMessage_1 = __importDefault(require("../responses/videoMessage"));
+const chatContext_1 = __importDefault(require("./chatContext"));
+const storage_1 = __importDefault(require("../../services/storage"));
+const path_1 = require("path");
+const reaction_1 = __importDefault(require("../responses/reaction"));
+class MessageContext extends chatContext_1.default {
+    constructor(botName, interactions, chatId, chatName, messageId, messageText, fromUserId, traceId, fromUserName) {
+        super(botName, interactions, chatId, chatName, traceId);
+        this.matchResults = [];
+        this.startCooldown = true;
+        this.updateActions = [];
+        this.messageId = messageId;
+        this.messageText = messageText;
+        this.fromUserId = fromUserId;
+        this.fromUserName = fromUserName;
+    }
+    async loadStateOf(commandName) {
+        return ((await storage_1.default.load(`command:${commandName.replace('.', '-')}`))[this.chatId] ?? new actionStateBase_1.default());
+    }
+    updateState(stateUpdateAction) {
+        this.updateActions.push(stateUpdateAction);
+    }
+    replyWithText(text) {
+        this.interactions.respond(new textMessage_1.default(text, this.chatId, this.messageId, this.traceId));
+    }
+    replyWithImage(name) {
+        const filePath = `./content/${name}.png`;
+        this.interactions.respond(new imageMessage_1.default({ source: (0, path_1.resolve)(filePath) }, this.chatId, this.messageId, this.traceId));
+    }
+    replyWithVideo(name) {
+        const filePath = `./content/${name}.mp4`;
+        this.interactions.respond(new videoMessage_1.default({ source: (0, path_1.resolve)(filePath) }, this.chatId, this.messageId, this.traceId));
+    }
+    react(emoji) {
+        this.interactions.react(new reaction_1.default(this.traceId, this.chatId, this.messageId, emoji));
+    }
+}
+exports.default = MessageContext;

package/dist/entities/incomingMessage.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const randomInt_1 = __importDefault(require("../helpers/randomInt"));
+class IncomingMessage {
+    constructor(ctxMessage) {
+        this.traceId = (0, randomInt_1.default)(10000, 99999);
+        this.message_id = ctxMessage.message_id;
+        this.chat = ctxMessage.chat;
+        this.from = ctxMessage.from;
+        this.text = ctxMessage.text || '';
+        this.chatName =
+            'title' in ctxMessage.chat
+                ? ctxMessage.chat.title + ' ' + ctxMessage.chat.id
+                : 'DM';
+    }
+}
+exports.default = IncomingMessage;

package/dist/entities/responses/imageMessage.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ImageMessage {
+    constructor(image, chatId, replyId, traceId) {
+        this.content = image;
+        this.chatId = chatId;
+        this.replyId = replyId;
+        this.traceId = traceId;
+    }
+}
+exports.default = ImageMessage;

package/dist/entities/responses/reaction.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Reaction {
+    constructor(traceId, chatId, messageId, emoji) {
+        this.chatId = chatId;
+        this.messageId = messageId;
+        this.emoji = emoji;
+        this.traceId = traceId;
+    }
+}
+exports.default = Reaction;

package/dist/entities/responses/textMessage.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TextMessage {
+    constructor(text, chatId, replyId, traceId) {
+        this.content = text;
+        this.chatId = chatId;
+        this.replyId = replyId;
+        this.traceId = traceId;
+    }
+}
+exports.default = TextMessage;

package/dist/entities/responses/videoMessage.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class VideoMessage {
+    constructor(video, chatId, replyId, traceId) {
+        this.content = video;
+        this.chatId = chatId;
+        this.replyId = replyId;
+        this.traceId = traceId;
+    }
+}
+exports.default = VideoMessage;

package/dist/entities/states/actionStateBase.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ActionStateBase {
+    constructor() {
+        this.lastExecutedDate = 0;
+    }
+}
+exports.default = ActionStateBase;

package/dist/entities/states/potuzhnoState.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const actionStateBase_1 = __importDefault(require("./actionStateBase"));
+class PotuzhnoState extends actionStateBase_1.default {
+    constructor() {
+        super(...arguments);
+        this.scoreBoard = {};
+    }
+}
+exports.default = PotuzhnoState;

package/dist/entities/taskRecord.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TaskRecord {
+    constructor(name, taskId, interval) {
+        this.name = name;
+        this.taskId = taskId;
+        this.interval = interval;
+    }
+}
+exports.default = TaskRecord;

package/dist/entities/transactionResult.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TransactionResult {
+    constructor(data, shouldUpdate) {
+        this.data = data;
+        this.shouldUpdate = shouldUpdate;
+    }
+}
+exports.default = TransactionResult;

package/dist/helpers/builders/commandActionBuilder.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandActionBuilder = exports.CommandActionBuilderWithState = void 0;
+const commandAction_1 = __importDefault(require("../../entities/actions/commandAction"));
+const actionStateBase_1 = __importDefault(require("../../entities/states/actionStateBase"));
+const toArray_1 = __importDefault(require("../toArray"));
+const noop_1 = __importDefault(require("../noop"));
+class CommandActionBuilderWithState {
+    constructor(name, stateConstructor) {
+        this.trigger = [];
+        this.active = true;
+        this.cooldownSeconds = 0;
+        this.blacklist = [];
+        this.allowedUsers = [];
+        this.handler = noop_1.default.call;
+        this.condition = noop_1.default.true;
+        this.name = name;
+        this.stateConstructor = stateConstructor;
+    }
+    on(trigger) {
+        this.trigger = trigger;
+        return this;
+    }
+    from(id) {
+        this.allowedUsers = (0, toArray_1.default)(id);
+        return this;
+    }
+    do(handler) {
+        this.handler = handler;
+        return this;
+    }
+    when(condition) {
+        this.condition = condition;
+        return this;
+    }
+    disabled() {
+        this.active = false;
+        return this;
+    }
+    cooldown(seconds) {
+        this.cooldownSeconds = seconds;
+        return this;
+    }
+    ignoreChat(chatId) {
+        this.blacklist.push(chatId);
+        return this;
+    }
+    build() {
+        return new commandAction_1.default(this.trigger, this.handler, this.name, this.active, this.cooldownSeconds, this.blacklist, this.allowedUsers, this.condition, this.stateConstructor);
+    }
+}
+exports.CommandActionBuilderWithState = CommandActionBuilderWithState;
+class CommandActionBuilder extends CommandActionBuilderWithState {
+    constructor(name) {
+        super(name, () => new actionStateBase_1.default());
+    }
+}
+exports.CommandActionBuilder = CommandActionBuilder;

package/dist/helpers/builders/scheduledActionBuilder.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const scheduledAction_1 = __importDefault(require("../../entities/actions/scheduledAction"));
+const cachedStateFactory_1 = __importDefault(require("../../entities/cachedStateFactory"));
+const noop_1 = __importDefault(require("../noop"));
+class ScheduledActionBuilder {
+    constructor(name) {
+        this.active = true;
+        this.time = 0;
+        this.cachedStateFactories = new Map();
+        this.whitelist = [];
+        this.handler = noop_1.default.call;
+        this.name = name;
+    }
+    allowIn(chatId) {
+        this.whitelist.push(chatId);
+        return this;
+    }
+    runAt(time) {
+        this.time = time;
+        return this;
+    }
+    do(handler) {
+        this.handler = handler;
+        return this;
+    }
+    withSharedCache(key, itemFactory, invalidationTimeoutInHours = 20) {
+        this.cachedStateFactories.set(key, new cachedStateFactory_1.default(itemFactory, invalidationTimeoutInHours));
+        return this;
+    }
+    disabled() {
+        this.active = false;
+        return this;
+    }
+    build() {
+        return new scheduledAction_1.default(this.name, this.handler, this.time, this.active, this.whitelist, this.cachedStateFactories);
+    }
+}
+exports.default = ScheduledActionBuilder;

package/dist/helpers/escapeMarkdown.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = escapeMarkdown;
+const markdown_escape_1 = __importDefault(require("markdown-escape"));
+function escapeMarkdown(text) {
+    return (0, markdown_escape_1.default)(text)
+        .replaceAll(/\./g, '\\.')
+        .replaceAll(/-/g, '\\-')
+        .replaceAll(/\+/g, '\\+')
+        .replaceAll(/\{/g, '\\{')
+        .replaceAll(/!/g, '\\!')
+        .replaceAll(/\|/g, '\\|')
+        .replaceAll(/\}/g, '\\}');
+}

package/dist/helpers/getWeek.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getCurrentWeek;
+const moment_1 = __importDefault(require("moment"));
+function getCurrentWeek() {
+    const firstDay = (0, moment_1.default)().startOf('isoWeek').format('YYYY-MM-DD');
+    const lastDay = (0, moment_1.default)().endOf('isoWeek').format('YYYY-MM-DD');
+    return { firstDay, lastDay };
+}

package/dist/helpers/noop.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+class Noop {
+    static async true(arg1) {
+        return true;
+    }
+    static async false(arg1) {
+        return false;
+    }
+    static async call(arg1) { }
+}
+exports.default = Noop;

package/dist/helpers/randomInt.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = randomInteger;
+function randomInteger(x1, x2) {
+    const range = x2 - x1 + 1;
+    const random = Math.floor(Math.random() * range);
+    return random + x1;
+}

package/dist/helpers/reverseMap.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reverseMap = reverseMap;
+function reverseMap(map) {
+    return new Map(Array.from(map, ([key, value]) => [value, key]));
+}

package/dist/helpers/timeConvertions.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secondsToMilliseconds = secondsToMilliseconds;
+exports.hoursToMilliseconds = hoursToMilliseconds;
+exports.hoursToSeconds = hoursToSeconds;
+function secondsToMilliseconds(value) {
+    return (value * 1000);
+}
+function hoursToMilliseconds(value) {
+    return (value * 60 * 60 * 1000);
+}
+function hoursToSeconds(value) {
+    return (value * 60 * 60);
+}

package/dist/helpers/toArray.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = toArray;
+function toArray(value) {
+    return Array.isArray(value) ? value : [value];
+}