react-dsl-editor 0.3.2 → 0.4.0

package/dist/index.d.ts

@@ -17,6 +17,8 @@ export declare interface CSTNode<T extends string> {
 
 export declare type CSTOf<T> = CSTNode<_NodeTypes<T>>;
 
+export declare function defaultSyntaxColors(theme: keyof typeof themes): (node: CSTNode<string>) => CSSProperties | undefined;
+
 export declare interface DSL<T extends string> {
     cst: CSTNode<T>;
     terminals: CSTNode<T>[];
@@ -38,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>;
 }
@@ -71,15 +74,19 @@ 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 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> {
@@ -87,6 +94,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>;
@@ -114,10 +122,15 @@ export declare function sequence<T extends string>(...nodes: GrammarNode<T>[]):
 
 export declare function success<T extends string>(param: ParserSuccess<T>): ParserSuccess<T>;
 
-declare type SyntaxColorsProvider = (node: CSTNode<string>) => CSSProperties | undefined;
+export declare type SyntaxColorsProvider = (node: CSTNode<string>) => CSSProperties | undefined;
 
 export declare function term(str: string): GrammarNode<never>;
 
+declare const themes: {
+    readonly light: string[];
+    readonly dark: string[];
+};
+
 export declare function visit<T extends string, V = string>(parserResult: ParserSuccess<T>, type: T[], extractor?: (node: ParserSuccess<T>) => V): V[];
 
 export declare const ws: GrammarNode<never>;