@flexiberry/berrycore 0.1.0

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

@@ -0,0 +1,242 @@
+/**
+ * AST Node Types for Flexiberry DSL
+ *
+ * Pure data interfaces — no methods, no logic.
+ * Each node type maps to a specific lexer grammar rule from reader_v2.
+ */
+export declare enum NodeType {
+    Program = "Program",
+    VarDeclaration = "VarDeclaration",
+    PointerReference = "PointerReference",
+    LinkStatement = "LinkStatement",
+    InputStatement = "InputStatement",
+    ApiBlock = "ApiBlock",
+    UrlStatement = "UrlStatement",
+    HeaderBlock = "HeaderBlock",
+    BodyBlock = "BodyBlock",
+    TaskBlock = "TaskBlock",
+    StepBlock = "StepBlock",
+    ParamsBlock = "ParamsBlock",
+    CaptureBlock = "CaptureBlock",
+    CheckBlock = "CheckBlock",
+    KeyValuePair = "KeyValuePair",
+    Condition = "Condition",
+    BinaryExpression = "BinaryExpression",
+    Identifier = "Identifier",
+    Literal = "Literal",
+    Comment = "Comment"
+}
+/** Source location attached to every AST node */
+export interface NodePosition {
+    readonly line: number;
+    readonly column: number;
+}
+export interface BaseNode {
+    readonly type: NodeType;
+    readonly position: NodePosition;
+}
+/** Top-level program — an ordered list of declarations */
+export interface ProgramNode extends BaseNode {
+    readonly type: NodeType.Program;
+    readonly body: ReadonlyArray<StatementNode>;
+}
+export type StatementNode = VarDeclarationNode | LinkStatementNode | InputStatementNode | ApiBlockNode | TaskBlockNode | StepBlockNode | ParamsBlockNode | CaptureBlockNode | CheckBlockNode | CommentNode;
+/**
+ * `Var @pointed title`
+ * followed by key-value pairs on subsequent lines
+ *
+ * Grammar: var.grammer.ts
+ * Tokens: Var, optional (Pointer + Pointed + Title), then keyValueGrammer loop
+ */
+export interface VarDeclarationNode extends BaseNode {
+    readonly type: NodeType.VarDeclaration;
+    readonly title: string | null;
+    readonly pointer: PointerReferenceNode | null;
+    readonly entries: ReadonlyArray<KeyValuePairNode>;
+}
+/**
+ * `@pointed` reference inside a Var declaration
+ *
+ * Tokens: Pointer (@), Pointed (name)
+ */
+export interface PointerReferenceNode extends BaseNode {
+    readonly type: NodeType.PointerReference;
+    readonly symbol: string;
+    readonly target: string;
+}
+/**
+ * `Link path/to/file.berry` or `Link http://example.com/file.berry`
+ *
+ * Grammar: link.grammer.ts
+ * Tokens: Link, LinkPath
+ */
+export interface LinkStatementNode extends BaseNode {
+    readonly type: NodeType.LinkStatement;
+    readonly path: string;
+}
+/**
+ * `Input path/to/file.csv`
+ *
+ * Grammar: input.grammer.ts
+ * Tokens: Input, InputPath
+ */
+export interface InputStatementNode extends BaseNode {
+    readonly type: NodeType.InputStatement;
+    readonly path: string;
+}
+/**
+ * `Api GET #myApi Some Title`
+ * followed by Url, Header, Body sub-blocks
+ *
+ * Grammar: api.grammer.ts
+ * Tokens: Api, ApiMethod, Hash, Identifier, Title
+ */
+export interface ApiBlockNode extends BaseNode {
+    readonly type: NodeType.ApiBlock;
+    readonly method: string | null;
+    readonly name: string;
+    readonly title: string | null;
+    readonly url: UrlStatementNode | null;
+    readonly headers: HeaderBlockNode | null;
+    readonly body: BodyBlockNode | null;
+}
+/**
+ * `Url https://example.com/api`
+ *
+ * Grammar: api.grammer.ts (url rule)
+ * Tokens: Url, Value
+ */
+export interface UrlStatementNode extends BaseNode {
+    readonly type: NodeType.UrlStatement;
+    readonly value: string;
+}
+/**
+ * `Header` followed by key-value pairs
+ *
+ * Grammar: api.grammer.ts (Header rule)
+ * Tokens: Header, then keyValueGrammer loop
+ */
+export interface HeaderBlockNode extends BaseNode {
+    readonly type: NodeType.HeaderBlock;
+    readonly entries: ReadonlyArray<KeyValuePairNode>;
+}
+/**
+ * `Body json` followed by backtick-wrapped content
+ *
+ * Grammar: api.grammer.ts (Body rule)
+ * Tokens: Body, BodyType, Backtick, Scalar, Backtick
+ */
+export interface BodyBlockNode extends BaseNode {
+    readonly type: NodeType.BodyBlock;
+    readonly bodyType: string;
+    readonly content: string;
+}
+/**
+ * `Task My Test Suite`
+ *
+ * Grammar: task.grammer.ts
+ * Tokens: Task, Title
+ */
+export interface TaskBlockNode extends BaseNode {
+    readonly type: NodeType.TaskBlock;
+    readonly title: string | null;
+    readonly steps: ReadonlyArray<StepBlockNode>;
+}
+/**
+ * `Step Call Api myApi`
+ *
+ * Grammar: step.grammer.ts
+ * Tokens: Step, Call, Api, Identifier
+ */
+export interface StepBlockNode extends BaseNode {
+    readonly type: NodeType.StepBlock;
+    readonly callType: string;
+    readonly targetType: string;
+    readonly targetName: string;
+    readonly params: ParamsBlockNode | null;
+    readonly capture: CaptureBlockNode | null;
+    readonly check: CheckBlockNode | null;
+}
+/**
+ * `Params` followed by key-value pairs
+ *
+ * Grammar: params.grammer.ts
+ * Tokens: Params, then keyValueGrammer loop
+ */
+export interface ParamsBlockNode extends BaseNode {
+    readonly type: NodeType.ParamsBlock;
+    readonly entries: ReadonlyArray<KeyValuePairNode>;
+}
+/**
+ * `Capture` followed by key-value pairs
+ *
+ * Grammar: capture.grammer.ts
+ * Tokens: Capture, then keyValueGrammer loop
+ */
+export interface CaptureBlockNode extends BaseNode {
+    readonly type: NodeType.CaptureBlock;
+    readonly entries: ReadonlyArray<KeyValuePairNode>;
+}
+/**
+ * `Check` followed by condition lines
+ *
+ * Grammar: check.grammer.ts
+ * Tokens: Check, then conditionGrammer loop
+ */
+export interface CheckBlockNode extends BaseNode {
+    readonly type: NodeType.CheckBlock;
+    readonly conditions: ReadonlyArray<ConditionNode>;
+}
+/**
+ * `- key: value` or `- "key": "value"` or `- key: \`multiline\``
+ *
+ * Grammar: keyvalue.grammer.ts
+ * Tokens: Hyphen, (Quote?, Identifier, Quote?, Colon), (Quote?, Scalar/Identifier, Quote?) or (Backtick, Scalar, Backtick)
+ */
+export interface KeyValuePairNode extends BaseNode {
+    readonly type: NodeType.KeyValuePair;
+    readonly key: string;
+    readonly value: string;
+    readonly isKeyQuoted: boolean;
+    readonly isValueQuoted: boolean;
+    readonly isMultiline: boolean;
+    readonly isEncrypted?: boolean;
+}
+/**
+ * `- lhs == rhs` with optional `OR` chains
+ *
+ * Grammar: conditions.grammer.ts
+ * Tokens: Hyphen, Lhs, Operator, Rhs, optional (Or, Lhs, Operator, Rhs)+
+ */
+export interface ConditionNode extends BaseNode {
+    readonly type: NodeType.Condition;
+    readonly lhs: string;
+    readonly operator: string;
+    readonly rhs: string;
+    readonly orConditions: ReadonlyArray<BinaryExpressionNode>;
+}
+/**
+ * An OR-chained binary expression within a condition
+ *
+ * Tokens: Or, Lhs, Operator, Rhs
+ */
+export interface BinaryExpressionNode extends BaseNode {
+    readonly type: NodeType.BinaryExpression;
+    readonly lhs: string;
+    readonly operator: string;
+    readonly rhs: string;
+}
+export interface IdentifierNode extends BaseNode {
+    readonly type: NodeType.Identifier;
+    readonly name: string;
+}
+export interface LiteralNode extends BaseNode {
+    readonly type: NodeType.Literal;
+    readonly value: string | number | boolean;
+    readonly raw: string;
+}
+export interface CommentNode extends BaseNode {
+    readonly type: NodeType.Comment;
+    readonly text: string;
+}
+export type ASTNode = ProgramNode | VarDeclarationNode | LinkStatementNode | InputStatementNode | PointerReferenceNode | ApiBlockNode | UrlStatementNode | HeaderBlockNode | BodyBlockNode | TaskBlockNode | StepBlockNode | ParamsBlockNode | CaptureBlockNode | CheckBlockNode | KeyValuePairNode | ConditionNode | BinaryExpressionNode | IdentifierNode | LiteralNode | CommentNode;

package/dist/parser/ast/ast.types.js

@@ -0,0 +1,37 @@
+/**
+ * AST Node Types for Flexiberry DSL
+ *
+ * Pure data interfaces — no methods, no logic.
+ * Each node type maps to a specific lexer grammar rule from reader_v2.
+ */
+// ─── Node Type Discriminator ────────────────────────────────────────────────
+export var NodeType;
+(function (NodeType) {
+    NodeType["Program"] = "Program";
+    // Variable constructs
+    NodeType["VarDeclaration"] = "VarDeclaration";
+    NodeType["PointerReference"] = "PointerReference";
+    // Link & Input constructs
+    NodeType["LinkStatement"] = "LinkStatement";
+    NodeType["InputStatement"] = "InputStatement";
+    // API constructs
+    NodeType["ApiBlock"] = "ApiBlock";
+    NodeType["UrlStatement"] = "UrlStatement";
+    NodeType["HeaderBlock"] = "HeaderBlock";
+    NodeType["BodyBlock"] = "BodyBlock";
+    // Task / Step constructs
+    NodeType["TaskBlock"] = "TaskBlock";
+    NodeType["StepBlock"] = "StepBlock";
+    // Data constructs
+    NodeType["ParamsBlock"] = "ParamsBlock";
+    NodeType["CaptureBlock"] = "CaptureBlock";
+    NodeType["CheckBlock"] = "CheckBlock";
+    // Shared primitives
+    NodeType["KeyValuePair"] = "KeyValuePair";
+    NodeType["Condition"] = "Condition";
+    NodeType["BinaryExpression"] = "BinaryExpression";
+    // Terminals
+    NodeType["Identifier"] = "Identifier";
+    NodeType["Literal"] = "Literal";
+    NodeType["Comment"] = "Comment";
+})(NodeType || (NodeType = {}));

package/dist/parser/formatter/formatter.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Berry Code Formatter
+ *
+ * Walks a ProgramNode AST and emits properly formatted Berry source code.
+ * This is a pure code-generator — no side effects, no runtime logic.
+ *
+ * Formatting rules:
+ *   - Top-level blocks (Var, Api, Task) separated by blank lines
+ *   - Api sub-blocks (Url, Header, Body) indented with no extra blank lines
+ *   - Task → Step indented 1 level (8 spaces)
+ *   - Step → Params/Capture/Check indented 2 levels (16 spaces)
+ *   - Key-value entries indented under their parent with "- key: value"
+ *   - Conditions indented under Check with "- lhs operator rhs"
+ */
+import { ProgramNode } from "../ast/ast.types.js";
+export interface FormatterOptions {
+    /** Number of spaces per indent level (default: 8) */
+    readonly indentSize: number;
+    /** Blank lines between top-level blocks (default: 1) */
+    readonly blankLinesBetweenBlocks: number;
+    /** Whether to quote key-value string values (default: true) */
+    readonly quoteValues: boolean;
+}
+export declare class BerryFormatter {
+    private readonly options;
+    constructor(options?: Partial<FormatterOptions>);
+    /** Format an entire AST back into Berry source code */
+    format(ast: ProgramNode): string;
+    private formatStatement;
+    private formatVarDeclaration;
+    private formatApiBlock;
+    private formatUrlStatement;
+    private formatHeaderBlock;
+    private formatBodyBlock;
+    private formatTaskBlock;
+    private formatStepBlock;
+    private formatParamsBlock;
+    private formatCaptureBlock;
+    private formatCheckBlock;
+    private formatKeyValuePair;
+    private formatCondition;
+    private formatComment;
+    private indent;
+}

package/dist/parser/formatter/formatter.js

@@ -0,0 +1,214 @@
+/**
+ * Berry Code Formatter
+ *
+ * Walks a ProgramNode AST and emits properly formatted Berry source code.
+ * This is a pure code-generator — no side effects, no runtime logic.
+ *
+ * Formatting rules:
+ *   - Top-level blocks (Var, Api, Task) separated by blank lines
+ *   - Api sub-blocks (Url, Header, Body) indented with no extra blank lines
+ *   - Task → Step indented 1 level (8 spaces)
+ *   - Step → Params/Capture/Check indented 2 levels (16 spaces)
+ *   - Key-value entries indented under their parent with "- key: value"
+ *   - Conditions indented under Check with "- lhs operator rhs"
+ */
+import { NodeType, } from "../ast/ast.types.js";
+const DEFAULT_OPTIONS = {
+    indentSize: 8,
+    blankLinesBetweenBlocks: 1,
+    quoteValues: true,
+};
+// ─── Formatter ──────────────────────────────────────────────────────────────
+export class BerryFormatter {
+    options;
+    constructor(options = {}) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    /** Format an entire AST back into Berry source code */
+    format(ast) {
+        const blocks = [];
+        for (const node of ast.body) {
+            const formatted = this.formatStatement(node);
+            if (formatted !== null) {
+                blocks.push(formatted);
+            }
+        }
+        const separator = "\n" + "\n".repeat(this.options.blankLinesBetweenBlocks);
+        return blocks.join(separator) + "\n";
+    }
+    // ── Statement Dispatch ──────────────────────────────────────────────────
+    formatStatement(node) {
+        switch (node.type) {
+            case NodeType.VarDeclaration:
+                return this.formatVarDeclaration(node);
+            case NodeType.ApiBlock:
+                return this.formatApiBlock(node);
+            case NodeType.TaskBlock:
+                return this.formatTaskBlock(node);
+            case NodeType.StepBlock:
+                return this.formatStepBlock(node, 0);
+            case NodeType.ParamsBlock:
+                return this.formatParamsBlock(node, 0);
+            case NodeType.CaptureBlock:
+                return this.formatCaptureBlock(node, 0);
+            case NodeType.CheckBlock:
+                return this.formatCheckBlock(node, 0);
+            case NodeType.Comment:
+                return this.formatComment(node);
+            default:
+                return null;
+        }
+    }
+    // ── Var Declaration ─────────────────────────────────────────────────────
+    formatVarDeclaration(node) {
+        const lines = [];
+        // Var header
+        let header = "Var";
+        if (node.pointer) {
+            header += ` ${node.pointer.symbol}${node.pointer.target}`;
+        }
+        if (node.title) {
+            header += ` ${node.title}`;
+        }
+        lines.push(header);
+        // Key-value entries (indented 1 level)
+        for (const entry of node.entries) {
+            lines.push(this.formatKeyValuePair(entry, 1));
+        }
+        return lines.join("\n");
+    }
+    // ── Api Block ───────────────────────────────────────────────────────────
+    formatApiBlock(node) {
+        const lines = [];
+        // Api header: Api METHOD #name title
+        let header = "Api";
+        if (node.method) {
+            header += ` ${node.method}`;
+        }
+        header += ` #${node.name}`;
+        if (node.title) {
+            header += ` ${node.title}`;
+        }
+        lines.push(header);
+        // Url
+        if (node.url) {
+            lines.push(this.formatUrlStatement(node.url));
+        }
+        // Header
+        if (node.headers) {
+            lines.push(this.formatHeaderBlock(node.headers));
+        }
+        // Body
+        if (node.body) {
+            lines.push(this.formatBodyBlock(node.body));
+        }
+        return lines.join("\n");
+    }
+    formatUrlStatement(node) {
+        return `Url ${node.value}`;
+    }
+    formatHeaderBlock(node) {
+        const lines = ["Header"];
+        for (const entry of node.entries) {
+            lines.push(this.formatKeyValuePair(entry, 0));
+        }
+        return lines.join("\n");
+    }
+    formatBodyBlock(node) {
+        return `Body ${node.bodyType} \`${node.content}\``;
+    }
+    // ── Task Block ──────────────────────────────────────────────────────────
+    formatTaskBlock(node) {
+        const lines = [];
+        let header = "Task";
+        if (node.title) {
+            header += ` ${node.title.trim()}`;
+        }
+        lines.push(header);
+        // Steps indented 1 level under Task
+        for (const step of node.steps) {
+            lines.push(this.formatStepBlock(step, 1));
+        }
+        return lines.join("\n");
+    }
+    // ── Step Block ──────────────────────────────────────────────────────────
+    formatStepBlock(node, indent) {
+        const lines = [];
+        const pad = this.indent(indent);
+        // Step Call Api <name>
+        lines.push(`${pad}Step ${node.callType} ${node.targetType} ${node.targetName}`);
+        // Sub-blocks indented one more level
+        const subIndent = indent + 1;
+        if (node.params) {
+            lines.push(this.formatParamsBlock(node.params, subIndent));
+        }
+        if (node.capture) {
+            lines.push(this.formatCaptureBlock(node.capture, subIndent));
+        }
+        if (node.check) {
+            lines.push(this.formatCheckBlock(node.check, subIndent));
+        }
+        return lines.join("\n");
+    }
+    // ── Params / Capture / Check ────────────────────────────────────────────
+    formatParamsBlock(node, indent) {
+        const pad = this.indent(indent);
+        const lines = [`${pad}Params`];
+        for (const entry of node.entries) {
+            lines.push(this.formatKeyValuePair(entry, indent));
+        }
+        return lines.join("\n");
+    }
+    formatCaptureBlock(node, indent) {
+        const pad = this.indent(indent);
+        const lines = [`${pad}Capture`];
+        for (const entry of node.entries) {
+            lines.push(this.formatKeyValuePair(entry, indent));
+        }
+        return lines.join("\n");
+    }
+    formatCheckBlock(node, indent) {
+        const pad = this.indent(indent);
+        const lines = [`${pad}Check`];
+        for (const condition of node.conditions) {
+            lines.push(this.formatCondition(condition, indent));
+        }
+        return lines.join("\n");
+    }
+    // ── Key-Value Pair ──────────────────────────────────────────────────────
+    formatKeyValuePair(node, indent) {
+        const pad = this.indent(indent);
+        // Format key
+        const key = node.isKeyQuoted ? `'${node.key}'` : node.key;
+        // Format value
+        let value;
+        if (node.isMultiline) {
+            value = `\`${node.value}\``;
+        }
+        else if (node.isValueQuoted || this.options.quoteValues) {
+            value = `'${node.value}'`;
+        }
+        else {
+            value = node.value;
+        }
+        return `${pad}- ${key}: ${value}`;
+    }
+    // ── Condition ─────────────────────────────────────────────────────────
+    formatCondition(node, indent) {
+        const pad = this.indent(indent);
+        let line = `${pad}- ${node.lhs} ${node.operator} ${node.rhs}`;
+        // Append OR chains
+        for (const orExpr of node.orConditions) {
+            line += ` OR ${orExpr.lhs} ${orExpr.operator} ${orExpr.rhs}`;
+        }
+        return line;
+    }
+    // ── Comment ─────────────────────────────────────────────────────────────
+    formatComment(node) {
+        return `##${node.text}`;
+    }
+    // ── Helpers ─────────────────────────────────────────────────────────────
+    indent(level) {
+        return " ".repeat(level * this.options.indentSize);
+    }
+}

package/dist/parser/tokenizer/reader/grammer/api.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const apiGrammer: LexerGrammer[];

package/dist/parser/tokenizer/reader/grammer/api.grammer.js

@@ -0,0 +1,102 @@
+import { TokenType } from "../../tokenType.js";
+import { keyValueGrammer } from "./keyvalue.grammer.js";
+export const apiGrammer = [
+    {
+        name: "api statement",
+        regex: /^\s*(Api)(?:\s+(GET|POST|PUT|DELETE|PATCH))?\s+((#)(\S+))(?:\s+(.*))?$/,
+        groups: [
+            {
+                tokenType: TokenType.Api,
+                index: 1,
+            },
+            {
+                tokenType: TokenType.ApiMethod,
+                index: 2,
+            },
+            {
+                tokenType: TokenType.Hash,
+                index: 4,
+            },
+            {
+                tokenType: TokenType.Identifier,
+                index: 5,
+            },
+            {
+                tokenType: TokenType.Title,
+                index: 6,
+            },
+        ],
+        isOptional: true,
+        isMultiline: false,
+    },
+    {
+        name: "url",
+        regex: /^\s*(Url)\s+(.*)$/,
+        groups: [
+            {
+                tokenType: TokenType.Url,
+                index: 1,
+            },
+            {
+                tokenType: TokenType.Value,
+                index: 2,
+            },
+        ],
+        isMultiline: false,
+    },
+    {
+        name: "Header",
+        regex: /^\s*(Header)/,
+        groups: [
+            {
+                tokenType: TokenType.Header,
+                index: 1,
+            },
+        ],
+        next: [
+            {
+                ...keyValueGrammer,
+                moveNextLine: true,
+            },
+        ],
+        isMultiline: false,
+    },
+    {
+        name: "Body",
+        regex: /^\s*(Body)\s(\w+)\s*/,
+        groups: [
+            {
+                tokenType: TokenType.Body,
+                index: 1,
+            },
+            {
+                tokenType: TokenType.BodyType,
+                index: 2,
+            },
+        ],
+        next: [
+            {
+                name: "multilineValue",
+                regex: /(`)([\s\S]*?)(`)/,
+                isOptional: false,
+                groups: [
+                    {
+                        tokenType: TokenType.Backtick,
+                        index: 1,
+                    },
+                    {
+                        tokenType: TokenType.Scalar,
+                        index: 2,
+                    },
+                    {
+                        tokenType: TokenType.Backtick,
+                        index: 3,
+                    },
+                ],
+                start: /(`)([\s\S]*?)/,
+                end: /(`)([\s\S]*?)(`)/,
+                mergeLines: true,
+            },
+        ],
+    },
+];

package/dist/parser/tokenizer/reader/grammer/capture.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const captureGrammer: LexerGrammer;

package/dist/parser/tokenizer/reader/grammer/capture.grammer.js

@@ -0,0 +1,21 @@
+import { TokenType } from "../../tokenType.js";
+import { keyValueGrammer } from "./keyvalue.grammer.js";
+export const captureGrammer = {
+    name: "Capture",
+    regex: /^\s*(Capture)/,
+    groups: [
+        {
+            tokenType: TokenType.Capture,
+            index: 1,
+        },
+    ],
+    next: [
+        {
+            ...keyValueGrammer,
+            moveNextLine: true,
+        },
+    ],
+    isOptional: true,
+    isMultiline: false,
+    moveNextLine: true,
+};

package/dist/parser/tokenizer/reader/grammer/check.grammer.d.ts

@@ -0,0 +1,2 @@
+import { LexerGrammer } from "../lexer.types.js";
+export declare const checkGrammer: LexerGrammer;

package/dist/parser/tokenizer/reader/grammer/check.grammer.js

@@ -0,0 +1,21 @@
+import { TokenType } from "../../tokenType.js";
+import { conditionGrammer } from "./conditions.grammer.js";
+export const checkGrammer = {
+    name: "Check",
+    regex: /^\s*(Check)/,
+    groups: [
+        {
+            tokenType: TokenType.Check,
+            index: 1,
+        },
+    ],
+    next: [
+        {
+            ...conditionGrammer,
+            moveNextLine: true,
+        },
+    ],
+    isOptional: true,
+    isMultiline: false,
+    moveNextLine: true,
+};