@quesmed/types-rn 2.0.4

package/utils/uuid4.js

@@ -0,0 +1,282 @@
+"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 ?? 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() {
+        return Uint8Array.from(Array(16)
+            .fill(0)
+            .map(() => Math.round(Math.random() * 255)));
+    }
+}
+/**
+ * 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/webSocketLink.d.ts

@@ -0,0 +1,7 @@
+import { ApolloLink, FetchResult, Observable, Operation } from '@apollo/client/core';
+import { ClientOptions } from 'graphql-ws';
+export declare class WebSocketLink extends ApolloLink {
+    private client;
+    constructor(options: ClientOptions);
+    request(operation: Operation): Observable<FetchResult>;
+}

package/utils/webSocketLink.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketLink = void 0;
+const core_1 = require("@apollo/client/core");
+const graphql_1 = require("graphql");
+const graphql_ws_1 = require("graphql-ws");
+class WebSocketLink extends core_1.ApolloLink {
+    constructor(options) {
+        super();
+        this.client = (0, graphql_ws_1.createClient)(options);
+    }
+    request(operation) {
+        return new core_1.Observable((sink) => {
+            return this.client.subscribe({ ...operation, query: (0, graphql_1.print)(operation.query) }, {
+                next: sink.next.bind(sink),
+                complete: sink.complete.bind(sink),
+                error: sink.error.bind(sink),
+            });
+        });
+    }
+}
+exports.WebSocketLink = WebSocketLink;

package/utils/wordsToNumber.d.ts

@@ -0,0 +1 @@
+export declare function wordsToNumber(s: string, checkForDigits?: boolean): number;

package/utils/wordsToNumber.js

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