@quesmed/types-rn 2.0.4

package/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/utils/lightgallery.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lightgalleryOsceResolve = void 0;
+const lightgalleryRegex = /\[lightgallery\]/;
+function isOsceMarksheet(data) {
+    return 'osceStationId' in data;
+}
+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,
+        };
+    }
+}
+exports.lightgalleryOsceResolve = lightgalleryOsceResolve;
+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/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>;
+}

package/utils/offlineLink.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfflineLink = void 0;
+const client_1 = require("@apollo/client");
+const uuid4_1 = __importDefault(require("./uuid4"));
+class OfflineLink extends client_1.ApolloLink {
+    /**
+     * 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 = 0, sequential = false, retryOnServerError = false, }) {
+        super();
+        this.queue = new Map();
+        this.prefix = 'offlineLink:';
+        if (!storage) {
+            throw new Error('Storage is required, it can be an AsyncStorage compatible storage instance.');
+        }
+        this.storage = storage;
+        this.sequential = sequential;
+        this.retryInterval = retryInterval;
+        this.retryOnServerError = retryOnServerError;
+    }
+    request(operation, forward) {
+        const context = operation.getContext();
+        const { query, variables } = operation || {};
+        if (!context.optimisticResponse) {
+            // If the mutation does not have an optimisticResponse then we can't defer it
+            return forward(operation);
+        }
+        return new client_1.Observable((observer) => {
+            const mutationId = uuid4_1.default.asBase64();
+            this.add({
+                mutation: query,
+                variables,
+                optimisticResponse: context.optimisticResponse,
+            }, mutationId);
+            const subscription = forward(operation).subscribe({
+                next: (result) => {
+                    this.remove(mutationId);
+                    observer.next(result);
+                },
+                error: () => {
+                    // Mutation failed so we try again after a certain amount of time.
+                    this.delayedSync();
+                    // Resolve the mutation with the optimistic response so the UI can be updated
+                    observer.next({
+                        data: context.optimisticResponse,
+                        dataPresent: true,
+                        errors: [],
+                    });
+                    // Say we're all done so the UI is re-rendered.
+                    observer.complete();
+                },
+                complete: () => observer.complete(),
+            });
+            return () => {
+                subscription.unsubscribe();
+            };
+        });
+    }
+    /**
+     * 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.
+     */
+    async getQueue() {
+        const map = new Map();
+        try {
+            const storedMutations = await this.storage.getItem(this.prefix + 'Mutations');
+            if (!storedMutations) {
+                return map;
+            }
+            const mutationIds = storedMutations.split(',');
+            for (const mutationId of mutationIds) {
+                const storedMutation = await this.storage.getItem(this.prefix + mutationId);
+                if (!storedMutation) {
+                    continue;
+                }
+                map.set(mutationId, JSON.parse(storedMutation));
+            }
+            return map;
+        }
+        catch (e) {
+            console.error(e);
+            return map;
+        }
+    }
+    /**
+     * Persist the queue so mutations can be retried at a later point in time.
+     */
+    async saveQueue(mutationId, mutation) {
+        try {
+            if (mutationId && mutation) {
+                await this.storage.setItem(this.prefix + mutationId, JSON.stringify(mutation));
+            }
+            await this.storage.setItem(this.prefix + 'Mutations', [...this.queue.keys()].join());
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    /**
+     * Add a mutation attempt to the queue so that it can be retried at a later point in time.
+     */
+    async add(item, mutationId) {
+        // We give the mutation attempt a random id so that it is easy to remove when needed (in sync loop)
+        if (!mutationId) {
+            mutationId = uuid4_1.default.asBase64();
+        }
+        this.queue.set(mutationId, item);
+        await this.saveQueue(mutationId, item);
+        return mutationId;
+    }
+    /**
+     * Remove a mutation attempt from the queue.
+     */
+    async remove(mutationId) {
+        this.queue.delete(mutationId);
+        await this.storage.removeItem(this.prefix + mutationId);
+        await this.saveQueue();
+    }
+    /**
+     * Takes the mutations in the queue and try to send them to the server again.
+     */
+    async sync() {
+        if (!this.client) {
+            throw new Error('Offline Link not setup with ApolloClient');
+        }
+        if (this.queue.size === 0) {
+            return;
+        }
+        const attempts = Array.from(this.queue);
+        if (this.sequential) {
+            for (const [mutationId, attempt] of attempts) {
+                let serverProcessed = false;
+                try {
+                    await this.client.mutate({
+                        ...attempt,
+                        optimisticResponse: undefined,
+                    });
+                    serverProcessed = true;
+                }
+                catch (e) {
+                    const err = e;
+                    const networkError = err.networkError;
+                    if (!this.retryOnServerError && networkError?.response) {
+                        // There are GraphQL errors, which means the server processed the request so we can remove the mutation from the queue
+                        serverProcessed = true;
+                    }
+                }
+                if (serverProcessed) {
+                    try {
+                        await this.remove(mutationId);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+            }
+        }
+        else {
+            await Promise.all(attempts.map(async ([mutationId, attempt]) => {
+                let serverProcessed = false;
+                try {
+                    await this.client?.mutate({
+                        ...attempt,
+                        optimisticResponse: undefined,
+                    });
+                    serverProcessed = true;
+                }
+                catch (e) {
+                    const err = e;
+                    const networkError = err.networkError;
+                    if (!this.retryOnServerError && networkError?.response) {
+                        serverProcessed = true;
+                    }
+                }
+                if (serverProcessed) {
+                    await this.remove(mutationId);
+                }
+            }));
+        }
+        // Remaining mutations in the queue are persisted
+        await this.saveQueue();
+        if (this.queue.size !== 0 || this.retryInterval !== 0) {
+            this.delayedSync();
+        }
+    }
+    /**
+     * Runs sync() after the retryInterval
+     */
+    delayedSync() {
+        if (this.retryInterval === 0) {
+            return;
+        }
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+        }
+        this.timeoutId = setTimeout(() => this.sync, this.retryInterval);
+    }
+    /**
+     * Configure the link to use Apollo Client and immediately try to sync the queue (if there's anything there).
+     */
+    async setup(client) {
+        this.client = client;
+        this.queue = await this.getQueue();
+        await this.sync();
+    }
+}
+exports.OfflineLink = OfflineLink;

package/utils/random.d.ts

@@ -0,0 +1 @@
+export declare function getRandom<T>(arr: T[], n?: number): T[];

package/utils/random.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandom = void 0;
+function getRandom(arr, n) {
+    if (n === undefined || n === null) {
+        n = arr.length;
+    }
+    const result = new Array(n);
+    let len = arr.length;
+    const taken = new Array(len);
+    if (n > len)
+        throw new RangeError('getRandom: more elements taken than available');
+    while (n--) {
+        const x = Math.floor(Math.random() * len);
+        result[n] = arr[x in taken ? taken[x] : x];
+        taken[x] = --len in taken ? taken[len] : len;
+    }
+    return result;
+}
+exports.getRandom = getRandom;

package/utils/uuid4.d.ts

@@ -0,0 +1,107 @@
+declare class Uuid4 {
+    /**
+     * Generate a custom base 64 encoded UUID v4 (random).
+     *
+     * @param {Uint8Array} [data] Should normally be `undefined` to create a
+     *                            truly random v4 UUID.
+     * @returns {string} Returns a custom base 64 encoded UUID v4.
+     */
+    static asBase64(data?: Uint8Array): string;
+    /**
+     * Generate a hexadecimal encoded UUID v4 (random).
+     *
+     * @param {Uint8Array} [data] Should normally be `undefined` to create a
+     *                            truly random v4 UUID.
+     * @returns {string} Returns a hexadecimal encoded UUID v4.
+     */
+    static asHexString(data?: Uint8Array): string;
+    /**
+     * Generate a standard UUID v4 (random).
+     *
+     * @param {Uint8Array} [data] Should normally be `undefined` to create a
+     *                            truly random v4 UUID.
+     * @returns {string} Returns a standard UUID v4.
+     */
+    static asUuid(data?: Uint8Array): string;
+    /**
+     * Convert from a base 64 encoded to a hexadecimal encoded UUID.
+     *
+     * NOTE: This method does not verify input is valid UUID.
+     *
+     * @param {string} data A base 64 encoded UUID.
+     * @returns {string} Returns a hexadecimal encoded UUID.
+     */
+    static fromBase64ToHexString(data: string): string;
+    /**
+     * Convert from a base 64 encoded to a standard UUID.
+     *
+     * NOTE: This method does not verify input is valid UUID.
+     *
+     * @param {string} data The base 64 encoded UUID.
+     * @returns {string} Returns a standard UUID.
+     */
+    static fromBase64ToUuid(data: string): string;
+    /**
+     * Convert from a hexadecimal encoded to a base 64 encoded UUID.
+     *
+     * NOTE: This method does not verify input is valid UUID.
+     *
+     * @param {string} data The hexadecimal encoded UUID.
+     * @returns {string} Returns base 64 encoded UUID.
+     */
+    static fromHexStringToBase64(data: string): string;
+    /**
+     * Convert from a hexadecimal encoded to a standard UUID.
+     *
+     * NOTE: This method does not verify input is valid UUID.
+     *
+     * @param {string} data The hexadecimal encoded UUID.
+     * @returns {string} Returns a standard UUID.
+     */
+    static fromHexStringToUuid(data: string): string;
+    /**
+     * Convert from a standard UUID to a base 64 encoded UUID.
+     *
+     * NOTE: This method does not verify input is valid UUID.
+     *
+     * @param {string} data The standard UUID.
+     * @returns {string} Returns base 64 encoded UUID.
+     */
+    static fromUuidToBase64(data: string): string;
+    /**
+     * Convert from a standard UUID to a hexadecimal encoded UUID.
+     *
+     * NOTE: This method does not verify input is valid UUID.
+     *
+     * @param {string} data The standard UUID.
+     * @returns {string} Returns a hexadecimal encoded UUID.
+     */
+    static fromUuidToHexString(data: string): string;
+    get [Symbol.toStringTag](): string;
+    /**
+     * Helper method for the common parts of creating new UUID encoded as a binary string.
+     *
+     * @param {Uint8Array} [data] Should normally be `undefined` to create a
+     *                            truly random v4 UUID.
+     * @returns {string} Returns an UUID encoded as a binary string.
+     * @private
+     */
+    protected static _asBinString(data?: Uint8Array): string;
+    /**
+     * Used to paste over differences in browser vs node secure random number generation.
+     *
+     * @returns {Uint8Array} Returns a new random number filled Uint8Array.
+     * @private
+     */
+    protected static _getRandomArray(): Uint8Array;
+    /**
+     * Used in mapping from binary to base 64 during encoding.
+     *
+     * @type {object}
+     * @private
+     */
+    protected static _base64: {
+        [key: string]: string;
+    };
+}
+export default Uuid4;