@quesmed/types 1.3.17 → 1.3.18

package/resolvers/query/video.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/resolvers/subscription/index.cjs

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./osce"), exports);

package/resolvers/subscription/osce.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsceGroupInit = exports.OSCE_MATCHMAKING_USERS = exports.OSCE_MATCHMAKING = exports.OSCE_MARKSHEET_ACTION = exports.ROLE_CHANGED = void 0;
+const models_1 = require("../../models");
+exports.ROLE_CHANGED = 'ROLE_CHANGED';
+exports.OSCE_MARKSHEET_ACTION = 'OSCE_MARKSHEET_ACTION';
+exports.OSCE_MATCHMAKING = 'OSCE_MATCHMAKING';
+exports.OSCE_MATCHMAKING_USERS = 'OSCE_MATCHMAKING_USERS';
+const OsceGroupInit = (osceMarksheetId) => [
+    {
+        id: null,
+        createdAt: null,
+        osceMarksheetId,
+        userId: null,
+        user: null,
+        role: models_1.EOsceRoles.CANDIDATE,
+    },
+    {
+        id: null,
+        createdAt: null,
+        osceMarksheetId,
+        userId: null,
+        user: null,
+        role: models_1.EOsceRoles.EXAMINER,
+    },
+    {
+        id: null,
+        createdAt: null,
+        osceMarksheetId,
+        userId: null,
+        user: null,
+        role: models_1.EOsceRoles.ACTOR,
+    },
+    {
+        id: null,
+        createdAt: null,
+        osceMarksheetId,
+        userId: null,
+        user: null,
+        role: models_1.EOsceRoles.OBSERVER,
+    },
+];
+exports.OsceGroupInit = OsceGroupInit;

package/utils/commonFunctions.cjs

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.correctMark = exports.formatPrescribeAnswer = exports.mapPrescribeMarkToAnswer = void 0;
+const models_1 = require("../models");
+const wordsToNumber_1 = require("./wordsToNumber");
+const floatRegex = /([0-9]*[.])?[0-9]+/gm;
+const ACCEPTED_FREQ = ['stat', 'od', 'bd', 'tds', 'qds'];
+function mapPrescribeMarkToAnswer(obj) {
+    return {
+        drug: {
+            value: obj.drug,
+            display: false,
+        },
+        dose: {
+            value: parseFloat(obj.dose),
+            display: false,
+        },
+        units: {
+            value: obj.units,
+            display: false,
+        },
+        route: {
+            value: obj.route,
+            display: false,
+        },
+        frequency: {
+            value: obj.frequency,
+            display: false,
+        },
+        duration: {
+            value: obj.duration,
+            display: false,
+        },
+    };
+}
+exports.mapPrescribeMarkToAnswer = mapPrescribeMarkToAnswer;
+function formatPrescribeAnswer(obj) {
+    obj.drug.value = obj.drug.value.toLowerCase().replace(/\s/g, '');
+    obj.route.value = obj.route.value.toLowerCase().replace(/\s/g, '');
+    if (obj.route.value === 'oral') {
+        obj.route.value = 'po';
+    }
+    else if (obj.route.value.includes('intravenous')) {
+        obj.route.value = 'iv';
+    }
+    else if (obj.route.value.includes('intramuscular')) {
+        obj.route.value = 'im';
+    }
+    else if (obj.route.value.includes('subcutaneous')) {
+        obj.route.value = 'sc';
+    }
+    else if (obj.route.value.includes('inhale')) {
+        obj.route.value = 'inh';
+    }
+    else if (obj.route.value.includes('nebuli')) {
+        obj.route.value = 'neb';
+    }
+    else if (obj.route.value.includes('topical')) {
+        obj.route.value = 'top';
+    }
+    obj.units.value = obj.units.value.toLowerCase().replace(/\s/g, '');
+    if (obj.units.value === 'milligram' || obj.units.value === 'milligrams') {
+        obj.units.value = 'mg';
+    }
+    else if (obj.units.value === 'microgram' || obj.units.value === 'micrograms') {
+        obj.units.value = 'mcg';
+    }
+    else if (obj.units.value === 'gram' || obj.units.value === 'grams') {
+        obj.units.value = 'g';
+    }
+    else if (obj.units.value === 'unit') {
+        obj.units.value = 'units';
+    }
+    let m;
+    const durationMatches = new Set();
+    while ((m = floatRegex.exec(obj.duration.value)) !== null) {
+        if (m.index === floatRegex.lastIndex) {
+            floatRegex.lastIndex++;
+        }
+        m.forEach((match) => durationMatches.add(match));
+    }
+    const durationWords = (0, wordsToNumber_1.wordsToNumber)(obj.duration.value, false);
+    if (durationWords !== 0) {
+        durationMatches.add(durationWords.toString());
+    }
+    obj.duration.value = [...durationMatches].filter((x) => !!x).join(',');
+    const orgFrequencyValue = obj.frequency.value.toLowerCase();
+    obj.frequency.value = orgFrequencyValue.replace(/\s/g, '');
+    const frequencyIncHourly = obj.frequency.value.includes('hour');
+    const hourlyFreqInt = parseInt(obj.frequency.value);
+    if (obj.frequency.value === 'once-off') {
+        obj.frequency.value = 'stat';
+    }
+    else if (obj.frequency.value.includes('once') || (frequencyIncHourly && hourlyFreqInt === 24)) {
+        obj.frequency.value = 'od';
+    }
+    else if (obj.frequency.value.includes('nightly') || obj.frequency.value === 'on') {
+        obj.frequency.value = 'od';
+    }
+    else if (obj.frequency.value.includes('twice') ||
+        (frequencyIncHourly && hourlyFreqInt === 12)) {
+        obj.frequency.value = 'bd';
+    }
+    else if (obj.frequency.value.includes('trice') || (frequencyIncHourly && hourlyFreqInt === 8)) {
+        obj.frequency.value = 'tds';
+    }
+    else if (frequencyIncHourly && hourlyFreqInt === 6) {
+        obj.frequency.value = 'qds';
+    }
+    else if (!ACCEPTED_FREQ.includes(obj.frequency.value)) {
+        obj.frequency.value = (0, wordsToNumber_1.wordsToNumber)(orgFrequencyValue, true).toString();
+    }
+    return obj;
+}
+exports.formatPrescribeAnswer = formatPrescribeAnswer;
+const answerRegex = /answer/gi;
+function correctMark(mark) {
+    const data = {
+        correct: false,
+        incorrect: false,
+        correctIndex: -1,
+    };
+    if (!mark || !mark.mark) {
+        return data;
+    }
+    try {
+        const qKeys = Object.keys(mark.question);
+        const answerKey = qKeys.find((k) => answerRegex.exec(k)) || 'answer';
+        const answer = mark.question[answerKey];
+        const flatAnswer = answer[0];
+        const flatAttempt = mark.mark[0];
+        if (models_1.EQuestionType.SINGLE_BEST_ANSWER === mark.question.typeId) {
+            const answer = flatAnswer;
+            const attempt = flatAttempt;
+            if (answer === attempt) {
+                data.correct = true;
+            }
+            else {
+                data.incorrect = true;
+            }
+        }
+        else if (models_1.EQuestionType.QUESTION_ANSWER === mark.question.typeId) {
+            const answer = flatAnswer.dose.toLowerCase().replace(/\s/g, '');
+            let attempt = '';
+            if (flatAttempt) {
+                attempt = flatAttempt.toLowerCase().replace(/\s/g, '');
+            }
+            if (answer === attempt) {
+                data.correct = true;
+            }
+            else {
+                data.incorrect = true;
+            }
+        }
+        else if (models_1.EQuestionType.MULTIPLE_ANSWERS === mark.question.typeId) {
+            const [answerA, answerB] = answer.map((x) => x.sort());
+            let [attemptA, attemptB] = [[], []];
+            if (Array.isArray(mark.mark) &&
+                mark.mark.length === 2 &&
+                Array.isArray(mark.mark[0]) &&
+                Array.isArray(mark.mark[1])) {
+                [attemptA, attemptB] = mark.mark.map((x) => x.sort());
+            }
+            if (answerA.length !== attemptA.length || answerB.length !== attemptB.length) {
+                data.incorrect = true;
+            }
+            else if (attemptA.every((x, i) => x === answerA[i]) &&
+                attemptB.every((x, i) => x === answerB[i])) {
+                data.correct = true;
+            }
+            else {
+                data.incorrect = true;
+            }
+        }
+        else if (models_1.EQuestionType.PRESCRIPTION_ANSWER === mark.question.typeId) {
+            const answers = answer.map(formatPrescribeAnswer);
+            let attempt = formatPrescribeAnswer(mapPrescribeMarkToAnswer({
+                drug: '',
+                dose: -1,
+                units: '',
+                route: '',
+                frequency: '',
+                duration: '',
+            }));
+            if (typeof flatAttempt === 'object' && Object.keys(flatAttempt).length === 6) {
+                attempt = formatPrescribeAnswer(mapPrescribeMarkToAnswer(flatAttempt));
+            }
+            let foundCorrect = false;
+            let index = 0;
+            for (const answer of answers) {
+                const doseCorrect = answer.dose.display || answer.dose.value === attempt.dose.value;
+                const drugCorrect = answer.drug.display || answer.drug.value === attempt.drug.value;
+                const durationCorrect = answer.duration.display ||
+                    answer.duration.value.split(',').includes(attempt.duration.value);
+                const frequencyCorrect = answer.frequency.display || answer.frequency.value === attempt.frequency.value;
+                const routeCorrect = answer.route.display || answer.route.value === attempt.route.value;
+                const unitsCorrect = answer.units.display || answer.units.value === attempt.units.value;
+                if (doseCorrect &&
+                    drugCorrect &&
+                    durationCorrect &&
+                    frequencyCorrect &&
+                    routeCorrect &&
+                    unitsCorrect) {
+                    foundCorrect = true;
+                    break;
+                }
+                index++;
+            }
+            if (foundCorrect) {
+                data.correct = true;
+                data.correctIndex = index;
+            }
+            else {
+                data.incorrect = true;
+            }
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return data;
+}
+exports.correctMark = correctMark;

package/utils/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./commonFunctions"), exports);
+__exportStar(require("./lightgallery"), exports);
+__exportStar(require("./offlineLink"), exports);
+__exportStar(require("./uuid4"), exports);
+__exportStar(require("./wordsToNumber"), exports);

package/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './commonFunctions';
+export * from './lightgallery';
+export * from './offlineLink';
+export * from './uuid4';
+export * from './wordsToNumber';

package/utils/index.js

@@ -0,0 +1,5 @@
+export * from './commonFunctions';
+export * from './lightgallery';
+export * from './offlineLink';
+export * from './uuid4';
+export * from './wordsToNumber';

package/utils/lightgallery.cjs

@@ -0,0 +1,91 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lightgalleryOsceResolve = void 0;
+const lightgalleryRegex = /\[lightgallery\]/;
+function isOsceMarksheet(data) {
+    return 'osceStationId' in data;
+}
+function lightgalleryOsceResolve(data, cache) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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 = yield lightgalleryMutation(upOsceStation.candidateBrief, station.candidatePictures, cache);
+        }
+        if (station.actorPictures && station.actorPictures.length > 0) {
+            upOsceStation.actorBrief = yield lightgalleryMutation(upOsceStation.actorBrief, station.actorPictures, cache);
+        }
+        if (station.examinerPictures && station.examinerPictures.length > 0) {
+            upOsceStation.examinerBrief = yield lightgalleryMutation(upOsceStation.examinerBrief, station.examinerPictures, cache);
+        }
+        if (station.walkthroughPictures && station.walkthroughPictures.length > 0) {
+            upOsceStation.explanation = yield lightgalleryMutation(upOsceStation.explanation, station.walkthroughPictures, cache);
+        }
+        if (isOsceMarksheet(data)) {
+            return Object.assign(Object.assign({}, data), { osceStation: Object.assign(Object.assign({}, data.osceStation), upOsceStation) });
+        }
+        else {
+            return Object.assign(Object.assign({}, data), upOsceStation);
+        }
+    });
+}
+exports.lightgalleryOsceResolve = lightgalleryOsceResolve;
+const lightgalleryMutation = (text, pictures, cache) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    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 = yield cache.CacheManager.get(uri, {}).getPath();
+                if (localPath) {
+                    file =
+                        cache.Platform.OS === 'ios'
+                            ? localPath.replace('file://', '')
+                            : localPath;
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        if (((_a = picture.caption) === null || _a === void 0 ? void 0 : _a.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.cjs

@@ -0,0 +1,237 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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) => __awaiter(this, void 0, void 0, function* () {
+                    yield 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.
+     */
+    getQueue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const map = new Map();
+            try {
+                const storedMutations = yield this.storage.getItem(this.prefix + 'Mutations');
+                if (!storedMutations) {
+                    return map;
+                }
+                const mutationIds = storedMutations.split(',');
+                for (const mutationId of mutationIds) {
+                    const storedMutation = yield 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.
+     */
+    saveQueue(mutationId, mutation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (mutationId && mutation) {
+                    yield this.storage.setItem(this.prefix + mutationId, JSON.stringify(mutation));
+                }
+                yield 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.
+     */
+    add(item, mutationId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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);
+            yield this.saveQueue(mutationId, item);
+            return mutationId;
+        });
+    }
+    /**
+     * Remove a mutation attempt from the queue.
+     */
+    remove(mutationId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.queue.delete(mutationId);
+            yield this.storage.removeItem(this.prefix + mutationId);
+            yield this.saveQueue();
+        });
+    }
+    /**
+     * Takes the mutations in the queue and try to send them to the server again.
+     */
+    sync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 {
+                        yield this.client.mutate(Object.assign(Object.assign({}, attempt), { optimisticResponse: undefined }));
+                        serverProcessed = true;
+                    }
+                    catch (e) {
+                        const err = e;
+                        const networkError = err.networkError;
+                        if (!this.retryOnServerError && (networkError === null || networkError === void 0 ? void 0 : 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 {
+                            yield this.remove(mutationId);
+                        }
+                        catch (e) {
+                            console.error(e);
+                        }
+                    }
+                }
+            }
+            else {
+                yield Promise.all(attempts.map(([mutationId, attempt]) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    let serverProcessed = false;
+                    try {
+                        yield ((_a = this.client) === null || _a === void 0 ? void 0 : _a.mutate(Object.assign(Object.assign({}, attempt), { optimisticResponse: undefined })));
+                        serverProcessed = true;
+                    }
+                    catch (e) {
+                        const err = e;
+                        const networkError = err.networkError;
+                        if (!this.retryOnServerError && (networkError === null || networkError === void 0 ? void 0 : networkError.response)) {
+                            serverProcessed = true;
+                        }
+                    }
+                    if (serverProcessed) {
+                        yield this.remove(mutationId);
+                    }
+                })));
+            }
+            // Remaining mutations in the queue are persisted
+            yield 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).
+     */
+    setup(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.client = client;
+            this.queue = yield this.getQueue();
+            yield this.sync();
+        });
+    }
+}
+exports.OfflineLink = OfflineLink;

package/{resolvers → utils}/offlineLink.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { ApolloLink, Observable, } from '@apollo/client';
-import uuid from '../utils/uuid4';
+import uuid from './uuid4';
 export class OfflineLink extends ApolloLink {
     /**
      * storage