@juki-team/commons 0.1.46 → 0.1.48

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];

package/dist/helpers/time.js

@@ -0,0 +1,69 @@
+export function splitTime(timeRemaining) {
+    const remaining = [];
+    // const aYearMilliseconds = 1000 * 60 * 60 * 24 * 365;
+    // const remainingYears = Math.floor(timeRemaining / aYearMilliseconds);
+    // remaining.push({ remaining: remainingYears, label: 'years', milliseconds: aYearMilliseconds });
+    // const aWeekMilliseconds = 1000 * 60 * 60 * 24 * 7;
+    // const remainingWeeks = Math.floor((timeRemaining % aYearMilliseconds) / aWeekMilliseconds);
+    // remaining.push({ remaining: remainingWeeks, label: 'weeks', milliseconds: aWeekMilliseconds });
+    const aSecondMilliseconds = 1000;
+    const aMinuteMilliseconds = aSecondMilliseconds * 60;
+    const aHourMilliseconds = aMinuteMilliseconds * 60;
+    const aDayMilliseconds = aHourMilliseconds * 24;
+    const aWeekMilliseconds = aDayMilliseconds * 7;
+    const remainingWeeks = Math.floor(timeRemaining / aWeekMilliseconds);
+    remaining.push({
+        remaining: remainingWeeks,
+        label: remainingWeeks === 1 ? 'week' : 'weeks',
+        abbreviatedLabel: 'w',
+        milliseconds: aWeekMilliseconds,
+        digits: 2,
+    });
+    const remainingDays = Math.floor((timeRemaining % aWeekMilliseconds) / aDayMilliseconds);
+    remaining.push({
+        remaining: remainingDays,
+        label: remainingDays === 1 ? 'day' : 'days',
+        abbreviatedLabel: 'd',
+        milliseconds: aDayMilliseconds,
+        digits: 2,
+    });
+    const remainingHours = Math.floor((timeRemaining % aDayMilliseconds) / aHourMilliseconds);
+    remaining.push({
+        remaining: remainingHours,
+        label: remainingHours === 1 ? 'hour' : 'hours',
+        abbreviatedLabel: 'h',
+        milliseconds: aHourMilliseconds,
+        digits: 2,
+    });
+    const remainingMinutes = Math.floor((timeRemaining % aHourMilliseconds) / aMinuteMilliseconds);
+    remaining.push({
+        remaining: remainingMinutes,
+        label: remainingMinutes === 1 ? 'minute' : 'minutes',
+        abbreviatedLabel: 'm',
+        milliseconds: aMinuteMilliseconds,
+        digits: 2,
+    });
+    const remainingSeconds = Math.floor((timeRemaining % aMinuteMilliseconds) / aSecondMilliseconds);
+    remaining.push({
+        remaining: remainingSeconds,
+        label: remainingSeconds === 1 ? 'second' : 'seconds',
+        abbreviatedLabel: 's',
+        milliseconds: aSecondMilliseconds,
+        digits: 2,
+    });
+    const remainingMilliseconds = Math.floor(timeRemaining % aSecondMilliseconds);
+    remaining.push({
+        remaining: remainingMilliseconds,
+        label: remainingMilliseconds === 1 ? 'millisecond' : 'milliseconds',
+        abbreviatedLabel: 'ms',
+        milliseconds: 1,
+        digits: 3,
+    });
+    // while (remaining[0].remaining <= 0) {
+    //   remaining.shift();
+    //   if (remaining.length === 3) {
+    //     break;
+    //   }
+    // }
+    return remaining;
+}

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

@@ -1,4 +1,4 @@
-import { ClientId, RecordId } from '../types';
+import { ClientId, RecordId } from '../types/index.js';
 export declare const getUserKey: (userNickname: string, userOrganizationKey: string) => string;
 export declare const getParamsOfUserKey: (userKey: string) => {
     userNickname: string;

package/dist/helpers/user.js

@@ -0,0 +1,14 @@
+export const getUserKey = (userNickname, userOrganizationKey) => {
+    return userNickname + '|' + userOrganizationKey;
+};
+export const getParamsOfUserKey = (userKey) => {
+    const [userNickname, userOrganizationKey] = userKey.split('|');
+    return { userNickname, userOrganizationKey };
+};
+export const getClientId = (sessionId, uiId) => {
+    return `${sessionId}|${uiId}`;
+};
+export const getParamsOfClientId = (clientId) => {
+    const [sessionId, uiId] = clientId.split('|');
+    return { sessionId, uiId };
+};

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

@@ -1,4 +1,4 @@
-import { BasicWorksheet, BodyWorksheet, CodeEditorSheet, JkmdSheet, QuizOptionsSheet, QuizProblemSheet, QuizTextSheet, SummaryWorksheetsInPages, WorksheetsInPages } from '../types';
+import { BasicWorksheet, BodyWorksheet, CodeEditorSheet, JkmdSheet, QuizOptionsSheet, QuizProblemSheet, QuizTextSheet, SummaryWorksheetsInPages, WorksheetsInPages } from '../types/index.js';
 export declare const getWorksheetsInPages: (initialSheets: BodyWorksheet[]) => WorksheetsInPages;
 export declare const getSummaryWorksheetsInPages: (initialSheets: BodyWorksheet[]) => SummaryWorksheetsInPages;
 export declare const getTotalExercisesOfSummaryWorksheetsInPages: (content: SummaryWorksheetsInPages) => number;

package/dist/helpers/worksheet.js

@@ -0,0 +1,107 @@
+import { NEW_PAGE_SHEET } from '../constants/worksheet.js';
+import { Judge, WorksheetType, } from '../types/index.js';
+export const getWorksheetsInPages = (initialSheets) => {
+    const sheets = [...initialSheets];
+    if (sheets[0]?.type !== WorksheetType.NEW_PAGE) {
+        sheets.unshift(NEW_PAGE_SHEET());
+    }
+    let newPage = sheets[0];
+    let content = [];
+    const sheetsByPages = [];
+    for (let i = 1; i < sheets.length; i++) {
+        const sheet = sheets[i];
+        if (sheet.type === WorksheetType.NEW_PAGE) {
+            sheetsByPages.push({
+                header: newPage,
+                content: [...content],
+            });
+            newPage = sheet;
+            content = [];
+        }
+        else {
+            content.push(sheet);
+        }
+    }
+    sheetsByPages.push({
+        header: newPage,
+        content: [...content],
+    });
+    return sheetsByPages;
+};
+export const getSummaryWorksheetsInPages = (initialSheets) => {
+    const sheets = [...initialSheets];
+    if (sheets[0]?.type !== WorksheetType.NEW_PAGE) {
+        sheets.unshift(NEW_PAGE_SHEET());
+    }
+    let newPage = sheets[0];
+    let content = [];
+    const sheetsByPages = [];
+    for (let i = 1; i < sheets.length; i++) {
+        const sheet = sheets[i];
+        if (sheet.type === WorksheetType.NEW_PAGE) {
+            sheetsByPages.push({
+                header: newPage,
+                content: content.map(c => ({
+                    id: c.id,
+                    type: c.type,
+                    title: c.title,
+                    points: c.points,
+                })),
+            });
+            newPage = sheet;
+            content = [];
+        }
+        else {
+            content.push(sheet);
+        }
+    }
+    sheetsByPages.push({
+        header: newPage,
+        content: [...content],
+    });
+    return sheetsByPages;
+};
+export const getTotalExercisesOfSummaryWorksheetsInPages = (content) => content.reduce((sum, { content }) => sum + content.reduce((sum, { type }) => sum + +(type === WorksheetType.QUIZ_OPTIONS || type === WorksheetType.QUIZ_PROBLEM || type === WorksheetType.QUIZ_TEXT), 0), 0);
+export const isBasicWorksheet = (value) => {
+    return typeof value?.id == 'string' && value.id
+        && Object.values(WorksheetType).includes(value?.type)
+        && typeof value?.title == 'string'
+        && typeof value?.points == 'number';
+};
+export const isJkmdSheet = (value) => {
+    return isBasicWorksheet(value)
+        && value?.type === WorksheetType.JK_MD
+        && typeof value?.content == 'string';
+};
+export const isCodeEditorSheet = (value) => {
+    return isBasicWorksheet(value)
+        && value?.type === WorksheetType.CODE_EDITOR
+        && typeof value?.sourceCode === 'object' && value?.sourceCode !== null
+        && value?.testCases === 'object' && value?.testCases !== null
+        && Array.isArray(value?.languages)
+        && typeof value?.height == 'number';
+};
+export const isQuizProblemSheet = (value) => {
+    return isBasicWorksheet(value)
+        && value?.type === WorksheetType.QUIZ_PROBLEM
+        && Object.values(Judge).includes(value?.problemJudge) || typeof value?.problemJudge === 'string'
+        && typeof value?.problemKey == 'string'
+        && Array.isArray(value?.languages)
+        && typeof value?.height == 'number';
+};
+export const isQuizOptionsSheet = (value) => {
+    return isBasicWorksheet(value)
+        && value?.type === WorksheetType.QUIZ_OPTIONS
+        && typeof value?.description == 'string'
+        && Array.isArray(value?.options)
+        && value?.options.every((option) => typeof option?.label == 'string' && typeof option?.correct == 'boolean' && typeof option?.id == 'string')
+        && typeof value?.multiple == 'boolean'
+        && (value?.scoringMode === 'TOTAL' || value?.scoringMode === 'PARTIAL');
+};
+export const isQuizTextSheet = (value) => {
+    return isBasicWorksheet(value)
+        && value?.type === WorksheetType.QUIZ_TEXT
+        && typeof value?.description == 'string'
+        && typeof value?.answer == 'string'
+        && ['text', 'number', 'textarea'].includes(value?.inputType);
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants/index.js';
+export * from './dto/index.js';
+export * from './helpers/index.js';
+export * from './types/index.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './constants/index.js';
+export * from './dto/index.js';
+export * from './helpers/index.js';
+export * from './types/index.js';

package/dist/types/account.js

@@ -0,0 +1,10 @@
+export var ProfileSetting;
+(function (ProfileSetting) {
+    ProfileSetting["NEWSLETTER_SUBSCRIPTION"] = "newsletterSubscription";
+    ProfileSetting["LANGUAGE"] = "preferredLanguage";
+    ProfileSetting["THEME"] = "preferredTheme";
+    ProfileSetting["DATA_VIEW_MODE"] = "preferredDataViewMode";
+    ProfileSetting["MENU_VIEW_MODE"] = "preferredMenuViewMode";
+    ProfileSetting["TIME_ZONE"] = "preferredTimeZone";
+    ProfileSetting["FONT_SIZE"] = "preferredFontSize";
+})(ProfileSetting || (ProfileSetting = {}));

package/dist/types/{types/class.d.ts → class.d.ts}

@@ -1,5 +1,5 @@
-import { BodyWorksheet } from '../types/sheet';
-import { EntityMembers, EntityState } from './entity';
+import { BodyWorksheet } from '../types/sheet.js';
+import { EntityMembers, EntityState } from './entity.js';
 export declare enum AssignmentClass {
     NONE = "NONE",
     COURSE = "COURSE",

package/dist/types/class.js

@@ -0,0 +1,7 @@
+export var AssignmentClass;
+(function (AssignmentClass) {
+    AssignmentClass["NONE"] = "NONE";
+    AssignmentClass["COURSE"] = "COURSE";
+    AssignmentClass["WORKSHEET"] = "WORKSHEET";
+    AssignmentClass["CONTEST"] = "CONTEST";
+})(AssignmentClass || (AssignmentClass = {}));

package/dist/types/comments.js

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

package/dist/types/{types/commons.d.ts → commons.d.ts}

@@ -1,4 +1,4 @@
-import { Language } from './prisma';
+import { Language } from './prisma.js';
 export declare enum CodeLanguage {
     C_11 = "c11",
     CPP_11 = "cpp11",

package/dist/types/commons.js

@@ -0,0 +1,69 @@
+export var CodeLanguage;
+(function (CodeLanguage) {
+    CodeLanguage["C_11"] = "c11";
+    CodeLanguage["CPP_11"] = "cpp11";
+    CodeLanguage["CPP_20"] = "cpp20";
+    CodeLanguage["JAVA_21"] = "java21";
+    CodeLanguage["PYTHON_3"] = "python3";
+    CodeLanguage["PYTHON_PYPY_3"] = "pypy3";
+    CodeLanguage["JAVASCRIPT_NODE_JS_22"] = "nodejs22";
+    // DEPRECATED
+    CodeLanguage["PYTHON_2"] = "python2";
+    CodeLanguage["PYTHON_PYPY_2"] = "pypy2";
+    CodeLanguage["ICPC_C"] = "ICPC_C";
+    CodeLanguage["C"] = "C";
+    CodeLanguage["CPP"] = "CPP";
+    CodeLanguage["ICPC_CPP"] = "ICPC_CPP";
+    CodeLanguage["CPP11"] = "CPP11";
+    CodeLanguage["CPP14"] = "CPP14";
+    CodeLanguage["CPP17"] = "CPP17";
+    CodeLanguage["JAVA"] = "JAVA";
+    CodeLanguage["ICPC_PYTHON"] = "ICPC_PYTHON";
+    CodeLanguage["PYTHON"] = "PYTHON";
+    CodeLanguage["PYTHON2"] = "PYTHON2";
+    CodeLanguage["PYTHON3"] = "PYTHON3";
+    CodeLanguage["JAVASCRIPT"] = "JAVASCRIPT";
+    CodeLanguage["TYPESCRIPT"] = "TYPESCRIPT";
+    CodeLanguage["JSX"] = "JSX";
+    CodeLanguage["TSX"] = "TSX";
+    CodeLanguage["MDX"] = "MDX";
+    CodeLanguage["PSEUDOCODE_PSEINT"] = "PSEUDOCODE_PSEINT";
+    CodeLanguage["LATEX"] = "LATEX";
+    CodeLanguage["JSON"] = "JSON";
+    CodeLanguage["HTML"] = "HTML";
+    CodeLanguage["TEXT"] = "TEXT";
+    CodeLanguage["DIFF"] = "DIFF";
+    CodeLanguage["MARKDOWN"] = "MARKDOWN";
+    CodeLanguage["ARDUINO"] = "ARDUINO";
+    CodeLanguage["DOT"] = "DOT";
+    CodeLanguage["MERMAID"] = "MERMAID";
+    CodeLanguage["BASH"] = "BASH";
+})(CodeLanguage || (CodeLanguage = {}));
+export var ScopeData;
+(function (ScopeData) {
+    ScopeData["USER"] = "USER";
+    ScopeData["PROBLEM"] = "PROBLEM";
+    ScopeData["CONTEST"] = "CONTEST";
+    ScopeData["ATTEMPT"] = "ATTEMPT";
+})(ScopeData || (ScopeData = {}));
+export var Status;
+(function (Status) {
+    Status["SUCCESS"] = "SUCCESS";
+    Status["ERROR"] = "ERROR";
+    Status["LOADING"] = "LOADING";
+    Status["NONE"] = "NONE";
+})(Status || (Status = {}));
+export var EntityStatus;
+(function (EntityStatus) {
+    EntityStatus["PUBLIC"] = "PUBLIC";
+    EntityStatus["RESERVED"] = "RESERVED";
+    EntityStatus["PRIVATE"] = "PRIVATE";
+    EntityStatus["ARCHIVED"] = "ARCHIVED";
+})(EntityStatus || (EntityStatus = {}));
+export var EntityAccess;
+(function (EntityAccess) {
+    EntityAccess["PRIVATE"] = "PRIVATE";
+    EntityAccess["RESTRICTED"] = "RESTRICTED";
+    EntityAccess["PUBLIC"] = "PUBLIC";
+    EntityAccess["EXPOSED"] = "EXPOSED";
+})(EntityAccess || (EntityAccess = {}));

package/dist/types/{types/contest.d.ts → contest.d.ts}

@@ -1,7 +1,7 @@
-import { CodeLanguage } from './commons';
-import { EntityMembers } from './entity';
-import { Judge } from './judge';
-import { UserBasicInfo } from './users';
+import { CodeLanguage } from './commons.js';
+import { EntityMembers } from './entity.js';
+import { Judge } from './judge.js';
+import { UserBasicInfo } from './users.js';
 export declare enum ContestStatus {
     PUBLIC = "PUBLIC",
     RESERVED = "RESERVED",

package/dist/types/contest.js

@@ -0,0 +1,27 @@
+export var ContestStatus;
+(function (ContestStatus) {
+    ContestStatus["PUBLIC"] = "PUBLIC";
+    ContestStatus["RESERVED"] = "RESERVED";
+    ContestStatus["ARCHIVED"] = "ARCHIVED";
+})(ContestStatus || (ContestStatus = {}));
+export var ContestTimeStatus;
+(function (ContestTimeStatus) {
+    ContestTimeStatus["UPCOMING"] = "upcoming";
+    ContestTimeStatus["LIVE"] = "live";
+    ContestTimeStatus["PAST"] = "past";
+})(ContestTimeStatus || (ContestTimeStatus = {}));
+export var ContestProblemPrerequisiteType;
+(function (ContestProblemPrerequisiteType) {
+    ContestProblemPrerequisiteType["INDIVIDUALLY"] = "INDIVIDUALLY";
+    ContestProblemPrerequisiteType["CONTEST"] = "CONTEST";
+})(ContestProblemPrerequisiteType || (ContestProblemPrerequisiteType = {}));
+export var ContestEventAction;
+(function (ContestEventAction) {
+    ContestEventAction["DATA_UPDATE"] = "DATA_UPDATE";
+    ContestEventAction["SCOREBOARD_RECALCULATE"] = "SCOREBOARD_RECALCULATE";
+    ContestEventAction["SCOREBOARD_UNLOCK"] = "SCOREBOARD_UNLOCK";
+    ContestEventAction["SCOREBOARD_LOCK"] = "SCOREBOARD_LOCK";
+    ContestEventAction["ENABLE_UPSOLVING"] = "ENABLE_UPSOLVING";
+    ContestEventAction["DISABLE_UPSOLVING"] = "DISABLE_UPSOLVING";
+    ContestEventAction["PARTICIPANT_JOIN"] = "PARTICIPANT_JOIN";
+})(ContestEventAction || (ContestEventAction = {}));

package/dist/types/{types/course.d.ts → course.d.ts}

@@ -1,4 +1,4 @@
-import { EntityMembers, EntityState } from './entity';
+import { EntityMembers, EntityState } from './entity.js';
 export interface CourseBaseDocument {
     key: string;
     title: string;