@quesmed/types 1.5.9 → 2.0.0

package/dist/mjs/resolvers/query/restricted/todos.d.ts

@@ -0,0 +1,29 @@
+import { Id, IPreBuildTodo, ITodo } from '../../../models';
+import { graphqlNormalize, RestrictedData } from '../../types';
+export interface IPreBuildTodoVar {
+    topics: number[];
+    conceptIds: number[];
+    search: string;
+    source: string;
+    filterOlderCard: boolean;
+}
+export declare type IPreBuildTodoData = RestrictedData<graphqlNormalize & IPreBuildTodo, 'preBuildTodo'>;
+export interface ITodoVar {
+    id: Id;
+}
+export declare type ITodoData = RestrictedData<graphqlNormalize & ITodo, 'todo'>;
+export declare type IDailyFeedVar = null;
+interface IDailyFeedTopicInfo {
+    name: string;
+    topicQuestionCount: number;
+}
+export interface IDailyFeed {
+    topic: IDailyFeedTopicInfo[];
+    totalCard: number;
+    todoId: number;
+    learnCard: number;
+    confidentCard: number;
+    reviewCard: number;
+}
+export declare type IDailyFeedData = RestrictedData<graphqlNormalize & IDailyFeed, 'dailyFeed'>;
+export {};

package/dist/mjs/resolvers/query/restricted/topics.d.ts

@@ -0,0 +1,10 @@
+import { ETopicType, Id, ITopic } from '../../../models';
+import { graphqlNormalize, RestrictedData } from '../../types';
+export interface ITopicVar {
+    id: Id;
+}
+export declare type ITopicData = RestrictedData<graphqlNormalize & ITopic, 'topic'>;
+export interface ITopicsVar {
+    filter: ETopicType;
+}
+export declare type ITopicsData = RestrictedData<(graphqlNormalize & ITopic)[], 'topics'>;

package/dist/mjs/resolvers/query/restricted/university.d.ts

@@ -0,0 +1,15 @@
+import { graphqlNormalize, RestrictedData } from '../../types';
+export interface IUniversityLeaderboardVar {
+    limit: number;
+}
+export interface IUniversitiesRankSpeciality {
+    name: string;
+    speciality: string;
+    rank: number;
+}
+export interface IUniversityLeaderboard {
+    updatedAt: number | Date | null;
+    month: IUniversitiesRankSpeciality[];
+    quarter: IUniversitiesRankSpeciality[];
+}
+export declare type IUniversityLeaderboardData = RestrictedData<graphqlNormalize & IUniversityLeaderboard, 'universityLeaderboard'>;

package/dist/mjs/resolvers/query/restricted/user.d.ts

@@ -0,0 +1,13 @@
+import { IUser } from '../../../models';
+import { graphqlNormalize, RestrictedData } from '../../types';
+export declare type IDashboardUserVar = null;
+export declare type IDashboardUserData = RestrictedData<graphqlNormalize & IUser, 'dashboardUser'>;
+export declare type IUserVar = null;
+export declare type IUserData = RestrictedData<graphqlNormalize & IUser, 'user'>;
+export declare type IDailyProgressVar = null;
+export interface IDailyProgressInfo {
+    totalCount: number;
+    totalTrue: number;
+    dateString: string;
+}
+export declare type IDailyProgressData = RestrictedData<(graphqlNormalize & IDailyProgressInfo)[], 'dailyProgress'>;

package/dist/mjs/resolvers/query/restricted/video.d.ts

@@ -0,0 +1,11 @@
+import { Id, IVideo } from '../../../models';
+import { graphqlNormalize, RestrictedData } from '../../types';
+export interface IVideoVar {
+    id: Id;
+}
+export declare type IVideoData = RestrictedData<graphqlNormalize & IVideo, 'video'>;
+export interface IVideosVar {
+    filter: 'new' | 'popular' | 'personal' | 'live' | 'osce';
+    limit: number;
+}
+export declare type IVideosData = RestrictedData<(graphqlNormalize & IVideo)[], 'videos'>;

package/dist/mjs/resolvers/query/sample.d.ts

@@ -0,0 +1,26 @@
+import { IMarksheet, IOsceMarksheet, ITodo } from '../../models';
+import { graphqlNormalize, RootData } from '../types';
+export declare const SAMPLE_CONTENT: import("@apollo/client").DocumentNode;
+export declare type ISampleContentVar = null;
+interface ISampleContent {
+    marksheets: IMarksheet[];
+    todos: ITodo[];
+    osceMarksheets: IOsceMarksheet[];
+}
+export declare type ISampleContentData = RootData<graphqlNormalize & ISampleContent, 'sampleContent'>;
+export declare const SAMPLE_MARKSHEET: import("@apollo/client").DocumentNode;
+export interface ISampleMarksheetVar {
+    marksheetId: number;
+}
+export declare type ISampleMarksheetData = RootData<graphqlNormalize & IMarksheet, 'sampleMarksheet'>;
+export declare const SAMPLE_TODO: import("@apollo/client").DocumentNode;
+export interface ISampleTodoVar {
+    todoId: number;
+}
+export declare type ISampleTodoData = RootData<graphqlNormalize & ITodo, 'sampleTodo'>;
+export declare const SAMPLE_OSCE_MARKSHEET: import("@apollo/client").DocumentNode;
+export interface ISampleOsceMarksheetVar {
+    osceMarksheetId: number;
+}
+export declare type ISampleOsceMarksheetData = RootData<graphqlNormalize & IOsceMarksheet, 'sampleOsceMarksheet'>;
+export {};

package/dist/mjs/resolvers/query/subscription.d.ts

@@ -0,0 +1,3 @@
+import { ISubscription } from '../../models';
+import { graphqlNormalize, RootData } from '../types';
+export declare type ISubscriptionsData = RootData<(graphqlNormalize & ISubscription)[], 'subscriptions'>;

package/dist/mjs/resolvers/query/university.d.ts

@@ -0,0 +1,6 @@
+import { Id, IUniversity } from '../../models';
+import { graphqlNormalize, RootData } from '../types';
+export interface IUniversitiesVar {
+    id: Id;
+}
+export declare type IUniversitiesData = RootData<graphqlNormalize & IUniversity[], 'universities'>;

package/dist/mjs/resolvers/query/user.d.ts

@@ -0,0 +1,13 @@
+import { RootData } from '../types';
+export interface IUsernameAvailableVar {
+    username: string;
+}
+export declare type IUsernameAvailableData = RootData<boolean, 'usernameAvailable'>;
+export interface IUsernameProvisionedVar {
+    username: string;
+}
+export declare type IUsernameProvisionedData = RootData<boolean, 'usernameProvisioned'>;
+export interface IValidateResetPasswordTokenVar {
+    token: string;
+}
+export declare type IValidateResetPasswordTokenData = RootData<string, 'validateResetPasswordToken'>;

package/dist/mjs/resolvers/query/video.d.ts

@@ -0,0 +1,15 @@
+import { Id, IVideo } from '../../models';
+import { graphqlNormalize, RootData } from '../types';
+export interface IVideosVar {
+    filter: 'new' | 'popular' | 'personal' | 'live';
+    limit: number;
+}
+export declare type IVideosData = RootData<(graphqlNormalize & IVideo)[], 'videos'>;
+export interface IVideoVar {
+    id: Id;
+}
+export declare type IVideoData = RootData<graphqlNormalize & IVideo, 'video'>;
+export interface IZoomSignatureVar {
+    meetingNumber: string;
+}
+export declare type IZoomSignatureData = RootData<graphqlNormalize & string, 'zoomSignature'>;

package/dist/mjs/resolvers/subscription/index.js

@@ -0,0 +1 @@
+export * from './osce';

package/dist/mjs/resolvers/subscription/osce.d.ts

@@ -0,0 +1,66 @@
+import { EClassYearGroup, EOsceMarksheetAction, EOsceRoles, IAccessLevel, IClassYear, Id, IOsceMarksheetTimer, IOsceMarksheetUser, IUser } from '../../models';
+import { RootData } from '../types';
+export declare const OSCE_ROLE_CHANGE_KEY = "OSCE_ROLE_CHANGE";
+export declare const OSCE_MARKSHEET_ACTION_KEY = "OSCE_MARKSHEET_ACTION";
+export declare const OSCE_MARKSHEET_TIMER_KEY = "OSCE_MARKSHEET_TIMER";
+export declare const OSCE_MATCHMAKING_KEY = "OSCE_MATCHMAKING";
+export declare const OSCE_MATCHMAKING_USERS_KEY = "OSCE_MATCHMAKING_USERS";
+export interface IOsceGroupMember {
+    role: EOsceRoles;
+    user: IUser | null;
+}
+export interface IOsceGroup {
+    osceMarksheetId: Id;
+    agoraId: string;
+    members: IOsceMarksheetUser[];
+    users: IUser[];
+}
+export declare const OsceGroupInit: (osceMarksheetId: number) => IOsceMarksheetUser[];
+export declare const OSCE_ROLE_CHANGE: import("@apollo/client").DocumentNode;
+export interface IOsceRoleChangedVar {
+    osceMarksheetId: Id;
+}
+export declare type IOsceRoleChangedData = RootData<IOsceGroup, 'osceRoleChange'>;
+export declare const OSCE_MARKSHEET_ACTION: import("@apollo/client").DocumentNode;
+export interface IOsceMarksheetActionVar {
+    osceMarksheetId: Id;
+}
+export interface IOsceMarksheetAction {
+    osceMarksheetId: Id;
+    agoraId: string;
+    userId: Id;
+    user: IUser;
+    startedAt: Date | null;
+    endedAt: Date | null;
+    action: EOsceMarksheetAction;
+}
+export declare type IOsceMarksheetActionData = RootData<IOsceMarksheetAction, 'osceMarksheetAction'>;
+export declare const OSCE_MATCHMAKING: import("@apollo/client").DocumentNode;
+export interface IOsceMatchmakingAction {
+    osceMarksheetId: Id;
+    agoraId: string;
+    matchedUsers: number;
+    userId: Id;
+    classYear: IClassYear;
+    classYearGroup: EClassYearGroup;
+    accessLevel: IAccessLevel;
+    lastSyncAt: number;
+    startedAt: number;
+    grouped: boolean;
+    completed: boolean;
+}
+export interface IOsceMatchmakingVar {
+    userId: Id;
+}
+export declare type IOsceMatchmakingData = RootData<IOsceMatchmakingAction, 'osceMatchmaking'>;
+export declare const OSCE_MATCHMAKING_USERS: import("@apollo/client").DocumentNode;
+export declare type IOsceMatchmakingUsersVar = null;
+export declare type IOsceMatchmakingUsersData = RootData<[
+    number,
+    number
+], 'osceMatchmakingUsers'>;
+export declare const OSCE_MARKSHEET_TIMER: import("@apollo/client").DocumentNode;
+export interface IOsceMarksheetTimerVar {
+    osceMarksheetId: number;
+}
+export declare type IOsceMarksheetTimerData = RootData<IOsceMarksheetTimer, 'osceMarksheetTimer'>;

package/dist/mjs/resolvers/types.d.ts

@@ -0,0 +1,10 @@
+export interface graphqlNormalize {
+    __typename?: string;
+}
+export declare type RestrictedData<T, K extends keyof any> = {
+    restricted: Record<K, T>;
+};
+export declare type AdminData<T, K extends keyof any> = {
+    admin: Record<K, T>;
+};
+export declare type RootData<T, K extends keyof any> = Record<K, T>;

package/dist/mjs/resolvers/types.js

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

package/dist/mjs/types.d.ts

@@ -0,0 +1 @@
+declare module 'fmt-obj';

package/dist/mjs/utils/commonFunctions.d.ts

@@ -0,0 +1,9 @@
+import { IMarksheetMark, IPrescribeAnswer, IPrescribeMark } from '../models';
+export declare function mapPrescribeMarkToAnswer(obj: IPrescribeMark): IPrescribeAnswer;
+export declare function formatPrescribeAnswer(baseAnswer: IPrescribeAnswer): IPrescribeAnswer;
+export interface ICorrectMarkData {
+    correct: boolean;
+    incorrect: boolean;
+    correctIndex: number;
+}
+export declare function correctMark(mark: IMarksheetMark): ICorrectMarkData;

package/{utils/commonFunctions.mjs → dist/mjs/utils/commonFunctions.js}

@@ -31,7 +31,27 @@ export function mapPrescribeMarkToAnswer(obj) {
     };
 }
 export function formatPrescribeAnswer(baseAnswer) {
-    const obj = Object.assign(Object.assign({}, baseAnswer), { drug: Object.assign({}, baseAnswer.drug), dose: Object.assign({}, baseAnswer.dose), units: Object.assign({}, baseAnswer.units), route: Object.assign({}, baseAnswer.route), frequency: Object.assign({}, baseAnswer.frequency), duration: Object.assign({}, baseAnswer.duration) });
+    const obj = {
+        ...baseAnswer,
+        drug: {
+            ...baseAnswer.drug,
+        },
+        dose: {
+            ...baseAnswer.dose,
+        },
+        units: {
+            ...baseAnswer.units,
+        },
+        route: {
+            ...baseAnswer.route,
+        },
+        frequency: {
+            ...baseAnswer.frequency,
+        },
+        duration: {
+            ...baseAnswer.duration,
+        },
+    };
     obj.drug.value = obj.drug.value.toLowerCase().replace(/\s/g, '');
     obj.route.value = obj.route.value
         .toLowerCase()

package/dist/mjs/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './commonFunctions';
+export * from './lightgallery';
+export * from './offlineLink';
+export * from './random';
+export * from './webSocketLink';
+export * from './wordsToNumber';
+import uuid from './uuid4';
+export declare const Uuid4: typeof uuid;
+export declare function printDuration(duration: number): string;

package/dist/mjs/utils/lightgallery.d.ts

@@ -0,0 +1,9 @@
+import { Platform } from 'react-native';
+import { CacheManager } from 'react-native-expo-image-cache';
+import { IOsceMarksheet, IOsceStation } from '../models';
+export interface ILightGalleryCache {
+    CacheManager: typeof CacheManager;
+    Platform: typeof Platform;
+}
+export declare function lightgalleryOsceResolve(data: IOsceStation, cache?: ILightGalleryCache): Promise<IOsceStation>;
+export declare function lightgalleryOsceResolve(data: IOsceMarksheet, cache?: ILightGalleryCache): Promise<IOsceMarksheet>;

package/dist/mjs/utils/lightgallery.js

@@ -0,0 +1,84 @@
+const lightgalleryRegex = /\[lightgallery\]/;
+function isOsceMarksheet(data) {
+    return 'osceStationId' in data;
+}
+export async function lightgalleryOsceResolve(data, cache) {
+    let station;
+    if (isOsceMarksheet(data)) {
+        if (!data.osceStation) {
+            throw new Error('OsceStation not found on OsceMarksheet');
+        }
+        station = data.osceStation;
+    }
+    else {
+        station = data;
+    }
+    const upOsceStation = {
+        candidateBrief: station.candidateBrief,
+        actorBrief: station.actorBrief,
+        examinerBrief: station.examinerBrief,
+        explanation: station.explanation,
+    };
+    if (station.candidatePictures && station.candidatePictures.length > 0) {
+        upOsceStation.candidateBrief = await lightgalleryMutation(upOsceStation.candidateBrief, station.candidatePictures, cache);
+    }
+    if (station.actorPictures && station.actorPictures.length > 0) {
+        upOsceStation.actorBrief = await lightgalleryMutation(upOsceStation.actorBrief, station.actorPictures, cache);
+    }
+    if (station.examinerPictures && station.examinerPictures.length > 0) {
+        upOsceStation.examinerBrief = await lightgalleryMutation(upOsceStation.examinerBrief, station.examinerPictures, cache);
+    }
+    if (station.walkthroughPictures && station.walkthroughPictures.length > 0) {
+        upOsceStation.explanation = await lightgalleryMutation(upOsceStation.explanation, station.walkthroughPictures, cache);
+    }
+    if (isOsceMarksheet(data)) {
+        return {
+            ...data,
+            osceStation: {
+                ...data.osceStation,
+                ...upOsceStation,
+            },
+        };
+    }
+    else {
+        return {
+            ...data,
+            ...upOsceStation,
+        };
+    }
+}
+const lightgalleryMutation = async (text, pictures, cache) => {
+    if (pictures.length === 0) {
+        return text;
+    }
+    const picturesHTML = [];
+    for (const picture of pictures) {
+        const pic = picture.path;
+        const uri = `https://app.quesmed.com/${pic}`;
+        let file = '';
+        if (cache) {
+            try {
+                const localPath = await cache.CacheManager.get(uri, {}).getPath();
+                if (localPath) {
+                    file =
+                        cache.Platform.OS === 'ios'
+                            ? localPath.replace('file://', '')
+                            : localPath;
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        if (picture.caption?.length > 0) {
+            picturesHTML.push(`![${file}](${uri} "${picture.caption}")`);
+        }
+        picturesHTML.push(`![${file}](${uri})`);
+    }
+    if (lightgalleryRegex.test(text)) {
+        return text.replace(lightgalleryRegex, picturesHTML[0]);
+    }
+    else {
+        return text + '\n\n' + picturesHTML[0] + '\n';
+    }
+};

package/dist/mjs/utils/offlineLink.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { ApolloClient, ApolloLink, MutationOptions, NextLink, Observable, Operation } from '@apollo/client';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import Localforage from 'localforage';
+export interface IOfflineLinkParam {
+    storage: typeof Localforage | typeof AsyncStorage;
+    retryInterval?: number;
+    sequential?: boolean;
+    retryOnServerError?: boolean;
+}
+export declare class OfflineLink extends ApolloLink {
+    storage: typeof Localforage | typeof AsyncStorage;
+    retryInterval: number;
+    sequential: boolean;
+    retryOnServerError: boolean;
+    queue: Map<string, MutationOptions>;
+    prefix: string;
+    client?: ApolloClient<any>;
+    timeoutId?: NodeJS.Timeout;
+    /**
+     * storage
+     * Provider that will persist the mutation queue. This can be any AsyncStorage compatible storage instance.
+     *
+     * retryInterval
+     * Milliseconds between attempts to retry failed mutations. Defaults to 0, which disables automatic retry.
+     *
+     * sequential
+     * Indicates if the attempts should be retried in order. Defaults to false which retries all failed mutations in parallel.
+     *
+     * retryOnServerError
+     * Indicates if mutations should be reattempted if there are server side errors, useful to retry mutations on session expiration. Defaults to false.
+     */
+    constructor({ storage, retryInterval, sequential, retryOnServerError, }: IOfflineLinkParam);
+    request(operation: Operation, forward: NextLink): Observable<any>;
+    /**
+     * Obtains the queue of mutations that must be sent to the server.
+     * These are kept in a Map to preserve the order of the mutations in the queue.
+     */
+    getQueue(): Promise<Map<any, any>>;
+    /**
+     * Persist the queue so mutations can be retried at a later point in time.
+     */
+    private saveQueue;
+    /**
+     * Add a mutation attempt to the queue so that it can be retried at a later point in time.
+     */
+    private add;
+    /**
+     * Remove a mutation attempt from the queue.
+     */
+    private remove;
+    /**
+     * Takes the mutations in the queue and try to send them to the server again.
+     */
+    sync(): Promise<void>;
+    /**
+     * Runs sync() after the retryInterval
+     */
+    private delayedSync;
+    /**
+     * Configure the link to use Apollo Client and immediately try to sync the queue (if there's anything there).
+     */
+    setup(client: ApolloClient<any>): Promise<void>;
+}