oclang 1.2.1 → 1.2.2

package/BUG_REGISTRY.md

@@ -8,6 +8,7 @@ BUG-\<BUG-NUMBER>\<BUG-PART>-\<VERSION>-\<VERSION-FORMAT>
 
 - BUG-002A-100-MmP: CLI always uses force mode
 - BUG-002B-101-MmP: The errors in the CLI shows 'undefined'
+- BUG-002C-100-MmP: Dist folder is not created
 
 ## 0.3.0 bugs
 

package/CHANGELOG.md

@@ -25,6 +25,10 @@ PATCH version when you make backwards-compatible bug fixes.
 
 - REPL mode added
 
+#### 1.1.2 - BUG-002C-100-MmP
+
+- BUG-002C-100-MmP: Dist folder is not created
+
 #### 1.1.1 - BUG-002B-101-MmP
 
 - BUG-002B-100-MmP: The errors in the CLI shows 'undefined'

package/dist/cli/index.js

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

package/dist/cli/ocat/commands/index.js

@@ -0,0 +1,2 @@
+export * from "./run.js";
+export * from "./repl.js";

package/dist/cli/ocat/commands/repl.js

@@ -0,0 +1,39 @@
+import readline from "readline";
+import chalk from "chalk";
+import { execute } from "../../../core/index.js";
+export function repl() {
+    console.log(chalk.yellow("Orange Cat REPL v1.0.0"));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk.cyan("ocat> "),
+    });
+    rl.prompt();
+    rl.on("line", (line) => {
+        const input = line.trim();
+        // comandos internos
+        if (input === ".exit") {
+            rl.close();
+            return;
+        }
+        if (input === ".help") {
+            console.log(`
+.exit     Exit REPL
+.clear    Clear screen
+      `);
+            rl.prompt();
+            return;
+        }
+        if (input === ".clear") {
+            console.clear();
+            rl.prompt();
+            return;
+        }
+        execute(input);
+        rl.prompt();
+    });
+    rl.on("close", () => {
+        console.log("\nBye!");
+        process.exit(0);
+    });
+}

package/dist/cli/ocat/commands/run.js

@@ -0,0 +1,19 @@
+import { execute } from "../../../core/index.js";
+import { ExtensionError } from "../../../shared/manager/errors/io/extension.js";
+import chalk from "chalk";
+import fs from "fs";
+import { FileDoesntExistError } from "../../../shared/manager/errors/io/file.js";
+export function runfile(file, options) {
+    if (!file.endsWith(".ocat") && !options.force) {
+        new ExtensionError("File must be a .ocat file. Use -f to force execution with other extensions").throw();
+    }
+    if (options.force) {
+        console.log(chalk.blue(`Running in force mode`));
+    }
+    if (!fs.existsSync(file)) {
+        new FileDoesntExistError(`File ${file} doesn't exist`)
+            .throw();
+    }
+    const fileText = fs.readFileSync(file, "utf8");
+    execute(fileText);
+}

package/dist/cli/ocat/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { runfile } from "./commands/index.js";
+import { repl } from "./commands/index.js";
+const program = new Command();
+program
+    .name("ocat")
+    .description("The Orange Cat language compiler")
+    .version("1.0.0");
+program
+    .command("run")
+    .description("Run a file. This file must be a .ocat file")
+    .argument("<file>", "The file to run")
+    .option("-f, --force", "Force the execution with other extensions")
+    .action(runfile);
+program
+    .command("inline")
+    .description("An REPL for the Orange Cat language")
+    .action(repl);
+program.parse();

package/dist/cli/ocm/commands/index.js

@@ -0,0 +1,2 @@
+export * from "./init.js";
+export * from "./run.js";

package/dist/cli/ocm/commands/init.js

@@ -0,0 +1,41 @@
+import inquirer from "inquirer";
+import chalk, {} from "chalk";
+import { chalkText } from "../../utils/chalkText.js";
+import { createProject } from "../../../project/index.js";
+import { fromCamelToDash } from "../../../shared/utils/strformat.js";
+export async function init() {
+    const projectTypes = [{ name: "App", color: chalk.red }, { name: "Lib", color: chalk.yellow }];
+    const answers = await inquirer.prompt([
+        {
+            type: "input",
+            name: "name",
+            message: "How do you want to name your project?",
+            default: "myProject",
+        },
+        {
+            type: "input",
+            name: "dir",
+            message: "Where do you want to create your project?",
+            default: (answers) => answers.name,
+        },
+        {
+            type: "input",
+            name: "id",
+            message: "What is your project ID?",
+            default: (answers) => fromCamelToDash(answers.name),
+        },
+        {
+            type: "select",
+            name: "type",
+            message: "What type of project do you want to create?",
+            choices: projectTypes
+                .map((choice) => chalkText(choice.name, choice.color)),
+        }
+    ]);
+    createProject({
+        name: answers.name,
+        dir: answers.dir,
+        type: answers.type,
+        id: answers.id,
+    });
+}

package/dist/cli/ocm/commands/run.js

@@ -0,0 +1,17 @@
+import path from "path";
+import { readJSON } from "../../../shared/io/json.js";
+import { runfile } from "../../ocat/commands/index.js";
+import * as context from "../../../shared/context/globalContext.js";
+import { defaultLoggerConfig, LoggerService } from "../../../core/services/log.service.js";
+export function run() {
+    const projectConfig = readJSON(path.join(".ocat", "config.json"));
+    context.set("isProject", true);
+    context.set("projectConfig", projectConfig);
+    context.set("services", {});
+    context.useObject("services", services => {
+        return {
+            log: new LoggerService(defaultLoggerConfig),
+        };
+    });
+    runfile(projectConfig.main, { force: false });
+}

package/dist/cli/ocm/index.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { init, run } from "./commands/index.js";
+const program = new Command();
+program.name("ocm").description("The Orange Cat manager").version("1.0.0");
+program
+    .command("initialize")
+    .alias("init")
+    .description("Initialize a new Orange Cat project")
+    .action(async () => { await init(); });
+program
+    .command("run")
+    .description("Run the project")
+    .action(run);
+program.parse();

package/dist/cli/utils/chalkText.js

@@ -0,0 +1,6 @@
+export function chalkText(text, color) {
+    return {
+        name: color(text),
+        value: text
+    };
+}

package/dist/core/ast/astBuilder.js

@@ -0,0 +1,150 @@
+import { createCoreContext } from "../context/coreContext.js";
+import { ValueType } from "../../shared/models/value.js";
+import { StatementKind } from "./types/base/index.js";
+export function buildAst(cst) {
+    const statements = cst.children.statement ?? [];
+    const ast = [];
+    for (const statement of statements) {
+        let __tmp = null;
+        const __$tmp = () => { if (__tmp)
+            ast.push(__tmp); };
+        __tmp = printStatement(statement);
+        __$tmp();
+        __tmp = variableStatement(statement);
+        __$tmp();
+        __tmp = functionStatement(statement);
+        __$tmp();
+        __tmp = callStatement(statement);
+        __$tmp();
+    }
+    return ast;
+}
+const printStatement = (statement) => {
+    const printStmt = statement.children.printStatement?.[0];
+    if (printStmt) {
+        const strToken = printStmt.children.StringLiteral?.[0];
+        if (strToken) {
+            return {
+                kind: StatementKind.PrintStatement,
+                sourceInfo: {
+                    tokens: printStmt.children,
+                    cstNode: printStmt,
+                    startLine: printStmt.startLine,
+                    endLine: printStmt.endLine,
+                    startColumn: printStmt.startColumn,
+                    endColumn: printStmt.endColumn,
+                },
+                value: {
+                    value: strToken.image,
+                    type: ValueType.String,
+                }
+            };
+        }
+        const idToken = printStmt.children.Identifier?.[0];
+        if (idToken) {
+            return {
+                kind: StatementKind.PrintStatement,
+                sourceInfo: {
+                    tokens: printStmt.children,
+                    cstNode: printStmt,
+                    startLine: printStmt.startLine,
+                    endLine: printStmt.endLine,
+                    startColumn: printStmt.startColumn,
+                    endColumn: printStmt.endColumn,
+                },
+                value: {
+                    value: idToken.image,
+                    type: ValueType.Identifier,
+                }
+            };
+        }
+    }
+    return null;
+};
+const variableStatement = (statement) => {
+    const varStmt = statement.children.variableStatement?.[0];
+    if (varStmt) {
+        const typeToken = varStmt.children.VarType?.[0];
+        const idToken = varStmt.children.Identifier?.[0];
+        const valueToken = varStmt.children.StringLiteral?.[0] ??
+            varStmt.children.NumberLiteral?.[0] ??
+            varStmt.children.BooleanLiteral?.[0];
+        if (!typeToken || !idToken || !valueToken)
+            return null;
+        const setToken = varStmt.children.Set?.[0];
+        const constToken = varStmt.children.Const?.[0];
+        const type = typeToken.image;
+        const id = idToken.image;
+        const value = valueToken.image;
+        return {
+            kind: StatementKind.VariableStatement,
+            sourceInfo: {
+                tokens: varStmt.children,
+                cstNode: varStmt,
+                startLine: varStmt.startLine,
+                endLine: varStmt.endLine,
+                startColumn: varStmt.startColumn,
+                endColumn: varStmt.endColumn,
+            },
+            id,
+            var: {
+                type,
+                value,
+                props: {
+                    isConst: !!constToken,
+                }
+            },
+            set: !!setToken,
+        };
+    }
+    return null;
+};
+const functionStatement = (statement) => {
+    const funcStmt = statement.children.functionStatement?.[0];
+    if (funcStmt) {
+        const idToken = funcStmt.children.Identifier?.[0];
+        if (!idToken)
+            return null;
+        const id = idToken.image;
+        const body = buildAst(funcStmt);
+        return {
+            kind: StatementKind.FunctionStatement,
+            sourceInfo: {
+                tokens: funcStmt.children,
+                cstNode: funcStmt,
+                startLine: funcStmt.startLine,
+                endLine: funcStmt.endLine,
+                startColumn: funcStmt.startColumn,
+                endColumn: funcStmt.endColumn,
+            },
+            id,
+            func: {
+                body,
+                scope: createCoreContext(),
+            }
+        };
+    }
+    return null;
+};
+const callStatement = (statement) => {
+    const callStmt = statement.children.callStatement?.[0];
+    if (callStmt) {
+        const idToken = callStmt.children.Identifier?.[0];
+        if (!idToken)
+            return null;
+        const id = idToken.image;
+        return {
+            kind: StatementKind.CallStatement,
+            sourceInfo: {
+                tokens: callStmt.children,
+                cstNode: callStmt,
+                startLine: callStmt.startLine,
+                endLine: callStmt.endLine,
+                startColumn: callStmt.startColumn,
+                endColumn: callStmt.endColumn,
+            },
+            id,
+        };
+    }
+    return null;
+};

package/dist/core/ast/types/base/index.js

@@ -0,0 +1,2 @@
+export * from "./statement.js";
+export * from "./source.js";

package/dist/core/ast/types/base/source.js

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

package/dist/core/ast/types/base/statement.js

@@ -0,0 +1,7 @@
+export var StatementKind;
+(function (StatementKind) {
+    StatementKind[StatementKind["PrintStatement"] = 0] = "PrintStatement";
+    StatementKind[StatementKind["VariableStatement"] = 1] = "VariableStatement";
+    StatementKind[StatementKind["FunctionStatement"] = 2] = "FunctionStatement";
+    StatementKind[StatementKind["CallStatement"] = 3] = "CallStatement";
+})(StatementKind || (StatementKind = {}));

package/dist/core/ast/types/statements/callStatement.js

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

package/dist/core/ast/types/statements/functionStatement.js

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

package/dist/core/ast/types/statements/index.js

@@ -0,0 +1,4 @@
+export * from "./printStatement";
+export * from "./variableStatement";
+export * from "./functionStatement";
+export * from "./callStatement";

package/dist/core/ast/types/statements/printStatement.js

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

package/dist/core/ast/types/statements/variableStatement.js

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

package/dist/core/context/contextType.js

@@ -0,0 +1,5 @@
+export var ContextType;
+(function (ContextType) {
+    ContextType["Variable"] = "Variable";
+    ContextType["Function"] = "Function";
+})(ContextType || (ContextType = {}));

package/dist/core/context/coreContext.js

@@ -0,0 +1,6 @@
+export function createCoreContext() {
+    return {
+        variables: {},
+        functions: {},
+    };
+}

package/dist/core/index.js

@@ -0,0 +1,22 @@
+import { ocatLexer } from "./lexer/tokens.js";
+import { OcatParser } from "./parser/parser.js";
+import { run } from "./runner/runner.js";
+import { createCoreContext } from "./context/coreContext.js";
+import { buildAst } from "./ast/astBuilder.js";
+import * as ctx from "../shared/context/globalContext.js";
+import fs from "fs";
+export function execute(code) {
+    const lexingResult = ocatLexer.tokenize(code);
+    const parser = new OcatParser();
+    parser.input = lexingResult.tokens;
+    const cst = parser.program();
+    const ast = buildAst(cst);
+    process.on("exit", () => {
+        if (ctx.get("isProject")) {
+            const logs = ctx.get("services").log.toString();
+            fs.writeFileSync(".ocat/logs.txt", logs);
+        }
+    });
+    const context = createCoreContext();
+    run(ast, context);
+}

package/dist/core/lexer/tokens/attrs.js

@@ -0,0 +1,6 @@
+import { createToken, Lexer } from "chevrotain";
+export const Const = createToken({
+    name: "Const",
+    pattern: /const/,
+});
+export const attributes = [Const];

package/dist/core/lexer/tokens/comments.js

@@ -0,0 +1,12 @@
+import { createToken, Lexer } from "chevrotain";
+export const LineComment = createToken({
+    name: "LineComment",
+    pattern: /\/\/[^\n]*/,
+    group: Lexer.SKIPPED,
+});
+export const BlockComment = createToken({
+    name: "BlockComment",
+    pattern: /\/\*[\s\S]*?\*\//,
+    group: Lexer.SKIPPED,
+});
+export const comments = [LineComment, BlockComment];

package/dist/core/lexer/tokens/delimiters.js

@@ -0,0 +1,11 @@
+import { createToken } from "chevrotain";
+export const LeftParen = createToken({ name: "LeftParen", pattern: /\(/ });
+export const RightParen = createToken({ name: "RightParen", pattern: /\)/ });
+export const LeftBrace = createToken({ name: "LeftBrace", pattern: /\{/ });
+export const RightBrace = createToken({ name: "RightBrace", pattern: /\}/ });
+export const LeftBracket = createToken({ name: "LeftBracket", pattern: /\[/ });
+export const RightBracket = createToken({ name: "RightBracket", pattern: /\]/ });
+export const LeftTag = createToken({ name: "LeftTag", pattern: /</ });
+export const RightTag = createToken({ name: "RightTag", pattern: />/ });
+export const Comma = createToken({ name: "Comma", pattern: /,/ });
+export const delimiters = [LeftParen, RightParen, LeftBrace, RightBrace, LeftBracket, RightBracket, LeftTag, RightTag, Comma];

package/dist/core/lexer/tokens/function.js

@@ -0,0 +1,10 @@
+import { createToken } from "chevrotain";
+export const Function = createToken({
+    name: "Function",
+    pattern: /func/,
+});
+export const Call = createToken({
+    name: "Call",
+    pattern: /call/,
+});
+export const functions = [Function, Call];

package/dist/core/lexer/tokens/ignored.js

@@ -0,0 +1,3 @@
+import { createToken } from "chevrotain";
+export const WhiteSpace = createToken({ name: "WhiteSpace", pattern: /\s+/ });
+export const ignored = [WhiteSpace];

package/dist/core/lexer/tokens/index.js

@@ -0,0 +1,29 @@
+export * from "./ignored.js";
+export * from "./comments.js";
+export * from "./keywords.js";
+export * from "./literals.js";
+export * from "./delimiters.js";
+export * from "./vars.js";
+export * from "./operators.js";
+export * from "./attrs.js";
+export * from "./function.js";
+import { ignored } from "./ignored.js";
+import { comments } from "./comments.js";
+import { keywords } from "./keywords.js";
+import { literals } from "./literals.js";
+import { delimiters } from "./delimiters.js";
+import { variablesAndConstants } from "./vars.js";
+import { operators } from "./operators.js";
+import { attributes } from "./attrs.js";
+import { functions } from "./function.js";
+export const allTokens = [
+    ...ignored,
+    ...comments,
+    ...keywords,
+    ...attributes,
+    ...functions,
+    ...literals,
+    ...delimiters,
+    ...variablesAndConstants,
+    ...operators,
+];

package/dist/core/lexer/tokens/keywords.js

@@ -0,0 +1,3 @@
+import { createToken } from "chevrotain";
+export const Output = createToken({ name: "Output", pattern: /print/ });
+export const keywords = [Output];

package/dist/core/lexer/tokens/literals.js

@@ -0,0 +1,14 @@
+import { createToken } from "chevrotain";
+export const StringLiteral = createToken({
+    name: "StringLiteral",
+    pattern: /"(?:[^\\"]|\\.)*"/,
+});
+export const NumberLiteral = createToken({
+    name: "NumberLiteral",
+    pattern: /\d+(\.\d+)?/,
+});
+export const BooleanLiteral = createToken({
+    name: "BooleanLiteral",
+    pattern: /true|false/,
+});
+export const literals = [StringLiteral, NumberLiteral, BooleanLiteral];

package/dist/core/lexer/tokens/operators.js

@@ -0,0 +1,3 @@
+import { createToken } from "chevrotain";
+export const Assign = createToken({ name: "Assign", pattern: /=/ });
+export const operators = [Assign];

package/dist/core/lexer/tokens/vars.js

@@ -0,0 +1,12 @@
+import { createToken } from "chevrotain";
+import { ValueType } from "../../../shared/models/value.js";
+export const VarType = createToken({
+    name: "VarType",
+    pattern: new RegExp(Object.values(ValueType).join("|")),
+});
+export const Set = createToken({ name: "Set", pattern: /set/ });
+export const Identifier = createToken({
+    name: "Identifier",
+    pattern: /[a-zA-Z_]\w*/,
+});
+export const variablesAndConstants = [VarType, Set, Identifier];

package/dist/core/lexer/tokens.js

@@ -0,0 +1,3 @@
+import { Lexer } from "chevrotain";
+import { allTokens } from "./tokens/index.js";
+export const ocatLexer = new Lexer(allTokens);

package/dist/core/parser/parser.js

@@ -0,0 +1,84 @@
+import { CstParser } from "chevrotain";
+import { ValueType } from "../../shared/models/value.js";
+import * as token from "../lexer/tokens/index.js";
+export class OcatParser extends CstParser {
+    constructor() {
+        super(token.allTokens, {
+            recoveryEnabled: true,
+        });
+        this.performSelfAnalysis();
+    }
+    program = this.RULE("program", () => {
+        this.MANY(() => this.SUBRULE(this.statement));
+    });
+    statement = this.RULE("statement", () => {
+        this.OR([
+            {
+                ALT: () => this.SUBRULE(this.printStatement, {
+                    LABEL: "printStatement",
+                }),
+            },
+            {
+                ALT: () => this.SUBRULE(this.variableStatement, {
+                    LABEL: "variableStatement",
+                }),
+            },
+            {
+                ALT: () => this.SUBRULE(this.functionStatement, {
+                    LABEL: "functionStatement",
+                }),
+            },
+            {
+                ALT: () => this.SUBRULE(this.callStatement, {
+                    LABEL: "callStatement",
+                }),
+            },
+        ]);
+    });
+    printStatement = this.RULE("printStatement", () => {
+        this.CONSUME(token.Output);
+        this.CONSUME(token.LeftParen);
+        this.OR([
+            ...token.literals.map((lit) => ({
+                ALT: () => this.CONSUME(lit, { LABEL: lit.name }),
+            })),
+            {
+                ALT: () => this.CONSUME(token.Identifier, { LABEL: "Identifier" }),
+            },
+        ]);
+        this.CONSUME(token.RightParen);
+    });
+    variableStatement = this.RULE("variableStatement", () => {
+        this.OPTION(() => {
+            this.OR([
+                { ALT: () => this.CONSUME(token.Set, { LABEL: "Set" }) },
+                { ALT: () => this.CONSUME(token.Const, { LABEL: "Const" }) },
+            ]);
+        });
+        const type = this.CONSUME(token.VarType).image;
+        this.CONSUME(token.Identifier);
+        this.CONSUME(token.Assign);
+        switch (type) {
+            case ValueType.String:
+                this.CONSUME(token.StringLiteral);
+                break;
+            case ValueType.Number:
+                this.CONSUME(token.NumberLiteral);
+                break;
+            case ValueType.Boolean:
+                this.CONSUME(token.BooleanLiteral);
+                break;
+        }
+    });
+    functionStatement = this.RULE("functionStatement", () => {
+        this.CONSUME(token.Function);
+        this.CONSUME(token.Identifier);
+        this.CONSUME(token.LeftBrace);
+        this.MANY(() => this.SUBRULE(this.statement));
+        this.CONSUME(token.RightBrace);
+    });
+    callStatement = this.RULE("callStatement", () => {
+        this.CONSUME(token.Call);
+        this.CONSUME(token.Identifier);
+    });
+}

package/dist/core/runner/runner.js

@@ -0,0 +1,108 @@
+import { AlreadyDeclaredFunctionError, AlreadyDeclaredVariableError, CantModifyConstError, } from "../../shared/manager/errors/semantic/undefined/declared.js";
+import { UndeclaredFunctionError, UndeclaredVariableError, } from "../../shared/manager/errors/semantic/undefined/undeclared.js";
+import { createCoreContext } from "../context/coreContext.js";
+import { ValueType } from "../../shared/models/value.js";
+import { solveString } from "./utils/string.js";
+import { StatementKind } from "../ast/types/base/statement.js";
+import * as ctx from "../../shared/context/globalContext.js";
+export function run(ast, context) {
+    for (const statement of ast) {
+        switch (statement.kind) {
+            case StatementKind.PrintStatement:
+                printStatement(statement, context);
+                break;
+            case StatementKind.VariableStatement:
+                variableStatement(statement, context);
+                break;
+            case StatementKind.FunctionStatement:
+                functionStatement(statement, context);
+                break;
+            case StatementKind.CallStatement:
+                callStatement(statement, context);
+                break;
+        }
+    }
+}
+function printStatement(statement, context) {
+    let val;
+    switch (statement.value.type) {
+        case ValueType.Identifier:
+            const id = statement.value.value;
+            const varData = context.variables[id];
+            if (varData !== undefined) {
+                val = varData.value;
+            }
+            else {
+                new UndeclaredVariableError(id).throw(statement.sourceInfo.startLine);
+            }
+            break;
+        case ValueType.String:
+            val = solveString(statement.value.value, context, (err) => {
+                err.throw(statement.sourceInfo.startLine);
+            });
+            break;
+        default:
+            val = statement.value.value;
+            break;
+    }
+    const info = ctx.get("services").log;
+    info.info(val);
+}
+function variableStatement(statement, context) {
+    const varId = statement.id;
+    if (statement.set) {
+        if (!context.variables[varId]) {
+            new UndeclaredVariableError(varId).throw(statement.sourceInfo.startLine);
+        }
+        if (context.variables[varId]?.props.isConst) {
+            new CantModifyConstError(varId).throw(statement.sourceInfo.startLine);
+        }
+    }
+    else if (!statement.var.props.isConst) {
+        if (context.variables[varId]) {
+            new AlreadyDeclaredVariableError(varId).throw(statement.sourceInfo.startLine);
+        }
+    }
+    let value = statement.var.value;
+    switch (statement.var.type) {
+        case ValueType.String:
+            value = solveString(value, context, (err) => {
+                err.throw(statement.sourceInfo.startLine);
+            });
+            break;
+        default:
+            break;
+    }
+    context.variables[varId] = {
+        type: statement.var.type,
+        value,
+        props: {
+            isConst: !!statement.var.props.isConst,
+        },
+    };
+}
+function functionStatement(statement, context) {
+    const idToken = statement.id;
+    if (!idToken)
+        return;
+    const funcData = context.functions[idToken];
+    if (funcData) {
+        new AlreadyDeclaredFunctionError(idToken).throw(statement.sourceInfo.startLine);
+    }
+    const body = statement.func.body ?? [];
+    const scope = statement.func.scope;
+    context.functions[idToken] = {
+        body,
+        scope,
+    };
+}
+function callStatement(statement, context) {
+    const funcId = statement.id;
+    if (!funcId)
+        return;
+    const funcData = context.functions[funcId];
+    if (!funcData) {
+        new UndeclaredFunctionError(funcId).throw(statement.sourceInfo.startLine);
+    }
+    run(funcData.body, context.functions[funcId].scope);
+}

package/dist/core/runner/utils/string.js

@@ -0,0 +1,14 @@
+import { OcatError } from "../../../shared/manager/errors/coreErrors.js";
+import { UndeclaredVariableError } from "../../../shared/manager/errors/semantic/undefined/undeclared.js";
+export function solveString(input, context, err) {
+    let str = input;
+    str = str.slice(1, -1);
+    str = str.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+        const value = context.variables[varName.trim()];
+        if (!value) {
+            err(new UndeclaredVariableError(varName.trim()));
+        }
+        return value?.value ?? "";
+    });
+    return str;
+}

package/dist/core/services/log.service.js

@@ -0,0 +1,53 @@
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["Debug"] = "DEBUG";
+    LogLevel["Info"] = "INFO";
+    LogLevel["Warning"] = "WARNING";
+    LogLevel["Error"] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+export class LoggerService {
+    logs = [];
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    log(message, level = LogLevel.Info) {
+        this.logs.push({ message, level });
+        this.config.interceptors.forEach(interceptor => {
+            if (interceptor.level === level) {
+                message = interceptor.onLog(message);
+            }
+        });
+        if (this.config.logs.includes(level)) {
+            console.log(message);
+        }
+    }
+    debug(message) {
+        this.log(message, LogLevel.Debug);
+    }
+    info(message) {
+        this.log(message, LogLevel.Info);
+    }
+    warning(message) {
+        this.log(message, LogLevel.Warning);
+    }
+    error(message) {
+        this.log(message, LogLevel.Error);
+    }
+    getLogs() {
+        return this.logs;
+    }
+    pushInterceptor(interceptor) {
+        this.config.interceptors.push(interceptor);
+    }
+    removeInterceptor(interceptor) {
+        this.config.interceptors = this.config.interceptors.filter(i => i !== interceptor);
+    }
+    toString() {
+        return this.logs.map(log => `[${log.level}] ${log.message}`).join("\n");
+    }
+}
+export const defaultLoggerConfig = {
+    interceptors: [],
+    logs: [LogLevel.Debug, LogLevel.Info],
+};

package/dist/project/index.js

@@ -0,0 +1,22 @@
+import fs from 'fs';
+import path from 'path';
+import { ProjectType } from "./models/project.js";
+import { addIf } from '../shared/utils/objects.js';
+export function createProject(ps) {
+    const projectPath = path.resolve(ps.dir);
+    fs.mkdirSync(path.join(projectPath, "src"), { recursive: true });
+    fs.mkdirSync(path.join(projectPath, "connection"), { recursive: true });
+    fs.mkdirSync(path.join(projectPath, ".ocat"), { recursive: true });
+    const mainFile = path.join(projectPath, "src", "main.ocat");
+    if (ps.type !== ProjectType.Lib) {
+        fs.writeFileSync(mainFile, 'print("Hello World!")');
+    }
+    fs.writeFileSync(path.join(projectPath, ".ocat", "config.json"), JSON.stringify({
+        name: ps.name,
+        version: "1.0.0",
+        description: "",
+        id: ps.id,
+        ...addIf(ps.type !== ProjectType.Lib, { main: path.join("src", "main.ocat") }),
+        type: ps.type.toLowerCase(),
+    }, null, 4));
+}

package/dist/project/models/project.js

@@ -0,0 +1,5 @@
+export var ProjectType;
+(function (ProjectType) {
+    ProjectType["App"] = "App";
+    ProjectType["Lib"] = "Lib";
+})(ProjectType || (ProjectType = {}));

package/dist/project/utils/project.js

@@ -0,0 +1,11 @@
+import { ProjectType } from "../models/project.js";
+export function toProjectType(type) {
+    switch (type) {
+        case "App":
+            return ProjectType.App;
+        case "Lib":
+            return ProjectType.Lib;
+        default:
+            return ProjectType.App;
+    }
+}

package/dist/shared/context/globalContext.js

@@ -0,0 +1,16 @@
+let globalContext = {};
+export function get(key) {
+    return globalContext[key];
+}
+export function set(key, value) {
+    globalContext[key] = value;
+}
+export function useArray(key, modify) {
+    set(key, modify(get(key)));
+}
+export function useObject(key, modify) {
+    set(key, modify(get(key)));
+}
+export function useContext(modify) {
+    globalContext = modify(globalContext);
+}

package/dist/shared/io/json.js

@@ -0,0 +1,7 @@
+import fs from "fs";
+export function readJSON(file) {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+export function writeJSON(path, data) {
+    fs.writeFileSync(path, JSON.stringify(data, null, 4));
+}

package/dist/shared/manager/baseManager.js

@@ -0,0 +1,30 @@
+import chalk, {} from "chalk";
+import * as ctx from "../context/globalContext.js";
+export class OcatManager {
+    name;
+    message;
+    color;
+    level;
+    constructor(name, color, level) {
+        this.name = name;
+        this.message = "";
+        this.color = color;
+        this.level = level;
+    }
+    toString(line = undefined) {
+        return `${this.color.bold(this.name)}${line ? chalk.gray(` at line ${line}`) : ""}: ${this.color.italic(this.message)}`;
+    }
+    build(line = undefined) {
+        return `${this.name}${line ?? ""}: ${this.message}`;
+    }
+    setMessage(message) {
+        this.message = message;
+        return this;
+    }
+    throw(line = undefined) {
+        console.log(this.toString(line));
+        const log = ctx.get("services").log;
+        log.log(this.build(line), this.level);
+        process.exit(1);
+    }
+}

package/dist/shared/manager/errors/coreErrors.js

@@ -0,0 +1,8 @@
+import chalk from "chalk";
+import { OcatManager } from "../baseManager.js";
+import { LogLevel } from "../../../core/services/log.service.js";
+export class OcatError extends OcatManager {
+    constructor(name) {
+        super(name, chalk.red, LogLevel.Error);
+    }
+}

package/dist/shared/manager/errors/io/extension.js

@@ -0,0 +1,7 @@
+import { OcatError } from "../coreErrors.js";
+export class ExtensionError extends OcatError {
+    constructor(message) {
+        super("ExtensionError");
+        this.setMessage(message);
+    }
+}

package/dist/shared/manager/errors/io/file.js

@@ -0,0 +1,7 @@
+import { OcatError } from "../coreErrors.js";
+export class FileDoesntExistError extends OcatError {
+    constructor(message) {
+        super("FileDoesn'tExistError");
+        this.setMessage(message);
+    }
+}

package/dist/shared/manager/errors/semantic/undefined/declared.js

@@ -0,0 +1,24 @@
+import { ContextType } from "../../../../../core/context/contextType.js";
+import { OcatError } from "../../coreErrors.js";
+export class AlreadyDeclaredError extends OcatError {
+    constructor(varName, type) {
+        super(`Already declared ${type.toLowerCase()}`);
+        this.setMessage(`${type} ${varName} is already declared`);
+    }
+}
+export class AlreadyDeclaredVariableError extends AlreadyDeclaredError {
+    constructor(varName) {
+        super(varName, ContextType.Variable);
+    }
+}
+export class AlreadyDeclaredFunctionError extends AlreadyDeclaredError {
+    constructor(varName) {
+        super(varName, ContextType.Function);
+    }
+}
+export class CantModifyConstError extends OcatError {
+    constructor(varName) {
+        super(`Can't modify const variable`);
+        this.setMessage(`Variable ${varName} is const and can't be modified`);
+    }
+}

package/dist/shared/manager/errors/semantic/undefined/undeclared.js

@@ -0,0 +1,18 @@
+import { ContextType } from "../../../../../core/context/contextType.js";
+import { OcatError } from "../../coreErrors.js";
+export class UndeclaredError extends OcatError {
+    constructor(varName, type) {
+        super(`Undeclared ${type.toLowerCase()}`);
+        this.setMessage(`${type} ${varName} is not declared`);
+    }
+}
+export class UndeclaredVariableError extends UndeclaredError {
+    constructor(varName) {
+        super(varName, ContextType.Variable);
+    }
+}
+export class UndeclaredFunctionError extends UndeclaredError {
+    constructor(varName) {
+        super(varName, ContextType.Function);
+    }
+}

package/dist/shared/manager/errors/syntax/syntaxErrors.js

@@ -0,0 +1,7 @@
+import { OcatError } from "../coreErrors.js";
+export class SyntaxError extends OcatError {
+    constructor(message) {
+        super("SyntaxError");
+        this.setMessage(message);
+    }
+}

package/dist/shared/manager/errors/syntax/token.js

@@ -0,0 +1,11 @@
+import { SyntaxError } from "./syntaxErrors.js";
+export class UndefinedToken extends SyntaxError {
+    constructor() {
+        super(`Undefined token`);
+    }
+}
+export class UnexpectedToken extends SyntaxError {
+    constructor(token) {
+        super(`Unexpected token: ${token}`);
+    }
+}

package/dist/shared/manager/warn/coreWarnings.js

@@ -0,0 +1,8 @@
+import chalk from "chalk";
+import { OcatManager } from "../baseManager";
+import { LogLevel } from "../../../core/services/log.service";
+export class OcatWarning extends OcatManager {
+    constructor(name) {
+        super(name, chalk.yellow, LogLevel.Warning);
+    }
+}

package/dist/shared/models/func.js

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

package/dist/shared/models/value.js

@@ -0,0 +1,7 @@
+export var ValueType;
+(function (ValueType) {
+    ValueType["String"] = "string";
+    ValueType["Number"] = "number";
+    ValueType["Boolean"] = "bool";
+    ValueType["Identifier"] = "identifier";
+})(ValueType || (ValueType = {}));

package/dist/shared/models/var.js

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

package/dist/shared/utils/objects.js

@@ -0,0 +1,6 @@
+export function addIf(cond, value) {
+    return cond ? value : undefined;
+}
+export function addIfElse(cond, value, elseValue) {
+    return cond ? value : elseValue;
+}

package/dist/shared/utils/strformat.js

@@ -0,0 +1,12 @@
+export function fromCamelToDash(str) {
+    return str.replace(/([A-Z])/g, (match) => "-" + match.toLowerCase());
+}
+export function fromDashToCamel(str) {
+    return str.replace(/-([a-z])/g, (match) => match[1].toUpperCase());
+}
+export function fromCamelToSnake(str) {
+    return str.replace(/([A-Z])/g, (match) => "_" + match.toLowerCase());
+}
+export function fromSnakeToCamel(str) {
+    return str.replace(/_([a-z])/g, (match) => match[1].toUpperCase());
+}

package/package.json

@@ -1,30 +1,30 @@
-{
-  "name": "oclang",
-  "version": "1.2.1",
-  "description": "A programming language",
-  "author": "LuisRG-L, Orange Cat",
-  "license": "MIT",
-  "type": "module",
-  "module": "src/index.ts",
-  "bin": {
-    "ocat": "dist/cli/ocat/index.js",
-    "ocm": "dist/cli/ocm/index.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "tsc && npm link --force"
-  },
-  "devDependencies": {
-    "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
-  },
-  "dependencies": {
-    "@types/node": "^25.0.3",
-    "chalk": "^5.6.2",
-    "chevrotain": "^11.0.3",
-    "commander": "^14.0.2",
-    "inquirer": "^13.1.0"
-  }
-}
+{
+  "name": "oclang",
+  "version": "1.2.2",
+  "description": "A programming language",
+  "author": "LuisRG-L, Orange Cat",
+  "license": "MIT",
+  "type": "module",
+  "module": "src/index.ts",
+  "bin": {
+    "ocat": "dist/cli/ocat/index.js",
+    "ocm": "dist/cli/ocm/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc && npm link --force"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@types/node": "^25.0.3",
+    "chalk": "^5.6.2",
+    "chevrotain": "^11.0.3",
+    "commander": "^14.0.2",
+    "inquirer": "^13.1.0"
+  }
+}