react-dsl-editor 0.2.3 → 0.3.0

package/dist/index.d.ts

@@ -1,86 +1,106 @@
-import { CSSProperties } from 'react';
 import { JSX } from 'react/jsx-runtime';
 import { TextareaHTMLAttributes } from 'react';
 
-export declare function alternative<T extends string>(type?: T, ...seq: Parse<T>[]): Parse<T>;
+export declare function alternative<T extends string>(...seq: GrammarNode<T>[]): GrammarNode<T>;
 
-export declare function appendOffset<T>(error: ParserError<T>, offset: number): ParserError<T>;
+export declare function asException<T extends string>(error: ParserError<T>): ParsingError;
 
-export declare function appendOffsets<T>(errors: ParserError<T>[], offsets: number): ParserError<T>[];
-
-export declare interface ASTNode<T extends string> {
-    type: T;
+export declare interface CSTNode<T extends string> {
     text: string;
-    children?: ASTNode<T>[];
-    errors: ParserError<T>[];
     offset: number;
+    end: number;
+    grammar: GrammarNode<T>;
+    children?: CSTNode<T>[];
+}
+
+export declare type CSTOf<T> = CSTNode<_NodeTypes<T>>;
+
+export declare interface DSL<T extends string> {
+    cst: CSTNode<T>;
+    terminals: CSTNode<T>[];
+    result: ParserSuccess<T>;
 }
 
-export declare function DslEditor<T extends string>({ code, onChange, onParsed, grammar, wrap, suggestions: clientSuggestions, className, styles, ...textareaProps }: {
+export declare function DslEditor<T extends string>({ code, onChange, onParsed, grammar, wrap, suggestions: clientSuggestions, className, ...textareaProps }: {
     code: string;
     onChange: (text: string) => void;
-    onParsed?: (ast: ParserResult<T>) => void;
-    grammar: Parse<T>;
+    onParsed?: (ast: ParserSuccess<T>) => void;
+    grammar: GrammarNode<T>;
     wrap?: boolean;
     className?: string;
-    styles?: Partial<Record<T | 'error', CSSProperties>>;
-    suggestions?: (type: T | 'error') => string[] | undefined;
+    suggestions?: (node: CSTNode<T>) => string[] | undefined;
 } & Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'wrap' | 'onChange'>): JSX.Element;
 
-export declare function isParserError<T extends string>(result: ParserResult<T>): boolean;
+export declare class DSLParser<T extends string> {
+    private readonly grammar;
+    constructor(grammar: GrammarNode<T>);
+    private _parse;
+    parse(input: string): DSL<T>;
+}
 
-export declare function isParserSuccess<T extends string>(result: ParserResult<T>): boolean;
+export declare const eof: GrammarNode;
 
-export declare type NodeTypes<T> = _NodeTypes<T> | 'error';
+export declare function error<T extends string>(param: ParserError<T>): ParserError<T>;
 
-declare type _NodeTypes<T> = T extends Parse<infer U> ? U : never;
+export declare interface GrammarNode<T extends string = never> {
+    type: T;
+    suggestions(): string[];
+    parse(text: string, context: ParserContext): ParserResult<T>;
+    children: GrammarNode<T>[];
+    meta?: Record<string, unknown>;
+}
 
-export declare function optional<T extends string>(subparser: Parse<T>): Parse<T>;
+export declare function isParserError<T extends string>(result: ParserResult<T>): result is ParserError<T>;
 
-export declare const optionalWhitespace: Parse<"optionalWhitespace">;
+export declare function isParserSuccess<T extends string>(result: ParserResult<T>): result is ParserSuccess<T>;
 
-export declare type Parse<T extends string> = (text: string) => ParserResult<T>;
+export declare function named<T extends string, K extends string>(name: T, child: GrammarNode<K>): GrammarNode<T | K>;
 
-export declare class Parser<T extends string> {
-    private readonly parser;
-    constructor(parser: Parse<T>);
-    parse(input: string): ASTNode<T>;
+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 ParserError<T> {
-    offset: number;
-    expected: string | RegExp;
+export declare interface ParserError<T extends string = never> {
+    grammar: GrammarNode<T>;
     got: string;
-    type: T;
+    expected: string[];
 }
 
-export declare interface ParserResult<T extends string> {
-    type: T;
+export declare type ParserResult<T extends string = never> = ParserSuccess<T> | ParserError<T>;
+
+export declare interface ParserSuccess<T extends string = never> {
     text: string;
-    children?: ParserResult<T>[];
-    errors: ParserError<T>[];
+    grammar: GrammarNode<T>;
+    children: ParserSuccess<T>[];
 }
 
 export declare class ParsingError extends Error {
     constructor(msg: string);
 }
 
-export declare function pattern(regex: string): Parse<'pattern'>;
+export declare function pattern(regex: RegExp): GrammarNode<never>;
 
-export declare function pattern<T extends string>(regex: string, type: T): Parse<T>;
+export declare const rational: GrammarNode<never>;
 
-export declare const rational: Parse<"rational">;
+export declare function repeat<T extends string>(child: GrammarNode<T>, min?: number, max?: number): GrammarNode<T>;
 
-export declare function repeat<T extends string>(type: T | undefined, parser: Parse<T>, min?: number, max?: number): Parse<T>;
+export declare function seq<T extends string>(...nodes: GrammarNode<T>[]): GrammarNode<T>;
 
-export declare function seq<T extends string>(type?: T, ...p: Parse<T>[]): Parse<T | 'optionalWhitespace'>;
+export declare function sequence<T extends string>(...nodes: GrammarNode<T>[]): GrammarNode<T>;
 
-export declare function sequence<T extends string>(type?: T, ...seq: Parse<T>[]): Parse<T>;
+export declare function success<T extends string>(param: ParserSuccess<T>): ParserSuccess<T>;
 
-export declare function term<T extends string>(str: T): Parse<T>;
+export declare function term(str: string): GrammarNode<never>;
 
-export declare function term<T extends string>(str: string, type: T): Parse<T>;
+export declare function visit<T extends string, V = string>(parserResult: ParserSuccess<T>, type: T, extractor?: (node: ParserSuccess<T>) => V): V[];
 
-export declare const ws: Parse<"space" | "ws">;
+export declare const ws: GrammarNode<never>;
 
 export { }