@quesmed/types 1.3.14 → 1.3.18

package/utils/offlineLink.js

@@ -0,0 +1,230 @@
+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());
+    });
+};
+import { ApolloLink, Observable, } from '@apollo/client';
+import uuid from './uuid4';
+export class OfflineLink extends 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 Observable((observer) => {
+            const mutationId = uuid.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 = uuid.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();
+        });
+    }
+}

package/utils/uuid4.cjs

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+        // Add an initial 4 bit zero pad so result is always 22 chars long.
+        const binString = '0000' + Uuid4._asBinString(data);
+        let result = '';
+        let pieces = [
+            0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96, 102,
+            108, 114, 120, 126,
+        ];
+        for (const piece of pieces) {
+            result += Uuid4._base64[binString.substr(piece, 6)];
+        }
+        return result;
+    }
+    /**
+     * 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) {
+        const binString = Uuid4._asBinString(data);
+        let hexString = '';
+        const pieces = [0, 16, 32, 48, 64, 80, 96, 112];
+        for (const piece of pieces) {
+            hexString += parseInt(binString.substr(piece, 16), 2)
+                .toString(16)
+                .padStart(4, '0');
+        }
+        return hexString;
+    }
+    /**
+     * 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) {
+        const hex = Uuid4.asHexString(data);
+        return Uuid4.fromHexStringToUuid(hex);
+    }
+    /**
+     * 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) {
+        if (22 !== data.length) {
+            const mess = `Expected base 64 number length of 22 characters but was given length: ${data.length}`;
+            throw new RangeError(mess);
+        }
+        // Need switched keys and values so reverse lookups can be done.
+        let flipped = {};
+        for (const [key, value] of Object.entries(Uuid4._base64)) {
+            flipped[value] = key;
+        }
+        let binString = '';
+        for (let i = 0, len = data.length; i < len; ++i) {
+            binString += flipped[data[i]];
+        }
+        // Cut off 4 bit zero padding.
+        binString = binString.substr(-128);
+        let hexString = '';
+        const pieces = [0, 32, 64, 96];
+        for (const piece of pieces) {
+            hexString += parseInt(binString.substr(piece, 32), 2)
+                .toString(16)
+                .padStart(8, '0');
+        }
+        return hexString;
+    }
+    /**
+     * 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) {
+        const hexString = Uuid4.fromBase64ToHexString(data);
+        return Uuid4.fromHexStringToUuid(hexString);
+    }
+    /**
+     * 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) {
+        if (32 !== data.length) {
+            const mess = `Expected hex string length of 32 characters but was given length: ${data.length}`;
+            throw new RangeError(mess);
+        }
+        let pieces = [0, 4, 8, 12, 16, 20, 24, 28];
+        let binString = '0000';
+        for (const piece of pieces) {
+            binString += parseInt(data.substr(piece, 4), 16)
+                .toString(2)
+                .padStart(16, '0');
+        }
+        let result = '';
+        pieces = [
+            0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96, 102,
+            108, 114, 120, 126,
+        ];
+        for (const piece of pieces) {
+            result += Uuid4._base64[binString.substr(piece, 6)];
+        }
+        return result;
+    }
+    /**
+     * 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) {
+        if (32 !== data.length) {
+            const mess = `Expected hex string length of 32 characters but was given length: ${data.length}`;
+            throw new RangeError(mess);
+        }
+        const pieces = [8, 4, 4, 4, 12];
+        let start = 0;
+        let hexArray = [];
+        for (const piece of pieces) {
+            hexArray.push(data.substr(start, piece));
+            start += piece;
+        }
+        return hexArray.join('-');
+    }
+    /**
+     * 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) {
+        const hexString = data.replace(/-/g, '');
+        return Uuid4.fromHexStringToBase64(hexString);
+    }
+    /**
+     * 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) {
+        return data.replace(/-/g, '');
+    }
+    get [Symbol.toStringTag]() {
+        return 'Uuid4';
+    }
+    /**
+     * 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
+     */
+    static _asBinString(data) {
+        let binArray = data !== null && data !== void 0 ? data : Uuid4._getRandomArray();
+        if (16 !== binArray.length) {
+            const mess = `Expected data array length of 16 but was given length: ${binArray.length}`;
+            throw new RangeError(mess);
+        }
+        binArray[6] = (binArray[6] & 0x0f) | 0x40;
+        binArray[8] = (binArray[8] & 0x3f) | 0x80;
+        let binary = '';
+        for (const piece of binArray) {
+            binary += piece.toString(2).padStart(8, '0');
+        }
+        return binary;
+    }
+    /**
+     * Used to paste over differences in browser vs node secure random number generation.
+     *
+     * @returns {Uint8Array} Returns a new random number filled Uint8Array.
+     * @private
+     */
+    static _getRandomArray() {
+        if (typeof window === 'undefined') {
+            let crypto = require('crypto');
+            return Uint8Array.from(crypto.randomBytes(16));
+        }
+        // `result` is modified in place.
+        let result = new Uint8Array(16);
+        window.crypto.getRandomValues(result);
+        return result;
+    }
+}
+/**
+ * Used in mapping from binary to base 64 during encoding.
+ *
+ * @type {object}
+ * @private
+ */
+Uuid4._base64 = {
+    '000000': 'A',
+    '000001': 'B',
+    '000010': 'C',
+    '000011': 'D',
+    '000100': 'E',
+    '000101': 'F',
+    '000110': 'G',
+    '000111': 'H',
+    '001000': 'I',
+    '001001': 'J',
+    '001010': 'K',
+    '001011': 'L',
+    '001100': 'M',
+    '001101': 'N',
+    '001110': 'O',
+    '001111': 'P',
+    '010000': 'Q',
+    '010001': 'R',
+    '010010': 'S',
+    '010011': 'T',
+    '010100': 'U',
+    '010101': 'V',
+    '010110': 'W',
+    '010111': 'X',
+    '011000': 'Y',
+    '011001': 'Z',
+    '011010': 'a',
+    '011011': 'b',
+    '011100': 'c',
+    '011101': 'd',
+    '011110': 'e',
+    '011111': 'f',
+    '100000': 'g',
+    '100001': 'h',
+    '100010': 'i',
+    '100011': 'j',
+    '100100': 'k',
+    '100101': 'l',
+    '100110': 'm',
+    '100111': 'n',
+    '101000': 'o',
+    '101001': 'p',
+    '101010': 'q',
+    '101011': 'r',
+    '101100': 's',
+    '101101': 't',
+    '101110': 'u',
+    '101111': 'v',
+    '110000': 'w',
+    '110001': 'x',
+    '110010': 'y',
+    '110011': 'z',
+    '110100': '0',
+    '110101': '1',
+    '110110': '2',
+    '110111': '3',
+    '111000': '4',
+    '111001': '5',
+    '111010': '6',
+    '111011': '7',
+    '111100': '8',
+    '111101': '9',
+    '111110': '-',
+    '111111': '_',
+};
+exports.default = Uuid4;

package/utils/uuid4.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 class Uuid4 {
     /**
      * Generate a custom base 64 encoded UUID v4 (random).
@@ -284,4 +282,4 @@ Uuid4._base64 = {
     '111110': '-',
     '111111': '_',
 };
-exports.default = Uuid4;
+export default Uuid4;

package/utils/wordsToNumber.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordsToNumber = void 0;
+const Small = {
+    zero: 0,
+    one: 1,
+    two: 2,
+    three: 3,
+    four: 4,
+    five: 5,
+    six: 6,
+    seven: 7,
+    eight: 8,
+    nine: 9,
+    ten: 10,
+    eleven: 11,
+    twelve: 12,
+    thirteen: 13,
+    fourteen: 14,
+    fifteen: 15,
+    sixteen: 16,
+    seventeen: 17,
+    eighteen: 18,
+    nineteen: 19,
+    twenty: 20,
+    thirty: 30,
+    forty: 40,
+    fifty: 50,
+    sixty: 60,
+    seventy: 70,
+    eighty: 80,
+    ninety: 90,
+};
+function wordsToNumber(s, checkForDigits = false) {
+    const words = s.toString().split(/[\s-]+/);
+    let total = 0;
+    words.forEach((word) => {
+        const wordKey = Small[word];
+        if (wordKey !== undefined) {
+            total += wordKey;
+        }
+        else if (checkForDigits && !isNaN(parseFloat(word))) {
+            total += parseFloat(word);
+        }
+    });
+    return total;
+}
+exports.wordsToNumber = wordsToNumber;

package/utils/wordsToNumber.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wordsToNumber = void 0;
 const Small = {
     zero: 0,
     one: 1,
@@ -31,7 +28,7 @@ const Small = {
     eighty: 80,
     ninety: 90,
 };
-function wordsToNumber(s, checkForDigits = false) {
+export function wordsToNumber(s, checkForDigits = false) {
     const words = s.toString().split(/[\s-]+/);
     let total = 0;
     words.forEach((word) => {
@@ -45,4 +42,3 @@ function wordsToNumber(s, checkForDigits = false) {
     });
     return total;
 }
-exports.wordsToNumber = wordsToNumber;