@fincity/kirun-js 3.1.4 → 3.2.0

package/dist/types.d.ts

@@ -864,6 +864,369 @@ export class StatementGroup extends AbstractStatement {
     static from(json: any): StatementGroup;
     toJSON(): any;
 }
+/**
+ * Token types for DSL lexer
+ */
+export enum DSLTokenType {
+    KEYWORD = "KEYWORD",
+    IDENTIFIER = "IDENTIFIER",
+    NUMBER = "NUMBER",
+    STRING = "STRING",
+    BACKTICK_STRING = "BACKTICK_STRING",// `...` for expressions
+    BOOLEAN = "BOOLEAN",
+    NULL = "NULL",
+    COLON = "COLON",// :
+    COMMA = "COMMA",// ,
+    DOT = "DOT",// .
+    EQUALS = "EQUALS",// =
+    OPERATOR = "OPERATOR",// + - * / % < > ! ? & | @ ^ ~
+    LEFT_PAREN = "LEFT_PAREN",// (
+    RIGHT_PAREN = "RIGHT_PAREN",// )
+    LEFT_BRACE = "LEFT_BRACE",// {
+    RIGHT_BRACE = "RIGHT_BRACE",// }
+    LEFT_BRACKET = "LEFT_BRACKET",// [
+    RIGHT_BRACKET = "RIGHT_BRACKET",// ]
+    NEWLINE = "NEWLINE",
+    COMMENT = "COMMENT",
+    WHITESPACE = "WHITESPACE",
+    EOF = "EOF"
+}
+/**
+ * Position information for tokens
+ */
+export class SourceLocation {
+    line: number;
+    column: number;
+    startPos: number;
+    endPos: number;
+    constructor(line: number, column: number, startPos: number, endPos: number);
+    toString(): string;
+}
+/**
+ * Token class with value and position tracking
+ */
+export class DSLToken {
+    type: DSLTokenType;
+    value: string;
+    location: SourceLocation;
+    constructor(type: DSLTokenType, value: string, location: SourceLocation);
+    toString(): string;
+    is(type: DSLTokenType, value?: string): boolean;
+}
+/**
+ * Check if a string is a keyword
+ */
+export function isKeyword(str: string): boolean;
+/**
+ * Check if a string is a block name
+ */
+export function isBlockName(str: string): boolean;
+/**
+ * Check if a string is a primitive type
+ */
+export function isPrimitiveType(str: string): boolean;
+/**
+ * Lexer error with position information
+ */
+export class LexerError extends Error {
+    location?: SourceLocation | undefined;
+    context?: string | undefined;
+    constructor(message: string, location?: SourceLocation | undefined, context?: string | undefined);
+}
+/**
+ * DSL Lexer - Tokenizes DSL text into tokens
+ *
+ * Features:
+ * - Keyword recognition
+ * - String literals with escape sequences
+ * - Number literals (integers and floats)
+ * - Comment stripping (single-line and block comments)
+ * - Position tracking for error messages
+ */
+export class DSLLexer {
+    constructor(input: string);
+    /**
+     * Tokenize the input string
+     */
+    tokenize(): DSLToken[];
+}
+/**
+ * Base class for all AST nodes
+ */
+export abstract class ASTNode {
+    readonly type: string;
+    readonly location: SourceLocation;
+    constructor(type: string, location: SourceLocation);
+    /**
+     * Convert AST node to JSON (for debugging/inspection)
+     */
+    abstract toJSON(): any;
+    /**
+     * Pretty-print the AST node
+     */
+    toString(): string;
+}
+/**
+ * Complex value node - represents literal values
+ * Used for parameter values that are objects, arrays, or primitives (strings, numbers, booleans, null)
+ */
+export class ComplexValueNode extends ASTNode {
+    value: any;
+    constructor(value: any, location: SourceLocation);
+    toJSON(): any;
+}
+/**
+ * Expression node - wraps KIRun Expression
+ */
+export class ExpressionNode extends ASTNode {
+    expressionText: string;
+    parsedExpression?: Expression;
+    constructor(expressionText: string, location: SourceLocation);
+    /**
+     * Parse the expression using KIRun Expression parser
+     */
+    parse(): void;
+    toJSON(): any;
+}
+/**
+ * Schema node - represents a schema specification
+ * Can be either a simple string (e.g., "INTEGER", "ARRAY OF STRING")
+ * or a complex JSON Schema object
+ */
+export class SchemaNode extends ASTNode {
+    schemaSpec: string | object;
+    constructor(schemaSpec: string | object, location: SourceLocation);
+    toJSON(): any;
+}
+/**
+ * Schema literal node - represents inline schema definitions with default values
+ * Example: (ARRAY OF INTEGER) WITH DEFAULT VALUE []
+ */
+export class SchemaLiteralNode extends ASTNode {
+    schema: SchemaNode;
+    defaultValue: ExpressionNode | undefined;
+    constructor(schema: SchemaNode, defaultValue: ExpressionNode | undefined, location: SourceLocation);
+    toJSON(): any;
+}
+type ArgumentValue = ExpressionNode | ComplexValueNode | SchemaLiteralNode;
+/**
+ * Argument node - represents a function argument
+ * Can be a single value or multiple values (multi-value parameter)
+ * Each value can be an expression, complex value (object/array), or schema literal
+ */
+export class ArgumentNode extends ASTNode {
+    key: string;
+    values: ArgumentValue[];
+    constructor(key: string, value: ArgumentValue | ArgumentValue[], location: SourceLocation);
+    /** Get the first (or only) value - for backwards compatibility */
+    get value(): ArgumentValue;
+    /** Check if this is a multi-value parameter */
+    isMultiValue(): boolean;
+    toJSON(): any;
+}
+/**
+ * Parameter declaration node
+ * Example: n AS INTEGER
+ */
+export class ParameterDeclNode extends ASTNode {
+    name: string;
+    schema: SchemaNode;
+    constructor(name: string, schema: SchemaNode, location: SourceLocation);
+    toJSON(): any;
+}
+/**
+ * Event declaration node
+ * Example:
+ *   output
+ *       result AS ARRAY OF INTEGER
+ */
+export class EventDeclNode extends ASTNode {
+    name: string;
+    parameters: ParameterDeclNode[];
+    constructor(name: string, parameters: ParameterDeclNode[] | undefined, location: SourceLocation);
+    toJSON(): any;
+}
+/**
+ * Function call node
+ * Example: System.Array.InsertLast(source = Context.a, element = 10)
+ */
+export class FunctionCallNode extends ASTNode {
+    namespace: string;
+    name: string;
+    argumentsMap: Map<string, ArgumentNode>;
+    constructor(namespace: string, name: string, argumentsMap: Map<string, ArgumentNode>, location: SourceLocation);
+    toJSON(): any;
+}
+/**
+ * Statement node - represents a single statement in the LOGIC block
+ * Example:
+ *   create: System.Context.Create(name = "a") AFTER Steps.prev
+ *       iteration
+ *           if: System.If(condition = true)
+ */
+export class StatementNode extends ASTNode {
+    statementName: string;
+    functionCall: FunctionCallNode;
+    afterSteps: string[];
+    executeIfSteps: string[];
+    nestedBlocks: Map<string, StatementNode[]>;
+    comment: string;
+    constructor(statementName: string, functionCall: FunctionCallNode, afterSteps: string[] | undefined, executeIfSteps: string[] | undefined, nestedBlocks: Map<string, StatementNode[]> | undefined, location: SourceLocation, comment?: string);
+    toJSON(): any;
+}
+/**
+ * Function definition node - root AST node
+ * Represents the entire function definition
+ */
+export class FunctionDefNode extends ASTNode {
+    name: string;
+    namespace?: string | undefined;
+    parameters: ParameterDeclNode[];
+    events: EventDeclNode[];
+    logic: StatementNode[];
+    constructor(name: string, namespace?: string | undefined, parameters?: ParameterDeclNode[], events?: EventDeclNode[], logic?: StatementNode[], location?: SourceLocation);
+    toJSON(): any;
+}
+/**
+ * Parser error with position information and expected tokens
+ */
+export class DSLParserError extends Error {
+    location?: SourceLocation | undefined;
+    expectedTokens?: string[] | undefined;
+    actualToken?: DSLToken | undefined;
+    constructor(message: string, location?: SourceLocation | undefined, expectedTokens?: string[] | undefined, actualToken?: DSLToken | undefined);
+}
+/**
+ * DSL Parser - Recursive descent parser
+ * Converts tokens into AST
+ */
+export class DSLParser {
+    constructor(tokens: DSLToken[], originalInput?: string);
+    /**
+     * Parse tokens into AST
+     */
+    parse(): FunctionDefNode;
+}
+/**
+ * Schema Transformer
+ * Converts between simple schema syntax and JSON Schema
+ */
+export class SchemaTransformer {
+    /**
+     * Transform simple schema syntax to JSON Schema
+     * Examples:
+     *   "INTEGER" → { type: "INTEGER" }
+     *   "ARRAY OF INTEGER" → { type: "ARRAY", items: { type: "INTEGER" } }
+     *   { type: "STRING", minLength: 5 } → { type: "STRING", minLength: 5 } (pass through)
+     */
+    static transform(schemaSpec: string | object): any;
+    /**
+     * Transform JSON Schema back to simple schema syntax (best effort)
+     * Examples:
+     *   { type: "INTEGER" } → "INTEGER"
+     *   { type: "ARRAY", items: { type: "INTEGER" } } → "ARRAY OF INTEGER"
+     *   Complex schema → JSON.stringify(schema)
+     */
+    static toText(schema: any): string;
+    /**
+     * Check if a schema specification is simple (can be represented as text)
+     */
+    static isSimpleSchema(schema: any): boolean;
+}
+/**
+ * AST to JSON Transformer
+ * Converts parsed AST to FunctionDefinition JSON
+ */
+export class ASTToJSONTransformer {
+    /**
+     * Transform AST to FunctionDefinition JSON
+     * Only includes non-empty/non-default fields
+     */
+    transform(ast: FunctionDefNode): any;
+    /**
+     * Flatten nested blocks into steps
+     * This adds all nested statements to the top-level steps object
+     * and sets their dependentStatements appropriately
+     */
+    flattenNestedBlocks(ast: FunctionDefNode): void;
+}
+/**
+ * Expression Handler
+ * Utilities for working with KIRun expressions
+ */
+export class ExpressionHandler {
+    /**
+     * Parse expression text using KIRun Expression parser
+     */
+    static parse(expressionText: string): Expression;
+    /**
+     * Validate expression syntax
+     */
+    static validate(expressionText: string): boolean;
+    /**
+     * Check if a value is an expression (has isExpression flag)
+     */
+    static isExpression(value: any): boolean;
+    /**
+     * Extract expression text from value object
+     */
+    static extractExpressionText(value: any): string | null;
+}
+/**
+ * JSON to Text Transformer
+ * Converts FunctionDefinition JSON back to DSL text
+ * Extracts implicit dependencies from expressions using same logic as KIRuntime
+ */
+export class JSONToTextTransformer {
+    /**
+     * Transform JSON to DSL text
+     */
+    transform(json: any): Promise<string>;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: FormattedError[];
+}
+export interface FormattedError {
+    message: string;
+    line?: number;
+    column?: number;
+    snippet?: string;
+}
+/**
+ * DSL Compiler - High-level API
+ * Main entry point for DSL compilation and decompilation
+ */
+export class DSLCompiler {
+    /**
+     * Compile DSL text to FunctionDefinition JSON
+     *
+     * @param text DSL source text
+     * @returns FunctionDefinition JSON
+     */
+    static compile(text: string): any;
+    /**
+     * Decompile FunctionDefinition JSON to DSL text
+     *
+     * @param json FunctionDefinition JSON
+     * @returns DSL source text
+     */
+    static decompile(json: any): Promise<string>;
+    /**
+     * Validate DSL syntax without full compilation
+     *
+     * @param text DSL source text
+     * @returns Validation result with errors if any
+     */
+    static validate(text: string): ValidationResult;
+    /**
+     * Format DSL text (parse and regenerate with consistent formatting)
+     *
+     * @param text DSL source text
+     * @returns Formatted DSL text
+     */
+    static format(text: string): Promise<string>;
+}
 export class FunctionDefinition extends FunctionSignature {
     static readonly SCHEMA: Schema;
     constructor(name: string);
@@ -876,6 +1239,17 @@ export class FunctionDefinition extends FunctionSignature {
     getParts(): FunctionDefinition[] | undefined;
     setParts(parts: FunctionDefinition[]): FunctionDefinition;
     static from(json: any): FunctionDefinition;
+    /**
+     * Create FunctionDefinition from DSL text
+     * @param text DSL source code
+     * @returns FunctionDefinition instance
+     */
+    static fromText(text: string): Promise<FunctionDefinition>;
+    /**
+     * Convert FunctionDefinition to DSL text
+     * @returns DSL source code
+     */
+    toText(): Promise<string>;
     toJSON(): any;
 }
 export class GraphVertex<K, T extends GraphVertexType<K>> {
@@ -1034,5 +1408,47 @@ export class Argument {
     setValue(value: any): Argument;
     static of(name: string, value: any): Argument;
 }
+export interface FunctionInfo {
+    namespace: string;
+    name: string;
+    fullName: string;
+    parameters: ParameterInfo[];
+    events: EventInfo[];
+    description?: string;
+}
+export interface ParameterInfo {
+    name: string;
+    type: string;
+    required: boolean;
+}
+export interface EventInfo {
+    name: string;
+    parameters: {
+        [key: string]: string;
+    };
+}
+/**
+ * DSL Function Provider
+ * Provides list of available functions for Monaco autocomplete
+ */
+export class DSLFunctionProvider {
+    /**
+     * Get all available functions from repository
+     * Uses repository.filter("") to dynamically discover all available functions
+     */
+    static getAllFunctions(repo?: Repository<Function>): Promise<FunctionInfo[]>;
+    /**
+     * Get functions by namespace
+     */
+    static getFunctionsByNamespace(namespace: string, repo?: Repository<Function>): Promise<FunctionInfo[]>;
+    /**
+     * Get all unique namespaces
+     */
+    static getAllNamespaces(repo?: Repository<Function>): Promise<string[]>;
+    /**
+     * Clear cached functions
+     */
+    static clearCache(repo?: Repository<Function>): void;
+}
 
 //# sourceMappingURL=types.d.ts.map