@fc-components/monaco-editor 0.1.27 → 0.3.1

package/dist/expr/__tests__/__mocks__/monaco-editor.d.ts

@@ -0,0 +1,28 @@
+export declare const MarkerSeverity: {
+    Warning: number;
+    Error: number;
+    Info: number;
+    Hint: number;
+};
+export declare const editor: {
+    setModelMarkers: () => void;
+};
+export declare const languages: {
+    CompletionItemKind: {
+        Keyword: number;
+        Function: number;
+    };
+    CompletionItemInsertTextRule: {
+        InsertAsSnippet: number;
+    };
+};
+export declare const KeyMod: {
+    Shift: number;
+    CtrlCmd: number;
+};
+export declare const KeyCode: {
+    Enter: number;
+    KeyF: number;
+};
+export declare const Selection: () => void;
+export declare const Range: () => void;

package/dist/expr/completion/getCompletionProvider.d.ts

@@ -0,0 +1,4 @@
+import * as monaco from 'monaco-editor';
+export declare const getExprCompletionProvider: () => {
+    provideCompletionItems(model: monaco.editor.ITextModel, position: monaco.Position, _context: monaco.languages.CompletionContext, _token: monaco.CancellationToken): monaco.languages.ProviderResult<monaco.languages.CompletionList>;
+};

package/dist/expr/expr.d.ts

@@ -0,0 +1,83 @@
+export declare const languageConfiguration: {
+    wordPattern: RegExp;
+    comments: {
+        lineComment: string;
+        blockComment: [string, string];
+    };
+    brackets: any;
+    autoClosingPairs: any;
+    surroundingPairs: any;
+    folding: {
+        offSide: boolean;
+    };
+};
+export declare const language: {
+    defaultToken: string;
+    tokenPostfix: string;
+    brackets: {
+        open: string;
+        close: string;
+        token: string;
+    }[];
+    keywords: string[];
+    builtinFunctions: string[];
+    operators: string[];
+    escapes: RegExp;
+    digits: RegExp;
+    hexdigits: RegExp;
+    octdigits: RegExp;
+    bindigits: RegExp;
+    tokenizer: {
+        root: ((string | RegExp)[] | {
+            include: string;
+        } | (RegExp | {
+            cases: {
+                '@builtinFunctions': string;
+                '@default': string;
+            };
+        })[] | (RegExp | {
+            cases: {
+                '@keywords': string;
+                '@default': string;
+            };
+        })[])[];
+        whitespace: (string | RegExp)[][];
+        comments: ((string | RegExp)[] | (RegExp | {
+            token: string;
+            next: string;
+        })[])[];
+        comment: ((string | RegExp)[] | (RegExp | {
+            token: string;
+            next: string;
+        })[])[];
+        numbers: (string | RegExp)[][];
+        strings: (RegExp | {
+            token: string;
+            next: string;
+        })[][];
+        string_double: ((string | RegExp)[] | (RegExp | {
+            token: string;
+            next: string;
+        })[])[];
+        string_single: ((string | RegExp)[] | (RegExp | {
+            token: string;
+            next: string;
+        })[])[];
+        string_backtick: ((string | RegExp)[] | (RegExp | {
+            token: string;
+            next: string;
+        })[])[];
+        bytes: (RegExp | {
+            token: string;
+            next: string;
+        })[][];
+        bytes_double: ((string | RegExp)[] | (RegExp | {
+            token: string;
+            next: string;
+        })[])[];
+        bytes_single: ((string | RegExp)[] | (RegExp | {
+            token: string;
+            next: string;
+        })[])[];
+    };
+};

package/dist/expr/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { ExprEditorProps } from './types';
+export default function ExprEditor(props: ExprEditorProps): React.JSX.Element;

package/dist/expr/parser/index.d.ts

@@ -0,0 +1,3 @@
+export { ExprParser } from './parser';
+export { Lexer } from './lexer';
+export * from './types';

package/dist/expr/parser/lexer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Expr-lang lexer/tokenizer
+ * Handles: identifiers, numbers, strings, bytes literals, operators, comments
+ */
+import { Token } from './types';
+export declare class Lexer {
+    private input;
+    private pos;
+    private line;
+    private column;
+    private startLine;
+    private startColumn;
+    reset(input: string): void;
+    next(): Token;
+    private skipWhitespace;
+    private skipComments;
+    private readString;
+    private readBacktickString;
+    private readByteLiteral;
+    private readNumber;
+    private readIdentOrKeyword;
+    private readOperatorOrBracket;
+    private isDigit;
+    private isIdentStart;
+    private isIdentPart;
+    private makeToken;
+}

package/dist/expr/parser/parser.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Expr-lang recursive descent parser
+ * Ported from Go's expr-lang parser with precedence climbing algorithm
+ */
+import { ParseError } from './types';
+export declare class ExprParser {
+    private lexer;
+    private current;
+    private errors;
+    constructor();
+    /**
+     * Parse an expr-lang expression and return any syntax errors.
+     * Returns empty array if the expression is valid.
+     */
+    parse(input: string): ParseError[];
+    private advance;
+    private curKind;
+    private curVal;
+    private expect;
+    private error;
+    private errorAt;
+    /**
+     * parseSequenceExpression parses multiple expressions separated by semicolons.
+     */
+    private parseSequenceExpression;
+    /**
+     * parseExpression uses precedence climbing to parse binary expressions.
+     */
+    private parseExpression;
+    /**
+     * parsePrimary handles unary operators, parentheses, and the #/. pointer prefix.
+     */
+    private parsePrimary;
+    /**
+     * parseSecondary handles identifiers, literals, arrays, and maps.
+     */
+    private parseSecondary;
+    /**
+     * parsePostfixExpression handles .member, ?.member, [index], [from:to], and calls after the primary.
+     */
+    private parsePostfixExpression;
+    /**
+     * parseVariableDeclaration parses "let name = value; rest"
+     */
+    private parseVariableDeclaration;
+    /**
+     * parseConditionalIf parses "if expr { expr1 } else { expr2 }" or "if expr { expr1 } else if ..."
+     */
+    private parseConditionalIf;
+    /**
+     * parseConditional parses "expr ? expr1 : expr2" or "expr ?: expr2"
+     */
+    private parseConditional;
+    /**
+     * parseArguments parses function call arguments: (arg1, arg2, ...)
+     */
+    private parseArguments;
+    /**
+     * parseArrayExpression parses "[elem1, elem2, ...]"
+     */
+    private parseArrayExpression;
+    /**
+     * parseMapExpression parses "{key: value, ...}"
+     */
+    private parseMapExpression;
+}

package/dist/expr/parser/types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Expr-lang token types and AST definitions
+ */
+export declare enum TokenKind {
+    Identifier = "Identifier",
+    Number = "Number",
+    String = "String",
+    Operator = "Operator",
+    Bracket = "Bracket",
+    EOF = "EOF"
+}
+export interface Token {
+    kind: TokenKind;
+    value: string;
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+}
+export interface ParseError {
+    message: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}
+export declare const EOF_TOKEN: Token;
+export declare const OPERATOR_PRECEDENCE: Record<string, number>;
+export declare const UNARY_OPERATORS: Set<string>;
+export declare const RIGHT_ASSOCIATIVE: Set<string>;
+export declare const COMPARISON_OPERATORS: Set<string>;
+export declare const KEYWORDS: Set<string>;

package/dist/expr/types.d.ts

@@ -0,0 +1,17 @@
+export interface ExprEditorProps {
+    className?: string;
+    maxHeight?: number | string;
+    fontSize?: number;
+    size?: 'small' | 'middle' | 'large';
+    theme?: 'light' | 'dark';
+    value?: string;
+    placeholder?: string;
+    enableAutocomplete?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+    onChange?: (value: string) => void;
+    onEnter?: (value: string) => void;
+    onBlur?: (value: string) => void;
+    onFocus?: (value: string) => void;
+    editorDidMount?: (editor: any) => void;
+}

package/dist/expr/validation.d.ts

@@ -0,0 +1,12 @@
+import * as monaco from 'monaco-editor';
+/**
+ * Validate an expr-lang expression and return Monaco editor markers.
+ * Uses the recursive descent parser for syntax errors,
+ * plus regex-based checks for structural issues like unbalanced quotes/brackets.
+ */
+export declare const validateExpr: (expr: string) => Omit<monaco.editor.IMarker, 'owner' | 'resource'>[];
+/**
+ * Validate an expr-lang expression and return a plain array of human-readable error messages.
+ * Returns an empty array if the expression is valid.
+ */
+export declare function checkExpr(expr: string): string[];

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import promql from './promql';
 import yaml from './yaml';
 import sql from './sql';
+import expr from './expr';
 export { promql as PromQLMonacoEditor };
 export { yaml as YamlMonacoEditor };
 export { sql as SqlMonacoEditor };
+export { expr as ExprMonacoEditor };