@graphql-mesh/fusion-composition 0.8.43 → 0.8.44

package/cjs/index.js

@@ -4,3 +4,4 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./compose.js"), exports);
 tslib_1.__exportStar(require("./transforms.js"), exports);
 tslib_1.__exportStar(require("./future-additions.js"), exports);
+tslib_1.__exportStar(require("./suggestionList/index.js"), exports);

package/cjs/suggestionList/index.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestionList = suggestionList;
+const naturalCompare_js_1 = require("./naturalCompare.js");
+// Taken from https://github.com/graphql/graphql-js/blob/16.x.x/src/jsutils/suggestionList.ts
+/**
+ * Given an invalid input string and a list of valid options, returns a filtered
+ * list of valid options sorted based on their similarity with the input.
+ */
+function suggestionList(input, options) {
+    const optionsByDistance = Object.create(null);
+    const lexicalDistance = new LexicalDistance(input);
+    const threshold = Math.floor(input.length * 0.4) + 1;
+    for (const option of options) {
+        const distance = lexicalDistance.measure(option, threshold);
+        if (distance !== undefined) {
+            optionsByDistance[option] = distance;
+        }
+    }
+    return Object.keys(optionsByDistance).sort((a, b) => {
+        const distanceDiff = optionsByDistance[a] - optionsByDistance[b];
+        return distanceDiff !== 0 ? distanceDiff : (0, naturalCompare_js_1.naturalCompare)(a, b);
+    });
+}
+/**
+ * Computes the lexical distance between strings A and B.
+ *
+ * The "distance" between two strings is given by counting the minimum number
+ * of edits needed to transform string A into string B. An edit can be an
+ * insertion, deletion, or substitution of a single character, or a swap of two
+ * adjacent characters.
+ *
+ * Includes a custom alteration from Damerau-Levenshtein to treat case changes
+ * as a single edit which helps identify mis-cased values with an edit distance
+ * of 1.
+ *
+ * This distance can be useful for detecting typos in input or sorting
+ */
+class LexicalDistance {
+    constructor(input) {
+        this._input = input;
+        this._inputLowerCase = input.toLowerCase();
+        this._inputArray = stringToArray(this._inputLowerCase);
+        this._rows = [
+            new Array(input.length + 1).fill(0),
+            new Array(input.length + 1).fill(0),
+            new Array(input.length + 1).fill(0),
+        ];
+    }
+    measure(option, threshold) {
+        if (this._input === option) {
+            return 0;
+        }
+        const optionLowerCase = option.toLowerCase();
+        // Any case change counts as a single edit
+        if (this._inputLowerCase === optionLowerCase) {
+            return 1;
+        }
+        let a = stringToArray(optionLowerCase);
+        let b = this._inputArray;
+        if (a.length < b.length) {
+            const tmp = a;
+            a = b;
+            b = tmp;
+        }
+        const aLength = a.length;
+        const bLength = b.length;
+        if (aLength - bLength > threshold) {
+            return undefined;
+        }
+        const rows = this._rows;
+        for (let j = 0; j <= bLength; j++) {
+            rows[0][j] = j;
+        }
+        for (let i = 1; i <= aLength; i++) {
+            const upRow = rows[(i - 1) % 3];
+            const currentRow = rows[i % 3];
+            let smallestCell = (currentRow[0] = i);
+            for (let j = 1; j <= bLength; j++) {
+                const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+                let currentCell = Math.min(upRow[j] + 1, // delete
+                currentRow[j - 1] + 1, // insert
+                upRow[j - 1] + cost);
+                if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                    // transposition
+                    const doubleDiagonalCell = rows[(i - 2) % 3][j - 2];
+                    currentCell = Math.min(currentCell, doubleDiagonalCell + 1);
+                }
+                if (currentCell < smallestCell) {
+                    smallestCell = currentCell;
+                }
+                currentRow[j] = currentCell;
+            }
+            // Early exit, since distance can't go smaller than smallest element of the previous row.
+            if (smallestCell > threshold) {
+                return undefined;
+            }
+        }
+        const distance = rows[aLength % 3][bLength];
+        return distance <= threshold ? distance : undefined;
+    }
+}
+function stringToArray(str) {
+    const strLength = str.length;
+    const array = new Array(strLength);
+    for (let i = 0; i < strLength; ++i) {
+        array[i] = str.charCodeAt(i);
+    }
+    return array;
+}

package/cjs/suggestionList/naturalCompare.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.naturalCompare = naturalCompare;
+/**
+ * Returns a number indicating whether a reference string comes before, or after,
+ * or is the same as the given string in natural sort order.
+ *
+ * See: https://en.wikipedia.org/wiki/Natural_sort_order
+ *
+ */
+function naturalCompare(aStr, bStr) {
+    let aIndex = 0;
+    let bIndex = 0;
+    while (aIndex < aStr.length && bIndex < bStr.length) {
+        let aChar = aStr.charCodeAt(aIndex);
+        let bChar = bStr.charCodeAt(bIndex);
+        if (isDigit(aChar) && isDigit(bChar)) {
+            let aNum = 0;
+            do {
+                ++aIndex;
+                aNum = aNum * 10 + aChar - DIGIT_0;
+                aChar = aStr.charCodeAt(aIndex);
+            } while (isDigit(aChar) && aNum > 0);
+            let bNum = 0;
+            do {
+                ++bIndex;
+                bNum = bNum * 10 + bChar - DIGIT_0;
+                bChar = bStr.charCodeAt(bIndex);
+            } while (isDigit(bChar) && bNum > 0);
+            if (aNum < bNum) {
+                return -1;
+            }
+            if (aNum > bNum) {
+                return 1;
+            }
+        }
+        else {
+            if (aChar < bChar) {
+                return -1;
+            }
+            if (aChar > bChar) {
+                return 1;
+            }
+            ++aIndex;
+            ++bIndex;
+        }
+    }
+    return aStr.length - bStr.length;
+}
+const DIGIT_0 = 48;
+const DIGIT_9 = 57;
+function isDigit(code) {
+    return !isNaN(code) && DIGIT_0 <= code && code <= DIGIT_9;
+}

package/esm/index.js

@@ -1,3 +1,4 @@
 export * from './compose.js';
 export * from './transforms.js';
 export * from './future-additions.js';
+export * from './suggestionList/index.js';

package/esm/suggestionList/index.js

@@ -0,0 +1,107 @@
+import { naturalCompare } from './naturalCompare.js';
+// Taken from https://github.com/graphql/graphql-js/blob/16.x.x/src/jsutils/suggestionList.ts
+/**
+ * Given an invalid input string and a list of valid options, returns a filtered
+ * list of valid options sorted based on their similarity with the input.
+ */
+export function suggestionList(input, options) {
+    const optionsByDistance = Object.create(null);
+    const lexicalDistance = new LexicalDistance(input);
+    const threshold = Math.floor(input.length * 0.4) + 1;
+    for (const option of options) {
+        const distance = lexicalDistance.measure(option, threshold);
+        if (distance !== undefined) {
+            optionsByDistance[option] = distance;
+        }
+    }
+    return Object.keys(optionsByDistance).sort((a, b) => {
+        const distanceDiff = optionsByDistance[a] - optionsByDistance[b];
+        return distanceDiff !== 0 ? distanceDiff : naturalCompare(a, b);
+    });
+}
+/**
+ * Computes the lexical distance between strings A and B.
+ *
+ * The "distance" between two strings is given by counting the minimum number
+ * of edits needed to transform string A into string B. An edit can be an
+ * insertion, deletion, or substitution of a single character, or a swap of two
+ * adjacent characters.
+ *
+ * Includes a custom alteration from Damerau-Levenshtein to treat case changes
+ * as a single edit which helps identify mis-cased values with an edit distance
+ * of 1.
+ *
+ * This distance can be useful for detecting typos in input or sorting
+ */
+class LexicalDistance {
+    constructor(input) {
+        this._input = input;
+        this._inputLowerCase = input.toLowerCase();
+        this._inputArray = stringToArray(this._inputLowerCase);
+        this._rows = [
+            new Array(input.length + 1).fill(0),
+            new Array(input.length + 1).fill(0),
+            new Array(input.length + 1).fill(0),
+        ];
+    }
+    measure(option, threshold) {
+        if (this._input === option) {
+            return 0;
+        }
+        const optionLowerCase = option.toLowerCase();
+        // Any case change counts as a single edit
+        if (this._inputLowerCase === optionLowerCase) {
+            return 1;
+        }
+        let a = stringToArray(optionLowerCase);
+        let b = this._inputArray;
+        if (a.length < b.length) {
+            const tmp = a;
+            a = b;
+            b = tmp;
+        }
+        const aLength = a.length;
+        const bLength = b.length;
+        if (aLength - bLength > threshold) {
+            return undefined;
+        }
+        const rows = this._rows;
+        for (let j = 0; j <= bLength; j++) {
+            rows[0][j] = j;
+        }
+        for (let i = 1; i <= aLength; i++) {
+            const upRow = rows[(i - 1) % 3];
+            const currentRow = rows[i % 3];
+            let smallestCell = (currentRow[0] = i);
+            for (let j = 1; j <= bLength; j++) {
+                const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+                let currentCell = Math.min(upRow[j] + 1, // delete
+                currentRow[j - 1] + 1, // insert
+                upRow[j - 1] + cost);
+                if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                    // transposition
+                    const doubleDiagonalCell = rows[(i - 2) % 3][j - 2];
+                    currentCell = Math.min(currentCell, doubleDiagonalCell + 1);
+                }
+                if (currentCell < smallestCell) {
+                    smallestCell = currentCell;
+                }
+                currentRow[j] = currentCell;
+            }
+            // Early exit, since distance can't go smaller than smallest element of the previous row.
+            if (smallestCell > threshold) {
+                return undefined;
+            }
+        }
+        const distance = rows[aLength % 3][bLength];
+        return distance <= threshold ? distance : undefined;
+    }
+}
+function stringToArray(str) {
+    const strLength = str.length;
+    const array = new Array(strLength);
+    for (let i = 0; i < strLength; ++i) {
+        array[i] = str.charCodeAt(i);
+    }
+    return array;
+}

package/esm/suggestionList/naturalCompare.js

@@ -0,0 +1,51 @@
+/**
+ * Returns a number indicating whether a reference string comes before, or after,
+ * or is the same as the given string in natural sort order.
+ *
+ * See: https://en.wikipedia.org/wiki/Natural_sort_order
+ *
+ */
+export function naturalCompare(aStr, bStr) {
+    let aIndex = 0;
+    let bIndex = 0;
+    while (aIndex < aStr.length && bIndex < bStr.length) {
+        let aChar = aStr.charCodeAt(aIndex);
+        let bChar = bStr.charCodeAt(bIndex);
+        if (isDigit(aChar) && isDigit(bChar)) {
+            let aNum = 0;
+            do {
+                ++aIndex;
+                aNum = aNum * 10 + aChar - DIGIT_0;
+                aChar = aStr.charCodeAt(aIndex);
+            } while (isDigit(aChar) && aNum > 0);
+            let bNum = 0;
+            do {
+                ++bIndex;
+                bNum = bNum * 10 + bChar - DIGIT_0;
+                bChar = bStr.charCodeAt(bIndex);
+            } while (isDigit(bChar) && bNum > 0);
+            if (aNum < bNum) {
+                return -1;
+            }
+            if (aNum > bNum) {
+                return 1;
+            }
+        }
+        else {
+            if (aChar < bChar) {
+                return -1;
+            }
+            if (aChar > bChar) {
+                return 1;
+            }
+            ++aIndex;
+            ++bIndex;
+        }
+    }
+    return aStr.length - bStr.length;
+}
+const DIGIT_0 = 48;
+const DIGIT_9 = 57;
+function isDigit(code) {
+    return !isNaN(code) && DIGIT_0 <= code && code <= DIGIT_9;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-mesh/fusion-composition",
-  "version": "0.8.43",
+  "version": "0.8.44",
   "description": "Basic composition utility for Fusion spec",
   "sideEffects": false,
   "peerDependencies": {

package/typings/index.d.cts

@@ -1,3 +1,4 @@
 export * from './compose.cjs';
 export * from './transforms.cjs';
 export * from './future-additions.cjs';
+export * from './suggestionList/index.cjs';

package/typings/index.d.ts

@@ -1,3 +1,4 @@
 export * from './compose.js';
 export * from './transforms.js';
 export * from './future-additions.js';
+export * from './suggestionList/index.js';

package/typings/suggestionList/index.d.cts

@@ -0,0 +1,5 @@
+/**
+ * Given an invalid input string and a list of valid options, returns a filtered
+ * list of valid options sorted based on their similarity with the input.
+ */
+export declare function suggestionList(input: string, options: ReadonlyArray<string>): Array<string>;

package/typings/suggestionList/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Given an invalid input string and a list of valid options, returns a filtered
+ * list of valid options sorted based on their similarity with the input.
+ */
+export declare function suggestionList(input: string, options: ReadonlyArray<string>): Array<string>;

package/typings/suggestionList/naturalCompare.d.cts

@@ -0,0 +1,8 @@
+/**
+ * Returns a number indicating whether a reference string comes before, or after,
+ * or is the same as the given string in natural sort order.
+ *
+ * See: https://en.wikipedia.org/wiki/Natural_sort_order
+ *
+ */
+export declare function naturalCompare(aStr: string, bStr: string): number;

package/typings/suggestionList/naturalCompare.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a number indicating whether a reference string comes before, or after,
+ * or is the same as the given string in natural sort order.
+ *
+ * See: https://en.wikipedia.org/wiki/Natural_sort_order
+ *
+ */
+export declare function naturalCompare(aStr: string, bStr: string): number;