clarity-pattern-parser 11.3.9 → 11.3.11

package/dist/intellisense/AutoComplete.d.ts

@@ -13,6 +13,12 @@ export interface AutoCompleteOptions {
      * and the string array are the tokens suggested for that pattern.
      */
     customTokens?: Record<string, string[]>;
+    /**
+     * Suggestions may share the same text but differ in their suggestionSequence.
+     * By default, duplicates are removed and only the first instance is kept.
+     * Disabling deduplication allows all distinct instances to be returned together.
+     */
+    disableDedupe?: boolean;
 }
 export declare class AutoComplete {
     private _pattern;
@@ -20,17 +26,29 @@ export declare class AutoComplete {
     private _cursor;
     private _text;
     constructor(pattern: Pattern, options?: AutoCompleteOptions);
+    suggestFor(text: string): Suggestion;
     suggestForWithCursor(cursor: Cursor): Suggestion;
     private getFurthestPosition;
-    suggestFor(text: string): Suggestion;
-    private _getAllOptions;
-    private _getOptionsFromErrors;
-    private _createSuggestionsFromRoot;
-    private _createSuggestionsFromMatch;
-    private _getTokensForPattern;
-    private _getAugmentedTokens;
+    private _getAllSuggestionsOptions;
+    private _createSuggestionOptionsFromErrors;
+    private _createSuggestionOptionsFromMatch;
+    /**
+     * Compares suggestions with provided text and removes completed sub-sequences and preceding text
+     * - IE. **currentText:** *abc*, **sequence:** *[{ab}{cd}{ef}*
+     *   - refines to {d}{ef}
+     */
+    private _trimSuggestionsByExistingText;
+    /** Removed segments already accounted for in the existing text.
+   * ie. sequence pattern segments ≈ [{look}, {an example}, {phrase}]
+   * fullText = "look an"
+   * remove {look} segment as its already been completed by the existing text.
+ */
+    private _filterCompletedSubSegments;
+    private _getCompositeSuggestionsForPattern;
+    private _getCustomTokens;
+    private _deDupeCompositeSuggestions;
     private _createSuggestions;
-    private _createSuggestion;
+    private _createSuggestionOption;
     static suggestFor(text: string, pattern: Pattern, options?: AutoCompleteOptions): Suggestion;
     static suggestForWithCursor(cursor: Cursor, pattern: Pattern, options?: AutoCompleteOptions): Suggestion;
 }

package/dist/intellisense/SuggestionOption.d.ts

@@ -1,4 +1,20 @@
-export interface SuggestionOption {
-    text: string;
+import { Pattern } from "../patterns/Pattern";
+/**
+ * A CompositeSuggestion associated with a index to start at when inserting into existing text.
+ */
+export interface SuggestionOption extends CompositeSuggestion {
     startIndex: number;
 }
+/**
+ * Represents a composed suggestion, derived from potential next tokens defined by the pattern, and configured auto complete options
+ * text: represents the full composed text of the suggestion; a concatenated string of relevant suggestion segments.
+ */
+export interface CompositeSuggestion {
+    text: string;
+    suggestionSequence: SuggestionSegment[];
+}
+/** A segment of a parent composite suggestion and a reference to the pattern that this segment token was derived from. */
+export interface SuggestionSegment {
+    text: string;
+    pattern: Pattern;
+}

package/dist/patterns/InfiniteRepeat.d.ts

@@ -19,6 +19,7 @@ export declare class InfiniteRepeat implements Pattern {
     private _firstIndex;
     private _min;
     private _trimDivider;
+    private _patterns;
     get id(): string;
     get type(): string;
     get name(): string;

package/jest.config.js

@@ -1,4 +1,6 @@
 module.exports = {
+  "preset": 'ts-jest',
+  "testEnvironment": 'node',
   "roots": [
     "<rootDir>/src"
   ],

package/jest.coverage.config.js

@@ -1,4 +1,6 @@
 module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
   "roots": [
     "<rootDir>/src"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.3.9",
+  "version": "11.3.11",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",
@@ -33,12 +33,13 @@
     "parser-generator"
   ],
   "devDependencies": {
+    "@rollup/plugin-typescript": "^11.1.6",
     "@types/jest": "^26.0.23",
-    "jest": "^26.6.3",
+    "jest": "^30.1.3",
     "rollup": "^2.41.2",
-    "@rollup/plugin-typescript": "^11.1.6",
-    "ts-jest": "^26.5.3",
+    "ts-jest": "^29.4.4",
     "tslib": "^2.1.0",
     "typescript": "^4.2.3"
-  }
-}
+  },
+  "packageManager": "yarn@4.9.0+sha512.5f5f00843eae735dfab6f0442524603e987ceca55e98b36eb0120f4e58908e5b1406545321e46627dca97d15d562f23dc13fb96cabd4e6bc92d379f619001e4e"
+}

package/src/generator/delete.ts

@@ -0,0 +1,88 @@
+import { Context } from "../patterns/Context";
+import { Expression } from "../patterns/Expression";
+import { Literal } from "../patterns/Literal";
+import { Reference } from "../patterns/Reference";
+import { Repeat } from "../patterns/Repeat";
+import { Sequence } from "../patterns/Sequence";
+import { Options } from "../patterns/Options";
+import { Optional } from "../patterns/Optional";
+import { TakeUntil } from "../patterns/TakeUntil";
+
+new Context("expression",
+    new Expression("expression", [
+        new Sequence("prefix-expression", [
+            new Literal("pre", "pre"),
+            new Reference("expression")
+        ]),
+        new Sequence("postfix-expression", [
+            new Reference("expression"),
+            new Literal("post", "post")
+        ]),
+        new Sequence("infix-expression", [
+            new Reference("expression"),
+            new Literal(" and ", " and "),
+            new Reference("expression")
+        ]),
+        new Expression("item", [
+            new Options("names", [
+                new Literal("john", "John"),
+                new Literal("Jane", "Jane")
+            ]),
+            new Reference("array")
+        ])
+    ]), [
+    new Literal("john", "John"),
+    new Options("names", [
+        new Literal("john", "John"),
+        new Literal("Jane", "Jane")
+    ]),
+    new Literal("space", "\\s+"),
+    new Literal("comma", "\\s*,\\s*"),
+    new Expression("item", [
+        new Options("names", [
+            new Literal("john", "John"),
+            new Literal("Jane", "Jane")
+        ]),
+        new Reference("array")
+    ]),
+    new Repeat("items",
+        new Expression("item", [
+            new Options("names", [
+                new Literal("john", "John"),
+                new Literal("Jane", "Jane")
+            ]),
+            new Reference("array")
+        ]), { min: 1, divider: new Literal("comma", "\\s*,\\s*") }),
+    new Sequence("array", [
+        new Literal("[", "["),
+        new Optional("optional-space",
+            new Literal("space", "\\s+")),
+        new Optional("optional-items",
+            new Repeat("items",
+                new Expression("item", [
+                    new Options("names", [
+                        new Literal("john", "John"),
+                        new Literal("Jane", "Jane")
+                    ]),
+                    new Reference("array")
+                ]), { min: 1, divider: new Literal("comma", "\\s*,\\s*") })),
+        new Optional("optional-space",
+            new Literal("space", "\\s+")),
+        new Literal("]", "]")
+    ]),
+    new Sequence("prefix-expression", [
+        new Literal("pre", "pre"),
+        new Reference("expression")
+    ]),
+    new Sequence("postfix-expression", [
+        new Reference("expression"),
+        new Literal("post", "post")
+    ]),
+    new Sequence("infix-expression", [
+        new Reference("expression"),
+        new Literal(" and ", " and "),
+        new Reference("expression")
+    ]),
+    new TakeUntil("take-until",
+        new Literal("</script", "</script"))
+])

package/src/generator/generator.test.ts

@@ -16,6 +16,7 @@ describe("generator", () => {
             postfix-expression = expression + "post"
             infix-expression = expression + " and " + expression
             expression = prefix-expression | postfix-expression | infix-expression | item
+            take-until = ? -> | "</script"
         `;
 
         const visitor = new TypescriptVisitor();

package/src/generator/generator.ts

@@ -70,6 +70,9 @@ export class Generator {
                 case "sequence": {
                     return this._visitor.sequence(pattern, args, this._depth);
                 }
+                case "take-until": {
+                    return this._visitor.takeUntil(pattern, args, this._depth);
+                }
             }
             throw Error("Cannot find pattern.");
         });

package/src/generator/ivisitor.ts

@@ -20,4 +20,5 @@ export interface IVisitor {
     finiteRepeat(pattern: Pattern, depth: number): string
     rightAssociated(pattern: Pattern, args: string[], depth: number): string;
     sequence(pattern: Pattern, args: string[], depth: number): string;
+    takeUntil(pattern: Pattern, args: string[], depth: number): string;
 }

package/src/generator/typescriptVisitor.ts

@@ -7,6 +7,20 @@ import { Repeat } from "../patterns/Repeat";
 import { IGenerator } from "./igenerator";
 import { IVisitor } from "./ivisitor";
 
+const importMap: any = {
+    "literal": "Literal",
+    "optional": "Optional",
+    "options": "Options",
+    "reference": "Reference",
+    "regex": "Regex",
+    "repeat": "Repeat",
+    "right-associated": "RightAssociation",
+    "sequence": "Sequence",
+    "take-until": "TakeUntil",
+    "context": "Context",
+    "expression": "Expression"
+};
+
 export class TypescriptVisitor implements IVisitor {
     private _generator: IGenerator | null = null;
 
@@ -24,9 +38,11 @@ export class TypescriptVisitor implements IVisitor {
 
     end() { }
 
-    header(): string {
-        return "";
+    header( patterns: string[]): string {
+        console.log(patterns);
+        return `import { ${patterns.map(p => importMap[p]).join(", ")} } from "../index.ts";`;
     }
+
     footer(): string {
         return "";
     }
@@ -97,7 +113,6 @@ export class TypescriptVisitor implements IVisitor {
         const name = pattern.name;
         const regex = pattern as Regex;
         return `new Literal("${name}", "${this._escapeString(regex.regex)}")`;
-
     }
 
     infiniteRepeat(pattern: Pattern, depth: number): string {
@@ -143,6 +158,12 @@ export class TypescriptVisitor implements IVisitor {
         return `new Sequence("${name}", [${args.join(", ")}${this._generateTabs(depth)}])`;
     }
 
+    takeUntil(pattern: Pattern, args: string[], depth: number): string {
+        args = this._indent(args, depth + 1);
+        const name = pattern.name;
+        return `new TakeUntil("${name}", ${args.join("")})`;
+    }
+
     private _escapeString(value: string) {
         return value.replaceAll('"', '\\"');
     }

package/src/grammar/Grammar.test.ts

@@ -363,6 +363,7 @@ describe("Grammar", () => {
         space = " "
         full-name = first-name + space + last-name
         `;
+
         function resolveImport(resource: string) {
             expect(resource).toBe("some/path/to/file.cpat");
             return Promise.resolve({ expression: importExpression, resource });

package/src/grammar/Grammar.ts

@@ -289,6 +289,8 @@ export class Grammar {
     }
 
     private _isRecursivePattern(name: string, pattern: Pattern) {
+        // Because we don't know if the pattern is a sequence with a reference we have to just assume it is.
+        // The better solution here would be to not have options at all and just use expresssion pattern instead.
         if (pattern.type === "reference") {
             return true;
         }

package/src/grammar/patterns.test.ts

@@ -35,4 +35,40 @@ describe("Patterns String Template Literal", () => {
         result && result.ast && result.ast.findAll(n => n.name.includes("space")).forEach(n => n.remove());
         expect(result?.ast?.value).toBe("<div><div></div><div></div></div>");
     });
+
+    test("Expression Pattern", () => {
+        const { expr } = patterns`
+        integer = /\\d+/
+        operator = "+" | "-" | "*" | "/"
+        unary-operator = "+" | "-"
+        postfix-operator = "++" | "--"
+        binary-expr = expr + operator + expr
+        unary-expr = unary-operator + expr
+        postfix-expr = expr + postfix-operator
+        expr = postfix-expr | unary-expr | binary-expr | integer
+        `;
+
+        const result = expr.exec("-10++");
+        const ast = result?.ast;
+
+        expect(ast?.name).toBe("unary-expr");
+
+        expect(ast?.children[0].type).toBe("literal");
+        expect(ast?.children[0].name).toBe("-");
+        expect(ast?.children[0].value).toBe("-");
+
+        expect(ast?.children[1].type).toBe("expression");
+        expect(ast?.children[1].name).toBe("postfix-expr");
+        expect(ast?.children[1].value).toBe("10++");
+
+        expect(ast?.children[1].children[0].type).toBe("regex");
+        expect(ast?.children[1].children[0].name).toBe("integer");
+        expect(ast?.children[1].children[0].value).toBe("10");
+
+        expect(ast?.children[1].children[1].type).toBe("literal");
+        expect(ast?.children[1].children[1].name).toBe("++");
+        expect(ast?.children[1].children[1].value).toBe("++");
+
+        expect(result?.ast?.value).toBe("-10++");
+    });
 });