@juki-team/commons 0.1.47 → 0.1.48

package/dist/helpers/errors.js

@@ -0,0 +1,17 @@
+import { ERROR } from '../constants/services.js';
+export class JkError extends Error {
+    code;
+    data;
+    constructor(code, custom) {
+        const message = custom?.message || ERROR[code].message;
+        super(message);
+        this.message = message;
+        this.code = code;
+        if (custom?.stack) {
+            this.stack = custom.stack;
+        }
+        if (custom?.data) {
+            this.data = custom.data;
+        }
+    }
+}

package/dist/helpers/file.js

@@ -0,0 +1,4 @@
+export function removeExtension(fileName) {
+    const i = fileName.lastIndexOf('.');
+    return i !== -1 ? fileName.substring(0, i) : fileName;
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,17 @@
+export * from './class.js';
+export * from './comments.js';
+export * from './commons.js';
+export * from './contest.js';
+export * from './date.js';
+export * from './document.js';
+export * from './errors.js';
+export * from './file.js';
+export * from './interval.js';
+export * from './judging.js';
+export * from './number.js';
+export * from './object.js';
+export * from './responses.js';
+export * from './socket.js';
+export * from './time.js';
+export * from './user.js';
+export * from './worksheet.js';

package/dist/helpers/index.js

@@ -0,0 +1,17 @@
+export * from './class.js';
+export * from './comments.js';
+export * from './commons.js';
+export * from './contest.js';
+export * from './date.js';
+export * from './document.js';
+export * from './errors.js';
+export * from './file.js';
+export * from './interval.js';
+export * from './judging.js';
+export * from './number.js';
+export * from './object.js';
+export * from './responses.js';
+export * from './socket.js';
+export * from './time.js';
+export * from './user.js';
+export * from './worksheet.js';

package/dist/helpers/interval.js

@@ -0,0 +1,24 @@
+// https://dev.to/jsmccrumb/asynchronous-setinterval-4j69
+const asyncIntervals = [];
+const runAsyncInterval = async (cb, interval, intervalIndex) => {
+    await cb();
+    if (asyncIntervals[intervalIndex]) {
+        setTimeout(() => runAsyncInterval(cb, interval, intervalIndex), interval);
+    }
+};
+export const setAsyncInterval = (cb, interval) => {
+    if (cb && typeof cb === 'function') {
+        const intervalIndex = asyncIntervals.length;
+        asyncIntervals.push(true);
+        void runAsyncInterval(cb, interval, intervalIndex);
+        return intervalIndex;
+    }
+    else {
+        throw new Error('Callback must be a function');
+    }
+};
+export const clearAsyncInterval = (intervalIndex) => {
+    if (asyncIntervals[intervalIndex]) {
+        asyncIntervals[intervalIndex] = false;
+    }
+};

package/dist/{types/helpers → helpers}/judging.d.ts

@@ -1,4 +1,4 @@
-import { CodeEditorTestCase, DataLog, ProblemVerdict, SubmissionTestCase, TestCaseVerdict } from '../types';
+import { CodeEditorTestCase, DataLog, ProblemVerdict, SubmissionTestCase, TestCaseVerdict } from '../types/index.js';
 export declare const getDataOfTestCase: (testCase: SubmissionTestCase, timeLimit: number, memoryLimit: number) => {
     compilationError: boolean;
     timeUsed: number;

package/dist/helpers/judging.js

@@ -0,0 +1,124 @@
+import { ProblemVerdict, SubmissionRunStatus, } from '../types/index.js';
+export const getDataOfTestCase = (testCase, timeLimit, memoryLimit) => {
+    const { timeUsed, memoryUsed, exitCode } = getDataLog(testCase?.log);
+    const timeLimitExceeded = timeUsed > timeLimit;
+    const memoryLimitExceeded = memoryUsed > memoryLimit;
+    const runtimeError = exitCode !== 0;
+    const compilationError = testCase?.status === SubmissionRunStatus.COMPILATION_ERROR;
+    return {
+        compilationError,
+        timeUsed,
+        timeLimitExceeded: timeLimitExceeded,
+        memoryUsed,
+        memoryLimitExceeded: memoryLimitExceeded,
+        exitCode,
+        runtimeError,
+        failed: !!testCase?.log && (timeLimitExceeded || memoryLimitExceeded || runtimeError),
+    };
+};
+export const getVerdictFromTestCase = (testCaseValue, timeLimit, memoryLimit) => {
+    const { compilationError, timeLimitExceeded, memoryLimitExceeded, runtimeError, timeUsed, memoryUsed, exitCode, } = getDataOfTestCase(testCaseValue, timeLimit, memoryLimit);
+    return {
+        verdict: compilationError
+            ? ProblemVerdict.CE
+            : timeLimitExceeded
+                ? ProblemVerdict.TLE
+                : memoryLimitExceeded
+                    ? ProblemVerdict.MLE
+                    : runtimeError
+                        ? ProblemVerdict.RE
+                        : testCaseValue.out === testCaseValue.testOut
+                            ? ProblemVerdict.AC
+                            : testCaseValue.withPE && testCaseValue.out.split(' ').join('').split('\n').join('') === testCaseValue.testOut.split(' ').join('').split('\n').join('')
+                                ? ProblemVerdict.PE
+                                : !testCaseValue.withPE && testCaseValue.out.split(' ').join('').split('\n').join('') === testCaseValue.testOut.split(' ').join('').split('\n').join('')
+                                    ? ProblemVerdict.AC
+                                    : ProblemVerdict.WA,
+        timeUsed,
+        memoryUsed,
+        exitCode,
+    };
+};
+export const mergeVerdicts = (first, second) => {
+    let verdict = first.verdict;
+    if (second.verdict === ProblemVerdict.RE) {
+        verdict = ProblemVerdict.RE;
+    }
+    else if (second.verdict === ProblemVerdict.TLE && verdict != ProblemVerdict.RE) {
+        verdict = ProblemVerdict.TLE;
+    }
+    else if (second.verdict === ProblemVerdict.MLE
+        && verdict !== ProblemVerdict.TLE
+        && verdict !== ProblemVerdict.RE) {
+        verdict = ProblemVerdict.MLE;
+    }
+    else if (second.verdict === ProblemVerdict.WA
+        && verdict !== ProblemVerdict.MLE
+        && verdict !== ProblemVerdict.TLE
+        && verdict !== ProblemVerdict.RE) {
+        verdict = ProblemVerdict.WA;
+    }
+    else if (second.verdict === ProblemVerdict.PE
+        && verdict !== ProblemVerdict.WA
+        && verdict !== ProblemVerdict.MLE
+        && verdict !== ProblemVerdict.TLE
+        && verdict !== ProblemVerdict.RE) {
+        verdict = ProblemVerdict.PE;
+    }
+    else if (second.verdict === ProblemVerdict.PA
+        && verdict !== ProblemVerdict.PE
+        && verdict !== ProblemVerdict.WA
+        && verdict !== ProblemVerdict.MLE
+        && verdict !== ProblemVerdict.TLE
+        && verdict !== ProblemVerdict.RE) {
+        verdict = ProblemVerdict.PA;
+    }
+    else if (second.verdict === ProblemVerdict.AC
+        && verdict !== ProblemVerdict.PA
+        && verdict !== ProblemVerdict.PE
+        && verdict !== ProblemVerdict.WA
+        && verdict !== ProblemVerdict.MLE
+        && verdict !== ProblemVerdict.TLE
+        && verdict !== ProblemVerdict.RE) {
+        verdict = ProblemVerdict.AC;
+    }
+    return {
+        timeUsed: Math.max(first.timeUsed, second.timeUsed),
+        memoryUsed: Math.max(first.memoryUsed, second.memoryUsed),
+        exitCode: first.exitCode || second.exitCode,
+        verdict,
+    };
+};
+export const getDataLog = (log) => {
+    const lines = log?.split?.('\n') || [];
+    let timeUsed = 0;
+    let memoryUsed = 0;
+    let exitCode = -1;
+    if (lines.length > 4) {
+        for (const line of lines) {
+            if (line.startsWith('time:')) {
+                timeUsed = +line.split(':')[1];
+                if (Number.isNaN(timeUsed)) {
+                    timeUsed = 0;
+                }
+                timeUsed *= 1000;
+            }
+            else if (line.startsWith('max-rss:')) {
+                memoryUsed = parseInt(line.split(':')[1], 10); // en KB
+            }
+            else if (line.startsWith('exitcode:')) {
+                exitCode = parseInt(line.split(':')[1], 10);
+            }
+        }
+    }
+    else if (lines.length >= 3) {
+        timeUsed = +lines[0];
+        memoryUsed = +lines[1];
+        exitCode = +lines[2];
+    }
+    return {
+        timeUsed: Number.isNaN(timeUsed) ? 0 : timeUsed,
+        memoryUsed: Number.isNaN(memoryUsed) ? 0 : memoryUsed,
+        exitCode: Number.isNaN(exitCode) ? -1 : exitCode,
+    };
+};

package/dist/helpers/number.js

@@ -0,0 +1,2 @@
+export const padStart = (n, maxLength, fillString = '0') => `${n}`.padStart(maxLength, fillString);
+export const padEnd = (n, maxLength, fillString = '0') => `${n}`.padEnd(maxLength, fillString);

package/dist/helpers/object.js

@@ -0,0 +1,33 @@
+export function memorySizeOf(obj) {
+    let bytes = 0;
+    function sizeOf(obj) {
+        if (obj !== null && obj !== undefined) {
+            switch (typeof obj) {
+                case "number":
+                    bytes += 8;
+                    break;
+                case "string":
+                    bytes += obj.length * 2;
+                    break;
+                case "boolean":
+                    bytes += 4;
+                    break;
+                case "object":
+                    const objClass = Object.prototype.toString.call(obj).slice(8, -1);
+                    if (objClass === "Object" || objClass === "Array") {
+                        for (const key in obj) {
+                            if (!obj.hasOwnProperty(key))
+                                continue;
+                            bytes += key.length * 2;
+                            sizeOf(obj[key]);
+                        }
+                    }
+                    else
+                        bytes += obj.toString().length * 2;
+                    break;
+            }
+        }
+        return bytes;
+    }
+    return sizeOf(obj);
+}

package/dist/{types/helpers → helpers}/responses.d.ts

@@ -1,5 +1,5 @@
-import { JkError } from './errors';
-import { ContentResponse, ContentsMeta, ContentsResponse, ErrorResponse } from '../types';
+import { JkError } from './errors.js';
+import { ContentResponse, ContentsMeta, ContentsResponse, ErrorResponse } from '../types/index.js';
 export declare function toJkError(err: any): JkError;
 export declare function errorsResponse(message: string, ...errors: JkError[]): ErrorResponse;
 export declare function contentResponse<T>(message: string, content: T): ContentResponse<T>;

package/dist/helpers/responses.js

@@ -0,0 +1,95 @@
+import { ERROR } from '../constants/index.js';
+import { JkError } from './errors.js';
+import { ErrorCode } from '../types/index.js';
+import { consoleError, isStringJson } from './commons.js';
+export function toJkError(err) {
+    const error = new Error();
+    let code = err?.code;
+    if (!(code in ErrorCode)) {
+        code = ErrorCode.ERR500;
+    }
+    return new JkError(code, {
+        message: err?.message || error.message,
+        stack: err?.stack || error.stack,
+        data: err?.data || null,
+    });
+}
+export function errorsResponse(message, ...errors) {
+    return {
+        success: false,
+        message: message,
+        errors: errors.map(error => ({
+            code: error.code,
+            message: error.message,
+            detail: error.stack || new Error().stack || '',
+            data: error.data,
+        })),
+    };
+}
+export function contentResponse(message, content) {
+    return {
+        success: true,
+        message,
+        content,
+    };
+}
+export function contentsResponse(message, contents, meta) {
+    return {
+        success: true,
+        message,
+        contents,
+        meta,
+    };
+}
+export const cleanRequest = (responseText) => {
+    if (!isStringJson(responseText)) {
+        // this occurs when the endpoint don't exits or server is down
+        const response = {
+            success: false,
+            message: ERROR[ErrorCode.ERR9999].message,
+            errors: [{ code: ErrorCode.ERR9999, detail: '', message: ERROR[ErrorCode.ERR9999].message }],
+        };
+        consoleError({ message: 'response is not string json, success false on cleaning request', responseText, response });
+        // jukiApiManager.reportError({ message: 'success false on cleaning request', responseText, response });
+        return response;
+    }
+    const responseJson = JSON.parse(responseText);
+    if (typeof responseJson.success === 'boolean') {
+        if (responseJson.success === true && typeof responseJson.message === 'string' && responseJson.content) { // V1
+            return {
+                success: true,
+                message: responseJson.message,
+                content: responseJson.content,
+            };
+        }
+        else if (responseJson.success === true && typeof responseJson.message === 'string' && Array.isArray(responseJson.contents) && responseJson.meta) { // V1
+            return {
+                success: true,
+                message: responseJson.message,
+                contents: responseJson.contents,
+                meta: responseJson.meta,
+            };
+        }
+        else if (responseJson.success === false && typeof responseJson.message === 'string' && Array.isArray(responseJson.errors)) { // V1
+            const response = {
+                success: false,
+                message: responseJson.message,
+                errors: responseJson.errors,
+            };
+            consoleError({ message: 'success false on cleaning request', responseText, response });
+            // jukiApiManager.reportError({ message: 'success false on cleaning request', responseText, response });
+            return response;
+        }
+    }
+    const response = {
+        success: false,
+        message: ERROR[ErrorCode.ERR9998].message,
+        errors: [{ code: ErrorCode.ERR9998, detail: '', message: ERROR[ErrorCode.ERR9998].message }],
+    };
+    consoleError({ message: 'success false on cleaning request', responseText, response });
+    // jukiApiManager.reportError({ message: 'success false on cleaning request', responseText, response });
+    return response;
+};
+export const getDefaultMeta = (contents, sort) => {
+    return { sort: sort ?? [], page: 1, size: contents.length, totalElements: contents.length, filter: {} };
+};

package/dist/{types/helpers → helpers}/socket.d.ts

@@ -1,5 +1,5 @@
-import { CodeRunStatusWebSocketResponseEventDto, ContestChangesWebSocketResponseEventDto, ProblemCrawledWebSocketResponseEventDto, SendDataEc2InstancesListWebSocketResponseEventDto, SendDataEcsTaskDefinitionListWebSocketResponseEventDto, SendDataEcsTasksListWebSocketResponseEventDto, SendDataRunCommandWebSocketResponseEventDto, SendDataSsmSessionsListWebSocketResponseEventDto, SendDataWebSocketResponseEventDto, SubmissionJudgingWebSocketResponseEventDto, SubmissionRunStatusWebSocketResponseEventDto, SubmissionsCrawlWebSocketResponseEventDto, SubmissionsJudgingScope, SubscribeCodeRunStatusWebSocketEventDto, SubscribeContestChangesWebSocketEventDto, SubscribeGetDataWebSocketEventDto, SubscribeProblemCrawledWebSocketEventDto, SubscribeSubmissionRunStatusWebSocketEventDto, SubscribeSubmissionsCrawlWebSocketEventDto, SubscribeSubmissionsJudgingWebSocketEventDto, SubscribeUserNotificationWebsocketEventDto, UnsubscribeCodeRunStatusWebSocketEventDto, UnsubscribeContestChangesWebSocketEventDto, UnsubscribeGetDataWebSocketEventDto, UnsubscribeProblemCrawledWebSocketEventDto, UnsubscribeSubmissionRunStatusWebSocketEventDto, UnsubscribeSubmissionsCrawlWebSocketEventDto, UnsubscribeSubmissionsJudgingWebSocketEventDto, UnsubscribeUserNotificationWebSocketEventDto, UserMessageWebSocketResponseEventDto, UserNotificationContestClarificationWebSocketResponseEventDto, UserNotificationSubmissionWebSocketResponseEventDto, UserNotificationWebSocketResponseEventDto, WebSocketChannelsMessageDto, WebSocketResponseEventDto, WebSocketSubscribeEventDto, WebSocketUnsubscribeEventDto } from '../dto';
-import { ClientId, WebSocketResponseEvent, WebSocketResponseEventKey } from '../types';
+import { CodeRunStatusWebSocketResponseEventDto, ContestChangesWebSocketResponseEventDto, ProblemCrawledWebSocketResponseEventDto, SendDataEc2InstancesListWebSocketResponseEventDto, SendDataEcsTaskDefinitionListWebSocketResponseEventDto, SendDataEcsTasksListWebSocketResponseEventDto, SendDataRunCommandWebSocketResponseEventDto, SendDataSsmSessionsListWebSocketResponseEventDto, SendDataWebSocketResponseEventDto, SubmissionJudgingWebSocketResponseEventDto, SubmissionRunStatusWebSocketResponseEventDto, SubmissionsCrawlWebSocketResponseEventDto, SubmissionsJudgingScope, SubscribeCodeRunStatusWebSocketEventDto, SubscribeContestChangesWebSocketEventDto, SubscribeGetDataWebSocketEventDto, SubscribeProblemCrawledWebSocketEventDto, SubscribeSubmissionRunStatusWebSocketEventDto, SubscribeSubmissionsCrawlWebSocketEventDto, SubscribeSubmissionsJudgingWebSocketEventDto, SubscribeUserNotificationWebsocketEventDto, UnsubscribeCodeRunStatusWebSocketEventDto, UnsubscribeContestChangesWebSocketEventDto, UnsubscribeGetDataWebSocketEventDto, UnsubscribeProblemCrawledWebSocketEventDto, UnsubscribeSubmissionRunStatusWebSocketEventDto, UnsubscribeSubmissionsCrawlWebSocketEventDto, UnsubscribeSubmissionsJudgingWebSocketEventDto, UnsubscribeUserNotificationWebSocketEventDto, UserMessageWebSocketResponseEventDto, UserNotificationContestClarificationWebSocketResponseEventDto, UserNotificationSubmissionWebSocketResponseEventDto, UserNotificationWebSocketResponseEventDto, WebSocketChannelsMessageDto, WebSocketResponseEventDto, WebSocketSubscribeEventDto, WebSocketUnsubscribeEventDto } from '../dto/index.js';
+import { ClientId, WebSocketResponseEvent, WebSocketResponseEventKey } from '../types/index.js';
 export declare const isWebsocketSubscription: (event: any) => event is WebSocketSubscribeEventDto | WebSocketUnsubscribeEventDto;
 export declare const isSubscribeCodeRunStatusWebSocketEventDto: (event: any) => event is SubscribeCodeRunStatusWebSocketEventDto;
 export declare const isUnsubscribeCodeRunStatusWebSocketEventDto: (event: any) => event is UnsubscribeCodeRunStatusWebSocketEventDto;

package/dist/helpers/socket.js

@@ -0,0 +1,279 @@
+import { CHANNEL_CONTEST, CHANNEL_PROBLEM, CHANNEL_SUBMISSION, CHANNEL_USER_ROLE, } from '../constants/websocket.js';
+import { ContestChannelRole, ProblemChannelRole, ProblemVerdict, SubmissionRunStatus, UserChannelRole, WebSocketResponseEvent, WebSocketSubscriptionEvent, } from '../types/index.js';
+import { join } from './commons.js';
+export const isWebsocketSubscription = (event) => {
+    return Object.values(WebSocketSubscriptionEvent).includes(event?.event)
+        && typeof event?.clientId === 'string' && !!event.clientId;
+};
+// CHANNEL_PUBLISH_SUBSCRIPTIONS
+export const isSubscribeCodeRunStatusWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.SUBSCRIBE_CODE_RUN_STATUS
+        && typeof event?.runId === 'string' && !!event.runId;
+};
+export const isUnsubscribeCodeRunStatusWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.UNSUBSCRIBE_CODE_RUN_STATUS
+        && typeof event?.runId === 'string' && !!event.runId;
+};
+export const isSubscribeSubmissionRunStatusWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.SUBSCRIBE_SUBMISSION_RUN_STATUS
+        && typeof event?.submitId === 'string' && !!event.submitId;
+};
+export const isUnsubscribeSubmissionRunStatusWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.UNSUBSCRIBE_SUBMISSION_RUN_STATUS
+        && typeof event?.submitId === 'string' && !!event.submitId;
+};
+export const isSubscribeGetDataWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.SUBSCRIBE_GET_DATA;
+};
+export const isUnsubscribeGetDataWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.UNSUBSCRIBE_GET_DATA;
+};
+export const isSubscribeProblemCrawledWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.SUBSCRIBE_PROBLEM_CRAWLED;
+};
+export const isUnsubscribeProblemCrawledWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.UNSUBSCRIBE_PROBLEM_CRAWLED;
+};
+export const isSubscribeSubmissionsCrawlWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.SUBSCRIBE_SUBMISSIONS_CRAWL;
+};
+export const isUnsubscribeSubmissionsCrawlWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.UNSUBSCRIBE_SUBMISSIONS_CRAWL;
+};
+export const isSubscribeContestChangesWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.SUBSCRIBE_CONTEST_CHANGES;
+};
+export const isUnsubscribeContestChangesWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.UNSUBSCRIBE_CONTEST_CHANGES;
+};
+export const isSubscribeUserNotificationWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.SUBSCRIBE_USER_NOTIFICATION;
+};
+export const isUnsubscribeUserNotificationWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.UNSUBSCRIBE_USER_NOTIFICATION;
+};
+const isNonEmptyString = (value) => typeof value === 'string' && !!value;
+/**
+ * Exactly one of `problemKey` / `contestKey` / `userKey` is set.
+ */
+export const isSubmissionsJudgingScope = (scope) => {
+    return [scope?.problemKey, scope?.contestKey, scope?.userKey].filter(isNonEmptyString).length === 1;
+};
+export const isSubscribeSubmissionsJudgingWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.SUBSCRIBE_SUBMISSIONS_JUDGING
+        && isSubmissionsJudgingScope(event);
+};
+export const isUnsubscribeSubmissionsJudgingWebSocketEventDto = (event) => {
+    return isWebsocketSubscription(event)
+        && event?.event === WebSocketSubscriptionEvent.UNSUBSCRIBE_SUBMISSIONS_JUDGING
+        && isSubmissionsJudgingScope(event);
+};
+// is WebSocketResponseEventDto, CHANNEL_SUBSCRIBE_CLIENT
+export const isWebSocketResponseEventDto = (event) => {
+    return Object.values(WebSocketResponseEvent).includes(event?.event)
+        && typeof event?.key === 'string'
+        && typeof event?.connectionId === 'string'
+        && typeof event?.createdAt === 'number' && !!event.createdAt;
+};
+export const isCodeRunStatusMessageWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.CODE_RUN_STATUS
+        && typeof event?.runId === 'string' && !!event.runId
+        && event?.status in SubmissionRunStatus;
+};
+export const isSubmissionRunStatusMessageWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.SUBMISSION_RUN_STATUS
+        && typeof event?.submitId === 'string' && !!event.submitId
+        && event?.status in SubmissionRunStatus
+        && event?.verdict in ProblemVerdict
+        && typeof event?.points === 'number';
+};
+export const isSubmissionJudgingWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.SUBMISSION_JUDGING
+        && isNonEmptyString(event?.submitId)
+        && isNonEmptyString(event?.problemKey)
+        && (event?.contestKey === null || isNonEmptyString(event?.contestKey))
+        && isNonEmptyString(event?.userKey)
+        && typeof event?.judging === 'boolean'
+        && event?.status in SubmissionRunStatus
+        && event?.verdict in ProblemVerdict
+        && typeof event?.points === 'number';
+};
+export const isUserMessageWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.USER_MESSAGE
+        && typeof event?.user?.nickname === 'string' && !!event.user?.nickname
+        && typeof event?.user?.imageUrl === 'string' && !!event.user?.imageUrl
+        && typeof event?.user?.organization?.key === 'string' && !!event.user?.organization?.key
+        && !!event?.content;
+};
+export const isSendDataWebSocketResponseEventDto = (event) => {
+    return [
+        WebSocketResponseEvent.SEND_DATA_ECS_TASK_DEFINITIONS_LIST,
+        WebSocketResponseEvent.SEND_DATA_EC2_INSTANCES_LIST,
+        WebSocketResponseEvent.SEND_DATA_ECS_TASKS_LIST,
+        WebSocketResponseEvent.SEND_DATA_SSM_SESSIONS_LIST,
+        WebSocketResponseEvent.SEND_DATA_RUN_COMMAND,
+    ].includes(event?.event)
+        && typeof event?.dataId === 'string' && !!event.dataId
+        && !!event?.content;
+};
+export const isSendDataEcsTaskDefinitionListWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event) && isSendDataWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.SEND_DATA_ECS_TASK_DEFINITIONS_LIST;
+};
+export const isSendDataEc2InstancesListWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event) && isSendDataWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.SEND_DATA_EC2_INSTANCES_LIST;
+};
+export const isSendDataEcsTasksListWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event) && isSendDataWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.SEND_DATA_ECS_TASKS_LIST;
+};
+export const isSendDataSsmSessionsListWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event) && isSendDataWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.SEND_DATA_SSM_SESSIONS_LIST;
+};
+export const isSendDataRunCommandWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event) && isSendDataWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.SEND_DATA_RUN_COMMAND;
+};
+export const isProblemCrawledWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.PROBLEM_CRAWLED
+        && !!event?.content;
+};
+export const isSubmissionsCrawlWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.SUBMISSIONS_CRAWL
+        && !!event?.content;
+};
+export const isContestChangesWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.CONTEST_CHANGES
+        && !!event?.content;
+};
+export const isUserNotificationWebSocketResponseEventDto = (event) => {
+    return [
+        WebSocketResponseEvent.USER_NOTIFICATION_SUBMISSION,
+        WebSocketResponseEvent.USER_NOTIFICATION_CONTEST_CLARIFICATION,
+    ].includes(event?.event)
+        && !!event?.content;
+};
+export const isUserNotificationSubmissionWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event) && isUserNotificationWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.USER_NOTIFICATION_SUBMISSION;
+};
+export const isUserNotificationContestClarificationWebSocketResponseEventDto = (event) => {
+    return isWebSocketResponseEventDto(event) && isUserNotificationWebSocketResponseEventDto(event)
+        && event?.event === WebSocketResponseEvent.USER_NOTIFICATION_CONTEST_CLARIFICATION;
+};
+// generic
+export const getWebSocketResponseEventKey = (event, clientId, id) => {
+    return `${event}-${clientId}-${id}`;
+};
+export const isWebSocketChannelsMessageDto = (message) => {
+    return Array.isArray(message?.channels)
+        && message.channels.every((channel) => typeof channel === 'string' && !!channel)
+        && Object.values(WebSocketResponseEvent).includes(message?.event?.event);
+};
+/**
+ * Key used by the client to dispatch a response received on a TOPIC channel to its subscribers.
+ * It is the same key that `getKeyWebSocketEventDto` (base-ui) computes for the subscription.
+ * Returns null when the response is not addressed to this client.
+ */
+export const getWebSocketResponseEventKeyOfResponse = (response, clientId) => {
+    if (isCodeRunStatusMessageWebSocketResponseEventDto(response)) {
+        return getWebSocketResponseEventKey(WebSocketResponseEvent.CODE_RUN_STATUS, clientId, response.runId);
+    }
+    if (isSubmissionRunStatusMessageWebSocketResponseEventDto(response)) {
+        return getWebSocketResponseEventKey(WebSocketResponseEvent.SUBMISSION_RUN_STATUS, clientId, response.submitId);
+    }
+    if (isSendDataWebSocketResponseEventDto(response)) {
+        return getWebSocketResponseEventKey(WebSocketResponseEvent.SEND_DATA_, clientId, response.dataId);
+    }
+    if (isContestChangesWebSocketResponseEventDto(response)) {
+        return getWebSocketResponseEventKey(WebSocketResponseEvent.CONTEST_CHANGES, clientId, response.content.contestKey);
+    }
+    if (isProblemCrawledWebSocketResponseEventDto(response)) {
+        return getWebSocketResponseEventKey(WebSocketResponseEvent.PROBLEM_CRAWLED, clientId, response.content.problemKey);
+    }
+    if (isSubmissionsCrawlWebSocketResponseEventDto(response)) {
+        return getWebSocketResponseEventKey(WebSocketResponseEvent.SUBMISSIONS_CRAWL, clientId, join([response.content.contestKey, response.content.problemKeys]));
+    }
+    if (isUserNotificationWebSocketResponseEventDto(response)) {
+        return getWebSocketResponseEventKey(WebSocketResponseEvent.USER_NOTIFICATION_, clientId, '*');
+    }
+    if (isSubmissionJudgingWebSocketResponseEventDto(response)) {
+        // one key for every table: the same event is published on several channels (problem / contest / user) and the
+        // client deduplicates it, so it is dispatched once; each table filters by the submissions it lists
+        return getWebSocketResponseEventKey(WebSocketResponseEvent.SUBMISSION_JUDGING, clientId, '*');
+    }
+    return null;
+};
+/**
+ * TOPIC channel that the client has to attach to receive the events of a subscription,
+ * or null when the events arrive by the private channels (session / user) the client is always attached to.
+ * Ably rejects the attach if the token has no capability for the channel.
+ */
+export const getChannelOfWebSocketSubscribeEvent = (event) => {
+    if (isSubscribeSubmissionRunStatusWebSocketEventDto(event)) {
+        return CHANNEL_SUBMISSION(event.submitId);
+    }
+    // SUBSCRIBE_PROBLEM_CRAWLED: the event arrives by the private user channel of who requested the crawl
+    if (isSubscribeContestChangesWebSocketEventDto(event) || isSubscribeSubmissionsCrawlWebSocketEventDto(event)) {
+        return CHANNEL_CONTEST(event.contestKey, ContestChannelRole.SPECTATORS);
+    }
+    if (isSubscribeSubmissionsJudgingWebSocketEventDto(event)) {
+        // the judging start/end is published on the spectators channel when it is visible to everyone; the hidden ones
+        // (frozen / quiet contests) arrive by the role channels of the contest (managers) and the private user channel
+        if ('problemKey' in event && event.problemKey) {
+            return CHANNEL_PROBLEM(event.problemKey, ProblemChannelRole.SPECTATORS);
+        }
+        if ('contestKey' in event && event.contestKey) {
+            return CHANNEL_CONTEST(event.contestKey, ContestChannelRole.SPECTATORS);
+        }
+        if ('userKey' in event && event.userKey) {
+            return CHANNEL_USER_ROLE(event.userKey, UserChannelRole.SPECTATORS);
+        }
+    }
+    return null;
+};
+/**
+ * Contest whose role channels the client needs (the API grants them when the token is requested with this contest).
+ */
+export const getContestKeyOfWebSocketSubscribeEvent = (event) => {
+    if (isSubscribeContestChangesWebSocketEventDto(event) || isSubscribeSubmissionsCrawlWebSocketEventDto(event)) {
+        return event.contestKey;
+    }
+    if (isSubscribeSubmissionsJudgingWebSocketEventDto(event) && 'contestKey' in event && event.contestKey) {
+        return event.contestKey;
+    }
+    return null;
+};
+/**
+ * Problem whose role channels the client needs (the API grants them when the token is requested with this problem).
+ */
+export const getProblemKeyOfWebSocketSubscribeEvent = (event) => {
+    if (isSubscribeSubmissionsJudgingWebSocketEventDto(event) && 'problemKey' in event && event.problemKey) {
+        return event.problemKey;
+    }
+    return null;
+};

package/dist/{types/helpers → helpers}/time.d.ts

@@ -1,2 +1,2 @@
-import { SplitTime } from '../types';
+import { SplitTime } from '../types/index.js';
 export declare function splitTime(timeRemaining: number): [SplitTime, SplitTime, SplitTime, SplitTime, SplitTime, SplitTime];