clarity-pattern-parser 4.0.3 → 6.0.0

package/dist/patterns/Or.d.ts

@@ -1,22 +1,33 @@
-import Pattern from "./Pattern";
-import ParseError from "./ParseError";
-import Cursor from "../Cursor";
-import Node from "../ast/Node";
-export default class Or extends Pattern {
-    patternIndex: number;
-    errors: ParseError[];
-    node: Node | null;
-    cursor: Cursor | null;
-    mark: number;
-    parseError: ParseError | null;
-    constructor(name: string, patterns: Pattern[], isOptional?: boolean);
-    private assertArguments;
-    private resetState;
-    private safelyGetCursor;
-    parse(cursor: Cursor): Node | null;
-    private tryToParse;
-    private processError;
-    private processResult;
-    clone(name?: string, isOptional?: boolean): Or;
-    getTokens(): string[];
-}
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+export declare class Or implements Pattern {
+    private _type;
+    private _name;
+    private _parent;
+    private _children;
+    private _isOptional;
+    private _firstIndex;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get isOptional(): boolean;
+    constructor(name: string, options: Pattern[], isOptional?: boolean);
+    private _assignChildrenToParent;
+    test(text: string): boolean;
+    exec(text: string): {
+        ast: Node | null;
+        cursor: Cursor;
+    };
+    parse(cursor: Cursor): Node | null;
+    private _tryToParse;
+    getTokens(): string[];
+    getTokensAfter(_childReference: Pattern): string[];
+    getNextTokens(): string[];
+    getPatternsAfter(_childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    findPattern(predicate: (p: Pattern) => boolean): Pattern | null;
+    clone(name?: string, isOptional?: boolean): Pattern;
+}

package/dist/patterns/ParseError.d.ts

@@ -1,8 +1,6 @@
-import Pattern from "./Pattern";
-export default class ParseError {
-    message: string;
-    name: string;
-    index: number;
-    pattern: Pattern;
-    constructor(message: string, index: number, pattern: Pattern);
-}
+import { Pattern } from "./Pattern";
+export declare class ParseError {
+    index: number;
+    pattern: Pattern;
+    constructor(index: number, pattern: Pattern);
+}

package/dist/patterns/ParseResult.d.ts

@@ -0,0 +1,6 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+export interface ParseResult {
+    ast: Node | null;
+    cursor: Cursor;
+}

package/dist/patterns/Pattern.d.ts

@@ -1,26 +1,20 @@
-import Cursor from "../Cursor";
-import Node from "../ast/Node";
-export default abstract class Pattern {
-    protected _type: string;
-    protected _name: string;
-    protected _children: Pattern[];
-    protected _parent: Pattern | null;
-    protected _isOptional: boolean;
-    get isOptional(): boolean;
-    constructor(type: string, name: string, children?: Pattern[], isOptional?: boolean);
-    abstract parse(cursor: Cursor): Node | null;
-    exec(text: string): Node | null;
-    test(text: string): boolean;
-    get name(): string;
-    get type(): string;
-    get parent(): Pattern | null;
-    set parent(value: Pattern | null);
-    get children(): Pattern[];
-    set children(value: Pattern[]);
-    abstract clone(name?: string): Pattern;
-    abstract getTokens(): string[];
-    getTokenValue(): string | null;
-    getNextTokens(): string[];
-    private cloneChildren;
-    private assignAsParent;
-}
+import { Cursor } from "./Cursor";
+import { Node } from "../ast/Node";
+import { ParseResult } from "./ParseResult";
+export interface Pattern {
+    type: string;
+    name: string;
+    parent: Pattern | null;
+    children: Pattern[];
+    isOptional: boolean;
+    parse(cursor: Cursor): Node | null;
+    exec(text: string): ParseResult;
+    test(text: string): boolean;
+    clone(name?: string, isOptional?: boolean): Pattern;
+    getTokens(): string[];
+    getTokensAfter(childReference: Pattern): string[];
+    getPatternsAfter(childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    getNextTokens(): string[];
+    findPattern(predicate: (p: Pattern) => boolean): Pattern | null;
+}

package/dist/patterns/Reference.d.ts

@@ -1,12 +1,34 @@
-import Pattern from "./Pattern";
-import Cursor from "../Cursor";
-export default class Reference extends Pattern {
-    constructor(name: string, isOptional?: boolean);
-    private getRoot;
-    private findPattern;
-    private walkTheTree;
-    parse(cursor: Cursor): import("..").Node | null;
-    clone(name?: string, isOptional?: boolean): Reference;
-    private safelyGetPattern;
-    getTokens(): string[];
-}
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+export declare class Reference implements Pattern {
+    private _type;
+    private _name;
+    private _parent;
+    private _isOptional;
+    private _pattern;
+    private _children;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get isOptional(): boolean;
+    constructor(name: string, isOptional?: boolean);
+    test(text: string): boolean;
+    exec(text: string): {
+        ast: Node | null;
+        cursor: Cursor;
+    };
+    parse(cursor: Cursor): Node | null;
+    private _getPatternSafely;
+    private _findPattern;
+    private _getRoot;
+    getTokens(): string[];
+    getTokensAfter(_lastMatched: Pattern): string[];
+    getNextTokens(): string[];
+    getPatternsAfter(_childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    findPattern(_predicate: (p: Pattern) => boolean): Pattern | null;
+    clone(name?: string, isOptional?: boolean): Pattern;
+}

package/dist/patterns/Regex.d.ts

@@ -1,21 +1,41 @@
-import Node from "../ast/Node";
-import Pattern from "./Pattern";
-import Cursor from "../Cursor";
-export default class Regex extends Pattern {
-    private regexString;
-    private regex;
-    private node;
-    private cursor;
-    private substring;
-    constructor(name: string, regex: string, isOptional?: boolean);
-    private assertArguments;
-    parse(cursor: Cursor): Node | null;
-    private resetState;
-    private tryToParse;
-    private processResult;
-    private processError;
-    private safelyGetCursor;
-    clone(name?: string, isOptional?: boolean): Regex;
-    getTokenValue(): string;
-    getTokens(): string[];
-}
+import { Node } from "../ast/Node";
+import { Pattern } from "./Pattern";
+import { Cursor } from "./Cursor";
+export declare class Regex implements Pattern {
+    private _type;
+    private _name;
+    private _isOptional;
+    private _parent;
+    private _originalRegexString;
+    private _regex;
+    private _node;
+    private _cursor;
+    private _substring;
+    private _tokens;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get isOptional(): boolean;
+    constructor(name: string, regex: string, isOptional?: boolean);
+    private assertArguments;
+    test(text: string): boolean;
+    exec(text: string): {
+        ast: Node | null;
+        cursor: Cursor;
+    };
+    parse(cursor: Cursor): Node | null;
+    private resetState;
+    private tryToParse;
+    private processResult;
+    private processError;
+    clone(name?: string, isOptional?: boolean): Regex;
+    getTokens(): string[];
+    getTokensAfter(_childReference: Pattern): string[];
+    getNextTokens(): string[];
+    getPatternsAfter(_childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    findPattern(_predicate: (p: Pattern) => boolean): Pattern | null;
+    setTokens(tokens: string[]): void;
+}

package/dist/patterns/Repeat.d.ts

@@ -1,20 +1,38 @@
-import Pattern from "./Pattern";
-import Node from "../ast/Node";
-import Cursor from "../Cursor";
-export default class Repeat extends Pattern {
-    _pattern: Pattern;
-    _divider: Pattern;
-    nodes: Node[];
-    cursor: Cursor;
-    mark: number;
-    node: Node | null;
-    constructor(name: string, pattern: Pattern, divider?: Pattern, isOptional?: boolean);
-    private assertArguments;
-    private _reset;
-    parse(cursor: Cursor): Node | null;
-    private tryToParse;
-    private processResult;
-    private safelyGetCursor;
-    clone(name?: string, isOptional?: boolean): Repeat;
-    getTokens(): string[];
-}
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+export declare class Repeat implements Pattern {
+    private _type;
+    private _name;
+    private _parent;
+    private _children;
+    private _pattern;
+    private _divider;
+    private _isOptional;
+    private _nodes;
+    private _firstIndex;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get isOptional(): boolean;
+    constructor(name: string, pattern: Pattern, divider?: Pattern, isOptional?: boolean);
+    private _assignChildrenToParent;
+    test(text: string): boolean;
+    exec(text: string): {
+        ast: Node | null;
+        cursor: Cursor;
+    };
+    parse(cursor: Cursor): Node | null;
+    private tryToParse;
+    private createNode;
+    private getLastValidNode;
+    getTokens(): string[];
+    getTokensAfter(childReference: Pattern): string[];
+    getNextTokens(): string[];
+    getPatternsAfter(childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    findPattern(predicate: (p: Pattern) => boolean): Pattern | null;
+    clone(name?: string, isOptional?: boolean): Pattern;
+}

package/dist/patterns/clonePatterns.d.ts

@@ -0,0 +1,2 @@
+import { Pattern } from "./Pattern";
+export declare function clonePatterns(patterns: Pattern[], isOptional?: boolean): Pattern[];

package/dist/patterns/filterOutNull.d.ts

@@ -0,0 +1,2 @@
+import { Node } from "../ast/Node";
+export declare function filterOutNull(nodes: (Node | null)[]): Node[];

package/dist/patterns/findPattern.d.ts

@@ -0,0 +1,2 @@
+import { Pattern } from "./Pattern";
+export declare function findPattern(pattern: Pattern, predicate: (pattern: Pattern) => boolean): Pattern | null;

package/dist/patterns/getNextPattern.d.ts

@@ -0,0 +1,2 @@
+import { Pattern } from "./Pattern";
+export declare function getNextPattern(pattern: Pattern): Pattern | null;

package/jest.config.js

@@ -9,4 +9,5 @@ module.exports = {
   "transform": {
     "^.+\\.(ts|tsx)$": "ts-jest"
   },
-}
+  coverageReporters: ["lcov", "text-summary"],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "4.0.3",
+  "version": "6.0.0",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",
@@ -8,17 +8,16 @@
   "types": "./dist/index.d.ts",
   "scripts": {
     "build": "rollup -c -m",
-    "test": "jest"
+    "test": "jest --coverage"
   },
   "keywords": [],
   "devDependencies": {
     "@types/jest": "^26.0.23",
     "jest": "^26.6.3",
     "rollup": "^2.41.2",
-    "rollup-plugin-typescript2": "^0.30.0",
+    "@rollup/plugin-typescript": "^11.1.6",
     "ts-jest": "^26.5.3",
     "tslib": "^2.1.0",
     "typescript": "^4.2.3"
-  },
-  "dependencies": {}
+  }
 }

package/rollup.config.js

@@ -1,4 +1,4 @@
-import typescript from "rollup-plugin-typescript2";
+import typescript from "@rollup/plugin-typescript";
 import pkg from "./package.json";
 
 export default {