clarity-pattern-parser 7.0.2 → 8.0.0

package/biome.json

@@ -0,0 +1,257 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.8.1/schema.json",
+  "css": {
+    "parser": {
+      "cssModules": true
+    }
+  },
+  "files": {
+    "ignore": [
+      "package.json",
+      "**/*.yml",
+      "node_modules/",
+      "storybook-static/",
+      ".yarn/",
+      ".vscode/",
+      "coverage/",
+      "dist/",
+      "build/",
+      "**/*.d.ts",
+      "**/@types/",
+      "**/__mocks__/"
+    ]
+  },
+  "formatter": {
+    "enabled": true,
+    "formatWithErrors": false,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineEnding": "lf",
+    "lineWidth": 90,
+    "attributePosition": "auto"
+  },
+  "organizeImports": { "enabled": true },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": false,
+      "a11y": {
+        "noAccessKey": "warn",
+        "noAriaUnsupportedElements": "warn",
+        "noBlankTarget": "warn",
+        "noDistractingElements": "warn",
+        "noHeaderScope": "warn",
+        "noRedundantAlt": "warn",
+        "noRedundantRoles": "warn",
+        "useAltText": "warn",
+        "useAnchorContent": "warn",
+        "useAriaActivedescendantWithTabindex": "warn",
+        "useAriaPropsForRole": "warn",
+        "useHeadingContent": "warn",
+        "useIframeTitle": "warn",
+        "useValidAnchor": "warn",
+        "useValidAriaProps": "warn",
+        "useValidAriaRole": "warn",
+        "useValidAriaValues": "warn"
+      },
+      "complexity": {
+        "noMultipleSpacesInRegularExpressionLiterals": "warn",
+        "noUselessConstructor": "warn",
+        "noUselessLabel": "warn",
+        "noUselessLoneBlockStatements": "warn",
+        "noUselessRename": "warn",
+        "noWith": "warn"
+      },
+      "correctness": {
+        "noConstAssign": "warn",
+        "noEmptyCharacterClassInRegex": "warn",
+        "noEmptyPattern": "warn",
+        "noGlobalObjectCalls": "warn",
+        "noInvalidUseBeforeDeclaration": "warn",
+        "noNewSymbol": "warn",
+        "noSelfAssign": "warn",
+        "noUndeclaredVariables": "error",
+        "noUnreachable": "warn",
+        "noUnreachableSuper": "warn",
+        "noUnusedLabels": "warn",
+        "noUnusedVariables": "warn",
+        "useArrayLiterals": "warn",
+        "useExhaustiveDependencies": "error",
+        "useHookAtTopLevel": "error",
+        "useIsNan": "warn",
+        "useYield": "warn"
+      },
+      "security": {
+        "noDangerouslySetInnerHtmlWithChildren": "warn",
+        "noGlobalEval": "warn"
+      },
+      "style": {
+        "noCommaOperator": "warn",
+        "noRestrictedGlobals": {
+          "level": "error",
+          "options": {
+            "deniedGlobals": [
+              "addEventListener",
+              "blur",
+              "close",
+              "closed",
+              "confirm",
+              "defaultStatus",
+              "defaultstatus",
+              "event",
+              "external",
+              "find",
+              "focus",
+              "frameElement",
+              "frames",
+              "history",
+              "innerHeight",
+              "innerWidth",
+              "length",
+              "location",
+              "locationbar",
+              "menubar",
+              "moveBy",
+              "moveTo",
+              "name",
+              "onblur",
+              "onerror",
+              "onfocus",
+              "onload",
+              "onresize",
+              "onunload",
+              "open",
+              "opener",
+              "opera",
+              "outerHeight",
+              "outerWidth",
+              "pageXOffset",
+              "pageYOffset",
+              "parent",
+              "print",
+              "removeEventListener",
+              "resizeBy",
+              "resizeTo",
+              "screen",
+              "screenLeft",
+              "screenTop",
+              "screenX",
+              "screenY",
+              "scroll",
+              "scrollbars",
+              "scrollBy",
+              "scrollTo",
+              "scrollX",
+              "scrollY",
+              "self",
+              "status",
+              "statusbar",
+              "stop",
+              "toolbar",
+              "top",
+              "setInterval",
+              "setTimeout",
+              "clearInterval",
+              "clearTimeout"
+            ]
+          }
+        }
+      },
+      "suspicious": {
+        "noCatchAssign": "warn",
+        "noCommentText": "warn",
+        "noControlCharactersInRegex": "warn",
+        "noDoubleEquals": "warn",
+        "noDuplicateCase": "warn",
+        "noDuplicateClassMembers": "warn",
+        "noDuplicateJsxProps": "warn",
+        "noDuplicateObjectKeys": "warn",
+        "noDuplicateParameters": "warn",
+        "noFallthroughSwitchClause": "off",
+        "noFunctionAssign": "warn",
+        "noLabelVar": "warn",
+        "noRedeclare": "warn",
+        "noSelfCompare": "warn",
+        "noShadowRestrictedNames": "warn",
+        "useGetterReturn": "warn",
+        "useValidTypeof": "warn"
+      }
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "jsxQuoteStyle": "double",
+      "quoteProperties": "asNeeded",
+      "trailingCommas": "es5",
+      "semicolons": "always",
+      "arrowParentheses": "asNeeded",
+      "bracketSpacing": true,
+      "bracketSameLine": false,
+      "quoteStyle": "single",
+      "attributePosition": "auto"
+    }
+  },
+  "overrides": [
+    {
+      "include": [
+        "*.test.ts",
+        "*.test.tsx",
+        "*.test.js",
+        "*.test.jsx",
+        "test.js",
+        "test.jsx",
+        "test.ts",
+        "test.tsx",
+        "testUtils.ts",
+        "testUtils.tsx"
+      ],
+      "linter": { "rules": {} }
+    },
+    {
+      "include": ["*.ts", "*.tsx"],
+      "linter": {
+        "rules": {
+          "complexity": {
+            "noBannedTypes": "warn",
+            "noUselessConstructor": "warn",
+            "noUselessTypeConstraint": "error"
+          },
+          "correctness": {
+            "noInvalidUseBeforeDeclaration": "off",
+            "noPrecisionLoss": "error",
+            "noUndeclaredVariables": "off",
+            "noUnusedVariables": "warn",
+            "useArrayLiterals": "off"
+          },
+          "style": {
+            "noInferrableTypes": "warn",
+            "noNamespace": "error",
+            "noNonNullAssertion": "warn",
+            "useAsConstAssertion": "error",
+            "useConsistentArrayType": "warn"
+          },
+          "suspicious": {
+            "noDuplicateClassMembers": "off",
+            "noEmptyBlockStatements": "off",
+            "noExplicitAny": "off",
+            "noExtraNonNullAssertion": "error",
+            "noMisleadingInstantiator": "error",
+            "noRedeclare": "off",
+            "useNamespaceKeyword": "error"
+          }
+        }
+      }
+    },
+    {
+      "include": [
+        "*.stories.@(ts|tsx|js|jsx|mjs|cjs)",
+        "*.story.@(ts|tsx|js|jsx|mjs|cjs)"
+      ],
+      "linter": { "rules": {} }
+    },
+    {
+      "include": [".storybook/main.@(js|cjs|mjs|ts)"],
+      "linter": { "rules": {} }
+    }
+  ]
+}

package/dist/index.browser.js

@@ -183,8 +183,9 @@
     }
 
     class ParseError {
-        constructor(index, pattern) {
-            this.index = index;
+        constructor(startIndex, endIndex, pattern) {
+            this.startIndex = startIndex;
+            this.endIndex = endIndex;
             this.pattern = pattern;
         }
     }
@@ -250,7 +251,7 @@
                     var _a;
                     let parent = (_a = m.pattern) === null || _a === void 0 ? void 0 : _a.parent;
                     while (parent != null) {
-                        if (parent == pattern.parent) {
+                        if (parent === pattern.parent) {
                             return true;
                         }
                         parent = parent.parent;
@@ -262,10 +263,10 @@
                 }
             }
         }
-        recordErrorAt(index, pattern) {
-            const error = new ParseError(index, pattern);
+        recordErrorAt(firstIndex, lastIndex, pattern) {
+            const error = new ParseError(firstIndex, lastIndex, pattern);
             this._currentError = error;
-            if (this._furthestError === null || index > this._furthestError.index) {
+            if (this._furthestError === null || lastIndex > this._furthestError.endIndex) {
                 this._furthestError = error;
             }
             if (this._isRecording) {
@@ -320,6 +321,9 @@
         get error() {
             return this._history.error;
         }
+        get errors() {
+            return this._history.errors;
+        }
         get index() {
             return this._index;
         }
@@ -368,8 +372,8 @@
         recordMatch(pattern, node) {
             this._history.recordMatch(pattern, node);
         }
-        recordErrorAt(index, onPattern) {
-            this._history.recordErrorAt(index, onPattern);
+        recordErrorAt(firstIndex, lastIndex, onPattern) {
+            this._history.recordErrorAt(firstIndex, lastIndex, onPattern);
         }
         resolveError() {
             this._history.resolveError();
@@ -395,6 +399,7 @@
             this._parent = null;
             this._firstIndex = 0;
             this._lastIndex = 0;
+            this._endIndex = 0;
         }
         get type() {
             return this._type;
@@ -437,7 +442,7 @@
                 return node;
             }
             if (!this._isOptional) {
-                cursor.recordErrorAt(cursor.index, this);
+                cursor.recordErrorAt(this._firstIndex, this._endIndex, this);
                 return null;
             }
             cursor.resolveError();
@@ -451,6 +456,7 @@
                 const literalRune = this._runes[i];
                 const cursorRune = cursor.currentChar;
                 if (literalRune !== cursorRune) {
+                    this._endIndex = cursor.index;
                     break;
                 }
                 if (i + 1 === literalRuneLength) {
@@ -459,6 +465,7 @@
                     break;
                 }
                 if (!cursor.hasNext()) {
+                    this._endIndex = cursor.index + 1;
                     break;
                 }
                 cursor.next();
@@ -505,6 +512,7 @@
         constructor(name, regex, isOptional = false) {
             this._node = null;
             this._cursor = null;
+            this._firstIndex = -1;
             this._substring = "";
             this._tokens = [];
             this._type = "regex";
@@ -558,6 +566,7 @@
             };
         }
         parse(cursor) {
+            this._firstIndex = cursor.index;
             this.resetState(cursor);
             this.tryToParse(cursor);
             return this._node;
@@ -586,7 +595,7 @@
         }
         processError(cursor) {
             if (!this._isOptional) {
-                cursor.recordErrorAt(cursor.index, this);
+                cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
             }
             this._node = null;
         }
@@ -824,7 +833,7 @@
                 return node;
             }
             if (!this._isOptional) {
-                cursor.recordErrorAt(this._firstIndex, this);
+                cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
                 return null;
             }
             cursor.resolveError();
@@ -963,7 +972,7 @@
             }
             if (matchCount < this._min) {
                 cursor.moveTo(startIndex);
-                cursor.recordErrorAt(startIndex, this);
+                cursor.recordErrorAt(startIndex, startIndex, this);
                 return null;
             }
             else if (nodes.length === 0) {
@@ -1026,7 +1035,7 @@
         getPatternsAfter(childReference) {
             const childIndex = this._children.indexOf(childReference);
             // If Reference Pattern isn't a child.
-            if (childIndex == -1) {
+            if (childIndex === -1) {
                 return [];
             }
             // If Reference Pattern is the last pattern. Ask for the parents next patterns 
@@ -1141,6 +1150,7 @@
             return this._nodes.length >= this._min;
         }
         _tryToParse(cursor) {
+            const firstIndex = cursor.index;
             let passed = false;
             while (true) {
                 const runningCursorIndex = cursor.index;
@@ -1152,7 +1162,7 @@
                     }
                     else {
                         cursor.moveTo(runningCursorIndex);
-                        cursor.recordErrorAt(runningCursorIndex, this._pattern);
+                        cursor.recordErrorAt(firstIndex, runningCursorIndex, this._pattern);
                         passed = false;
                     }
                     break;
@@ -1188,7 +1198,7 @@
                 return passed;
             }
             else if (!hasMinimum && passed) {
-                cursor.recordErrorAt(cursor.index, this);
+                cursor.recordErrorAt(firstIndex, cursor.index, this);
                 cursor.moveTo(this._firstIndex);
                 return false;
             }
@@ -1293,7 +1303,7 @@
             this._pattern = pattern;
             this._parent = null;
             this._options = Object.assign(Object.assign({}, options), { min: options.min == null ? 1 : options.min, max: options.max == null ? Infinity : options.max });
-            if (this._options.max != Infinity) {
+            if (this._options.max !== Infinity) {
                 this._repeatPattern = new FiniteRepeat(name, pattern, this._options.max, this._options);
             }
             else {
@@ -1481,7 +1491,7 @@
                                     break;
                                 }
                                 // We didn't finish the parsing sequence.
-                                cursor.recordErrorAt(cursor.index + 1, this);
+                                cursor.recordErrorAt(this._firstIndex, cursor.index + 1, this);
                                 break;
                             }
                         }
@@ -1496,7 +1506,7 @@
                         // If we don't have any results from what we parsed then record error.
                         const lastNode = this.getLastValidNode();
                         if (lastNode === null) {
-                            cursor.recordErrorAt(cursor.index, this);
+                            cursor.recordErrorAt(this._firstIndex, cursor.index, this);
                             break;
                         }
                         // The sequence was parsed fully.
@@ -1785,7 +1795,7 @@
             else {
                 cursor.moveTo(firstIndex);
                 cursor.resolveError();
-                cursor.recordErrorAt(firstIndex, this);
+                cursor.recordErrorAt(firstIndex, firstIndex, this);
             }
             return null;
         }
@@ -1853,12 +1863,13 @@
             }
             this._text = text;
             this._cursor = new Cursor(text);
+            this._cursor.startRecording();
             let errorAtIndex = null;
             const ast = this._pattern.parse(this._cursor);
             const isComplete = (ast === null || ast === void 0 ? void 0 : ast.value) === text;
             const options = this._getAllOptions();
             if (this._cursor.hasError && this._cursor.furthestError != null) {
-                errorAtIndex = this._cursor.furthestError.index;
+                errorAtIndex = this._cursor.furthestError.endIndex;
                 errorAtIndex = options.reduce((errorAtIndex, option) => Math.max(errorAtIndex, option.startIndex), errorAtIndex);
             }
             return {
@@ -1870,7 +1881,20 @@
             };
         }
         _getAllOptions() {
-            return this._cursor.leafMatches.map((m) => this._createSuggestionsFromMatch(m)).flat();
+            const errorMatches = this._getOptionsFromErrors();
+            const leafMatches = this._cursor.leafMatches.map((m) => this._createSuggestionsFromMatch(m)).flat();
+            const finalResults = errorMatches.filter(m => leafMatches.findIndex(l => l.text === m.text) === -1);
+            return [...leafMatches, ...finalResults];
+        }
+        _getOptionsFromErrors() {
+            // These errored because the length of the string.
+            const errors = this._cursor.errors.filter(e => e.endIndex === this._cursor.length);
+            const suggestions = errors.map(e => {
+                const tokens = this._getTokensForPattern(e.pattern);
+                const adjustedTokens = tokens.map(t => t.slice(e.endIndex - e.startIndex));
+                return this._createSuggestions(e.endIndex, adjustedTokens);
+            });
+            return suggestions.flat();
         }
         _createSuggestionsFromRoot() {
             const suggestions = [];
@@ -1881,7 +1905,7 @@
             return suggestions;
         }
         _createSuggestionsFromMatch(match) {
-            if (!match.pattern) {
+            if (match.pattern == null) {
                 return this._createSuggestions(-1, this._getTokensForPattern(this._pattern));
             }
             const leafPattern = match.pattern;