react-dsl-editor 0.3.4 → 0.4.1

package/dist/index.d.ts

@@ -40,29 +40,30 @@ export declare function DslEditor<T extends string>({ code, onChange, onParsed,
 
 export declare interface DSLError {
     message: string;
+    expected?: string[];
     start: number;
     end: number;
+    depth: number;
 }
 
 export declare class DSLParser<T extends string> {
     private readonly grammar;
     constructor(grammar: GrammarNode<T>);
+    private _parseStrict;
+    parseStrict(input: string): ParserSuccess<T> | undefined;
     parse(input: string): DSL<T>;
 }
 
-export declare const eof: GrammarNode;
+export declare const eof: GrammarNode<never>;
 
-export declare function error<T extends string>(param: Omit<ParserError<T>, 'offset'>): {
-    offset: number;
-    grammar: GrammarNode<T>;
-    got: string;
-    expected: string[];
-};
+export declare function error<T extends string>(param: ParserError<T>): ParserError<T>;
+
+export declare type FaultToleranceMode = 'skip-parser' | 'skip-input' | 'fuzzy-match' | 'partial-match';
 
 export declare interface GrammarNode<T extends string = never> {
     type: T;
     suggestions(): string[];
-    parse(text: string, context: ParserContext): ParserResult<T>;
+    parse(text: string, context: ParserContext<T>): ParserResult<T>;
     children: GrammarNode<T>[];
     meta?: Record<string, unknown>;
 }
@@ -73,15 +74,21 @@ export declare function isParserSuccess<T extends string>(result: ParserResult<T
 
 export declare function named<T extends string, K extends string>(name: T, child: GrammarNode<K>): GrammarNode<T | K>;
 
+export declare const newline: GrammarNode<never>;
+
+export declare function nodeName<T extends string>(node: {
+    grammar: GrammarNode<T>;
+}): T | undefined;
+
 export declare type NodeTypes<T> = _NodeTypes<T> | 'error';
 
 declare type _NodeTypes<T> = T extends GrammarNode<infer U> ? U : never;
 
 export declare function optional<T extends string>(child: GrammarNode<T>): GrammarNode<T>;
 
-export declare interface ParserContext {
-    faultTolerant: boolean;
-    faultCorrection<T extends string>(parse: ParserResult<T>, grammar: GrammarNode<T>): ParserResult<T>;
+export declare interface ParserContext<T extends string> {
+    path: GrammarNode<T>[];
+    handleTerminalError(text: string, context: ParserContext<T>, grammar: GrammarNode<T>): ParserResult<T>;
 }
 
 export declare interface ParserError<T extends string = never> {
@@ -89,6 +96,7 @@ export declare interface ParserError<T extends string = never> {
     got: string;
     expected: string[];
     offset: number;
+    path: GrammarNode<T>[];
 }
 
 export declare type ParserResult<T extends string = never> = ParserSuccess<T> | ParserError<T>;
@@ -97,13 +105,15 @@ export declare interface ParserSuccess<T extends string = never> {
     text: string;
     grammar: GrammarNode<T>;
     children: ParserSuccess<T>[];
-    recoverableError?: boolean;
+    errorLabel?: ParserError<T>;
 }
 
 export declare class ParsingError extends Error {
     constructor(msg: string);
 }
 
+export declare function pathToString(v: GrammarNode<string>[]): string;
+
 export declare function pattern(regex: RegExp): GrammarNode<never>;
 
 export declare const rational: GrammarNode<never>;
@@ -127,6 +137,8 @@ declare const themes: {
 
 export declare function visit<T extends string, V = string>(parserResult: ParserSuccess<T>, type: T[], extractor?: (node: ParserSuccess<T>) => V): V[];
 
+export declare function visitPredicate<T extends string, V = string>(parserResult: ParserSuccess<T>, filter: (v: ParserSuccess<T>) => boolean, extractor?: (node: ParserSuccess<T>) => V): V[];
+
 export declare const ws: GrammarNode<never>;
 
 export { }