@flexiberry/berrycore 0.1.0

package/dist/parser/tokenizer/reader/lexer.engine.js

@@ -0,0 +1,178 @@
+import { Token } from "../token.js";
+import { comment } from "./grammer/comment.grammer.js";
+import { varLexerGrammer } from "./grammer/var.grammer.js";
+import { TokenType } from "../tokenType.js";
+import { apiGrammer } from "./grammer/api.grammer.js";
+import { taskGrammer } from "./grammer/task.grammer.js";
+import { stepGrammer } from "./grammer/step.grammer.js";
+import { paramsGrammer } from "./grammer/params.grammer.js";
+import { captureGrammer } from "./grammer/capture.grammer.js";
+import { checkGrammer } from "./grammer/check.grammer.js";
+import { linkGrammer } from "./grammer/link.grammer.js";
+import { inputGrammer } from "./grammer/input.grammer.js";
+const grammer = [
+    linkGrammer,
+    inputGrammer,
+    ...varLexerGrammer,
+    comment,
+    ...apiGrammer,
+    taskGrammer,
+    stepGrammer,
+    paramsGrammer,
+    captureGrammer,
+    checkGrammer,
+];
+export class LexerError extends Error {
+    line;
+    column;
+    constructor(message, line, column) {
+        super(`[LexerError at ${line}:${column}] ${message}`);
+        this.line = line;
+        this.column = column;
+        this.name = "LexerError";
+    }
+}
+export class LexerEngine {
+    input;
+    tokens = [];
+    lines = [];
+    lineIndex = 0;
+    columnIndex = 0;
+    currentLine = "";
+    at() {
+        return this.lines[this.lineIndex];
+    }
+    next() {
+        do {
+            this.lineIndex++;
+        } while (comment.regex.test(this.at()) &&
+            this.lineIndex < this.lines.length);
+        this.columnIndex = 0;
+        return this.at();
+    }
+    prev() {
+        this.lineIndex--;
+        return this.at();
+    }
+    constructor(input) {
+        this.input = input;
+    }
+    /**
+     * Processes a grammar rule against the given line and updates tokens.
+     * Optimized for readability and performance.
+     */
+    processGrammer(grammar) {
+        // Handle multi-line grammar start/end
+        if (grammar.start && grammar.end && grammar.start.test(this.currentLine)) {
+            this.currentLine = this.mergeLinesUntilEnd(grammar, this.currentLine);
+        }
+        // Check if the line matches the grammar regex
+        if (grammar.regex.test(this.currentLine)) {
+            const match = this.currentLine.match(grammar.regex);
+            if (match) {
+                this.processGroups(grammar, match);
+                // Handle next grammar rules if present
+                if (grammar.next) {
+                    this.processNextGrammars(grammar.next);
+                }
+                if (grammar.loopUntil) {
+                    this.processLoopUntil(grammar);
+                    if (grammar.moveNextLine ||
+                        grammar.loopUntil.test(this.currentLine)) {
+                        this.currentLine = this.prev();
+                    }
+                }
+            }
+            return true;
+        }
+        else {
+            if (grammar.isOptional === false) {
+                throw new LexerError("Invalid syntax or grammar at current line", this.lineIndex, this.columnIndex);
+            }
+        }
+        return false;
+    }
+    /**
+     * Merges lines until the grammar's end pattern is matched or lines run out.
+     */
+    mergeLinesUntilEnd(grammar, line) {
+        while (grammar.end &&
+            !grammar.end.test(line) &&
+            grammar.mergeLines &&
+            this.lineIndex < this.lines.length) {
+            line += this.next();
+        }
+        return line;
+    }
+    /**
+     * Processes the groups in the grammar and generates tokens.
+     */
+    processGroups(grammar, match) {
+        for (const group of grammar.groups) {
+            const groupIdx = group.index ?? 0;
+            const matchedValue = match[groupIdx];
+            if (group.index !== undefined && matchedValue) {
+                this.tokens.push(Token.from(matchedValue, group.tokenType, this.columnIndex, this.columnIndex + matchedValue.length, this.lineIndex));
+                const indexofmatch = this.currentLine.indexOf(matchedValue);
+                this.columnIndex += indexofmatch >= 0 ? indexofmatch : 0;
+                this.currentLine = this.currentLine.substring(indexofmatch + matchedValue.length);
+            }
+        }
+    }
+    /**
+     * Processes any next grammar rules chained to the current grammar.
+     */
+    processNextGrammars(nextGrammars) {
+        let isProcessed = false;
+        for (const nextGrammar of nextGrammars) {
+            if (isProcessed && nextGrammar.isOptional)
+                continue;
+            if (nextGrammar.moveNextLine) {
+                this.currentLine = this.next();
+            }
+            isProcessed = this.processGrammer(nextGrammar);
+        }
+    }
+    /**
+     * Handles looping a grammar until a condition is met.
+     */
+    processLoopUntil(grammar) {
+        if (!grammar.loopUntil)
+            return true;
+        do {
+            this.currentLine = grammar.mergeLines
+                ? this.currentLine + this.next()
+                : grammar.moveNextLine
+                    ? this.next()
+                    : this.currentLine;
+            const isProcessed = this.processGrammer(grammar);
+            if (!isProcessed)
+                return false;
+        } while (grammar.loopUntil &&
+            grammar.loopUntil.test(this.currentLine) &&
+            this.lineIndex < this.lines.length);
+        return true;
+    }
+    /**
+     * Tokenizes the input string into tokens using the defined grammar list.
+     */
+    tokenize() {
+        this.lines = this.input.split("\n");
+        const totalLines = this.lines.length;
+        // Process each line
+        while (this.lineIndex < totalLines) {
+            this.columnIndex = 0;
+            this.currentLine = this.at();
+            // Try each grammar rule; break if processed
+            for (const grammarRule of grammer) {
+                if (this.processGrammer(grammarRule)) {
+                    break;
+                }
+            }
+            this.next();
+        }
+        // Add EOF token at the end
+        this.tokens.push(Token.from("EOF", TokenType.Eof, this.columnIndex, this.columnIndex, this.lineIndex));
+        return this.tokens;
+    }
+}

package/dist/parser/tokenizer/reader/lexer.types.d.ts

@@ -0,0 +1,18 @@
+import { TokenType } from "../tokenType.js";
+export type CaptureGroup = {
+    tokenType: TokenType;
+    index?: number;
+};
+export type LexerGrammer = {
+    name: string;
+    regex: RegExp;
+    groups: CaptureGroup[];
+    isOptional?: boolean;
+    moveNextLine?: boolean;
+    isMultiline?: boolean;
+    next?: LexerGrammer[];
+    loopUntil?: RegExp;
+    mergeLines?: boolean;
+    start?: RegExp;
+    end?: RegExp;
+};

package/dist/parser/tokenizer/reader/lexer.types.js

@@ -0,0 +1 @@
+export {};

package/dist/parser/tokenizer/token.d.ts

@@ -0,0 +1,13 @@
+import { TokenType } from "./tokenType.js";
+export type Position = {
+    start: number;
+    end: number;
+    line?: number;
+};
+export declare class Token {
+    value: any;
+    type: TokenType;
+    position: Position;
+    constructor(value: any, type: TokenType, position: Position);
+    static from(value: any, type: TokenType, start: number, end: number, line?: number): Token;
+}

package/dist/parser/tokenizer/token.js

@@ -0,0 +1,13 @@
+export class Token {
+    value;
+    type;
+    position;
+    constructor(value, type, position) {
+        this.value = value;
+        this.type = type;
+        this.position = position;
+    }
+    static from(value, type, start, end, line) {
+        return new Token(value, type, { start: start, end: end, line: line });
+    }
+}

package/dist/parser/tokenizer/tokenType.d.ts

@@ -0,0 +1,58 @@
+export declare function TokenTypeValueOf(value: TokenType): string;
+export declare enum TokenType {
+    Number = 0,
+    Scalar = 1,
+    Value = 2,
+    Identifier = 3,
+    Env = 4,
+    Var = 5,
+    Link = 6,
+    LinkPath = 7,
+    Input = 8,
+    InputPath = 9,
+    Decrypt = 10,
+    Pointer = 11,
+    Pointed = 12,
+    Api = 13,
+    ApiMethod = 14,
+    Url = 15,
+    Body = 16,
+    BodyType = 17,
+    Header = 18,
+    HeaderValue = 19,
+    ApiEnd = 20,
+    Task = 21,
+    Step = 22,
+    StepName = 23,
+    Call = 24,
+    Title = 25,
+    And = 26,
+    Or = 27,
+    Gte = 28,
+    Gt = 29,
+    Lte = 30,
+    Lt = 31,
+    Equal = 32,
+    Lhs = 33,
+    Rhs = 34,
+    Operands = 35,
+    Operator = 36,
+    OperandsScalar = 37,
+    Comment = 38,
+    DocumentStart = 39,
+    DocumentEnd = 40,
+    Whitespace = 41,
+    Eof = 42,
+    EmptyLine = 43,
+    Comma = 44,
+    Colon = 45,
+    Backtick = 46,
+    Hyphen = 47,
+    Hash = 48,
+    Quote = 49,
+    Capture = 50,
+    Params = 51,
+    Check = 52,
+    NotEqual = 53,
+    Unknown = 54
+}

package/dist/parser/tokenizer/tokenType.js

@@ -0,0 +1,64 @@
+export function TokenTypeValueOf(value) {
+    return TokenType[value]; // Return the name of the TokenType
+}
+export var TokenType;
+(function (TokenType) {
+    // Literal Types
+    TokenType[TokenType["Number"] = 0] = "Number";
+    TokenType[TokenType["Scalar"] = 1] = "Scalar";
+    TokenType[TokenType["Value"] = 2] = "Value";
+    TokenType[TokenType["Identifier"] = 3] = "Identifier";
+    // Keywords
+    TokenType[TokenType["Env"] = 4] = "Env";
+    TokenType[TokenType["Var"] = 5] = "Var";
+    TokenType[TokenType["Link"] = 6] = "Link";
+    TokenType[TokenType["LinkPath"] = 7] = "LinkPath";
+    TokenType[TokenType["Input"] = 8] = "Input";
+    TokenType[TokenType["InputPath"] = 9] = "InputPath";
+    TokenType[TokenType["Decrypt"] = 10] = "Decrypt";
+    TokenType[TokenType["Pointer"] = 11] = "Pointer";
+    TokenType[TokenType["Pointed"] = 12] = "Pointed";
+    TokenType[TokenType["Api"] = 13] = "Api";
+    TokenType[TokenType["ApiMethod"] = 14] = "ApiMethod";
+    TokenType[TokenType["Url"] = 15] = "Url";
+    TokenType[TokenType["Body"] = 16] = "Body";
+    TokenType[TokenType["BodyType"] = 17] = "BodyType";
+    TokenType[TokenType["Header"] = 18] = "Header";
+    TokenType[TokenType["HeaderValue"] = 19] = "HeaderValue";
+    TokenType[TokenType["ApiEnd"] = 20] = "ApiEnd";
+    TokenType[TokenType["Task"] = 21] = "Task";
+    TokenType[TokenType["Step"] = 22] = "Step";
+    TokenType[TokenType["StepName"] = 23] = "StepName";
+    TokenType[TokenType["Call"] = 24] = "Call";
+    TokenType[TokenType["Title"] = 25] = "Title";
+    //   logic types
+    TokenType[TokenType["And"] = 26] = "And";
+    TokenType[TokenType["Or"] = 27] = "Or";
+    TokenType[TokenType["Gte"] = 28] = "Gte";
+    TokenType[TokenType["Gt"] = 29] = "Gt";
+    TokenType[TokenType["Lte"] = 30] = "Lte";
+    TokenType[TokenType["Lt"] = 31] = "Lt";
+    TokenType[TokenType["Equal"] = 32] = "Equal";
+    TokenType[TokenType["Lhs"] = 33] = "Lhs";
+    TokenType[TokenType["Rhs"] = 34] = "Rhs";
+    TokenType[TokenType["Operands"] = 35] = "Operands";
+    TokenType[TokenType["Operator"] = 36] = "Operator";
+    TokenType[TokenType["OperandsScalar"] = 37] = "OperandsScalar";
+    TokenType[TokenType["Comment"] = 38] = "Comment";
+    TokenType[TokenType["DocumentStart"] = 39] = "DocumentStart";
+    TokenType[TokenType["DocumentEnd"] = 40] = "DocumentEnd";
+    TokenType[TokenType["Whitespace"] = 41] = "Whitespace";
+    TokenType[TokenType["Eof"] = 42] = "Eof";
+    TokenType[TokenType["EmptyLine"] = 43] = "EmptyLine";
+    TokenType[TokenType["Comma"] = 44] = "Comma";
+    TokenType[TokenType["Colon"] = 45] = "Colon";
+    TokenType[TokenType["Backtick"] = 46] = "Backtick";
+    TokenType[TokenType["Hyphen"] = 47] = "Hyphen";
+    TokenType[TokenType["Hash"] = 48] = "Hash";
+    TokenType[TokenType["Quote"] = 49] = "Quote";
+    TokenType[TokenType["Capture"] = 50] = "Capture";
+    TokenType[TokenType["Params"] = 51] = "Params";
+    TokenType[TokenType["Check"] = 52] = "Check";
+    TokenType[TokenType["NotEqual"] = 53] = "NotEqual";
+    TokenType[TokenType["Unknown"] = 54] = "Unknown";
+})(TokenType || (TokenType = {}));

package/dist/script/format-util.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Format Utility
+ *
+ * Utilities for converting external API formats (CURL, etc.) to Berry code.
+ */
+export interface ApiCommand {
+    method: string;
+    url: string;
+    title?: string;
+    body?: string;
+    bodyType?: string;
+    headers?: string;
+}
+export declare class FormatUtil {
+    /**
+     * Convert a CURL command to Berry Api string
+     * @param curl The CURL command string
+     * @param id The name/identifier for the Api
+     */
+    static convertCurlToBerry(curl: string, id: string): string;
+    /**
+     * Build a Berry Api block from a command object
+     */
+    static buildApi(name: string, cmd: ApiCommand): string;
+    /**
+     * Build a Berry Var block
+     */
+    static buildVar(title: string, variables: string[], env?: string): string;
+    /**
+     * Build a Berry Env block
+     */
+    static buildEnv(envs: (string | null | undefined)[]): string;
+}

package/dist/script/format-util.js

@@ -0,0 +1,94 @@
+/**
+ * Format Utility
+ *
+ * Utilities for converting external API formats (CURL, etc.) to Berry code.
+ */
+export class FormatUtil {
+    /**
+     * Convert a CURL command to Berry Api string
+     * @param curl The CURL command string
+     * @param id The name/identifier for the Api
+     */
+    static convertCurlToBerry(curl, id) {
+        // 1. Extract Method
+        const methodMatch = curl.match(/(?:--location|-X)\s+(\w+)/);
+        const method = (methodMatch ? methodMatch[1] : "GET").toUpperCase();
+        // 2. Extract URL
+        const urlMatch = curl.match(/(?:['"]?)(https?:\/\/[^\s'"]+)(?:['"]?)/);
+        const url = urlMatch ? urlMatch[1] : "";
+        // 3. Extract Headers
+        const headers = {};
+        const headerPattern = /(?:--header|-[Hh])\s+(['"])(.*?):\s*(.*?)\1/gm;
+        let match;
+        while ((match = headerPattern.exec(curl)) !== null) {
+            if (match[2] && match[3]) {
+                headers[match[2].trim()] = match[3].trim();
+            }
+        }
+        // 4. Extract Body
+        const bodyMatch = curl.match(/(?:--data-raw|--data-binary|--data|-[dD])\s+(?:'|")?(\{.*\}|.*)(?:'|")?/s);
+        // Cleanup body: remove leading/trailing quotes if the regex captured them lazily
+        let body = bodyMatch ? bodyMatch[1].trim() : null;
+        if (body && (body.startsWith("'") || body.startsWith('"'))) {
+            body = body.slice(1, -1);
+        }
+        // 5. Construct Berry String
+        const lines = [`Api ${method} #${id}`];
+        lines.push(`Url ${url}`);
+        if (body) {
+            // Inline the body for simplicity in CURL conversion
+            const cleanBody = body.replace(/\n/g, " ").trim();
+            lines.push(`Body JSON \`${cleanBody}\``);
+        }
+        if (Object.entries(headers).length > 0) {
+            lines.push("Header");
+            for (const [key, value] of Object.entries(headers)) {
+                lines.push(`- ${key}: '${value}'`);
+            }
+        }
+        return lines.join("\n") + "\n";
+    }
+    /**
+     * Build a Berry Api block from a command object
+     */
+    static buildApi(name, cmd) {
+        const lines = [`Api ${cmd.method.toUpperCase()} #${name} ${cmd.title || ""}`];
+        lines.push(`Url ${cmd.url}`);
+        if (cmd.body) {
+            const type = (cmd.bodyType || "JSON").toUpperCase();
+            lines.push(`Body ${type}`);
+            lines.push("`", cmd.body, "`");
+        }
+        if (cmd.headers) {
+            lines.push("Header");
+            const headerList = cmd.headers.split(",").map((h) => h.trim());
+            for (const h of headerList) {
+                if (h)
+                    lines.push(`- ${h}`);
+            }
+        }
+        return lines.join("\n") + "\n";
+    }
+    /**
+     * Build a Berry Var block
+     */
+    static buildVar(title, variables, env) {
+        const header = `Var ${env ? "@" + env : ""} ${title}`;
+        const lines = [header];
+        for (const v of variables) {
+            lines.push(`- ${v}`);
+        }
+        return lines.join("\n") + "\n";
+    }
+    /**
+     * Build a Berry Env block
+     */
+    static buildEnv(envs) {
+        const validEnvs = envs
+            .filter((e) => !!e)
+            .map((e) => e.trim().toUpperCase());
+        if (validEnvs.length === 0)
+            return "";
+        return `Env ${validEnvs.join(",")}\n`;
+    }
+}

package/dist/script/postman.util.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Postman Collection Interfaces (Minimal for conversion)
+ */
+export interface PostmanHeader {
+    key: string;
+    value: string;
+    description?: string;
+}
+export interface PostmanUrl {
+    raw: string;
+    protocol?: string;
+    host?: string[];
+    path?: string[];
+    query?: Array<{
+        key: string;
+        value: string;
+    }>;
+    variable?: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+export interface PostmanBody {
+    mode: "raw" | "urlencoded" | "formdata" | "file" | "graphql";
+    raw?: string;
+    urlencoded?: Array<{
+        key: string;
+        value: string;
+    }>;
+    formdata?: Array<{
+        key: string;
+        value: string;
+    }>;
+    options?: {
+        raw?: {
+            language: string;
+        };
+    };
+}
+export interface PostmanRequest {
+    method: string;
+    header: PostmanHeader[];
+    url: PostmanUrl | string;
+    body?: PostmanBody;
+}
+export interface PostmanItem {
+    name: string;
+    request?: PostmanRequest;
+    item?: PostmanItem[];
+}
+export interface PostmanCollection {
+    info: {
+        name: string;
+        schema: string;
+    };
+    item: PostmanItem[];
+}
+export declare class PostmanUtil {
+    /**
+     * Convert a Postman collection file (JSON) to Berry API code
+     * @param filePath Path to the Postman collection JSON file
+     */
+    static convertFromPostmanFile(filePath: string): string;
+    /**
+     * Internal recursive processor for Postman items
+     */
+    private static processItems;
+    /**
+     * Build URL string from Postman URL object
+     */
+    private static buildUrl;
+    /**
+     * Abbreviate title to camelCase ID
+     */
+    private static abbreviate;
+    /**
+     * Extract headers to Berry format
+     */
+    private static extractHeaders;
+    /**
+     * Extract body content from Postman request
+     */
+    private static extractBody;
+    /**
+     * Detect Berry body type from content-type or Postman options
+     */
+    private static detectBodyType;
+}