mimo-lang 1.1.0 → 1.1.1

package/README.md

@@ -1,15 +1,68 @@
 # mimo
 
-To install dependencies:
+[![GitHub release](https://img.shields.io/github/release/bethropolis/mimo?include_prereleases=&sort=semver&color=blue)](https://github.com/bethropolis/mimo/releases/)
+[![License](https://img.shields.io/badge/License-MIT-blue)](#license)
+[![Deploy to GitHub Pages](https://github.com/bethropolis/mimo/actions/workflows/deploy.yml/badge.svg)](https://github.com/bethropolis/mimo/actions/workflows/deploy.yml)
+
+a simple programming language written in js.
+
+## Instalation
+
+```sh
+# install globally
+npm install -g mimo-lang
+
+# install project scope
+npm install mimo-lang
 
-```bash
-bun install
 ```
 
-To run:
+### Global cli commands
+
+the folowing are available commands and flags for the cli tool.
 
 ```bash
-bun run index.js
+$ mimo [FILENAME] [-o|--output] [-t|--time] [-h|--help] [-q|--quiet] [-d|--debug] [-v|--version]
+```
+
+example `mimo exampleFile.mimo`
+
+### Library usage
+
+example:
+
+```js
+import Mimo from "../index.js";
+
+let mimo = new Mimo();
+
+let code = /* your code here*/
+
+mimo.run(code);
+```
+
+## Language syntax:
+
+```
+function add(a,b)
+  return + a b
+endfunction
+
+set x 5
+set y 2
+
+call add(x,y) -> result
+show result
 ```
 
-This project was created using `bun init` in bun v1.0.35. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.
+more example id the [test directory]('./test/mimo/')
+
+
+## About
+this is just a simple language i created to learn more about how programing languages work.
+contributions are welcome.
+
+## License
+Released under [MIT](./LICENSE)
+
+happy coding 💜

package/compiler/lexer/tokenizer.js

@@ -1,6 +1,17 @@
 import { processToken, processStringToken, processOperatorToken, isOperator } from './processToken.js';
 import { PUNCTUATION } from './tokenTypes.js';
 
+/**
+ * @typedef {Object} Token
+ * @property {string} type - The type of the token (e.g., 'number', 'identifier', 'operator', etc.).
+ * @property {string} value - The value of the token (e.g., '42', 'x', '+', etc.).
+ */
+
+/**
+ * Generate tokens from the given input.
+ * @param {string} input - The input to be tokenized.
+ * @returns {Token[]} An array of tokens.
+ */
 function generateTokens(input) {
     const tokens = [];
     let currentToken = "";

package/compiler/parser/parseStatement.js

@@ -10,7 +10,6 @@ import { showStatement } from "./statement/show.js";
 export const parseStatement = (tokens, index) => {
   let statement = { type: "statement" };
 
-  // console.log("parsing..", tokens[index].type, tokens[index].value);
   if (tokens[index].value === "set") {
     ({ statement, index } = setStatement(tokens, index));
   } else if (tokens[index].value === "if") {

package/compiler/parser/parser.js

@@ -1,5 +1,34 @@
 import { parseStatement } from "./parseStatement.js";
 
+
+/**
+ * @typedef {import('../lexer/tokenizer.js').Token} Token
+ */
+
+/**
+ * @typedef {Object} Node
+ * @property {string} type - The type of the node (e.g., 'binary', 'assignment', 'literal', etc.).
+ *  optionals
+ * @property {string} [operator] - The operator (e.g., '+', '-', '*', '/', etc.).
+ * @property {Node} [left] - The left node.
+ * @property {Node} [right] - The right node.
+ * @property {Node} [condition] - The expression node.
+ * @property {Node} [consequent] - The consequent node.
+ * @property {Node} [expression] - The expression node.
+ * @property {Node} [alternate] - The alternate node.
+ * @property {string} [target] - The target of the assignment.
+ * @property {number} [value] - The value to be assigned.
+ * @property {string} [name] - The name of functions and variables.
+ * @property {string[]} [params] - The parameters of a function.
+ * @property {Node[]} [body] - The body of a block statement.
+*/
+
+/**
+ * Parse the list of tokens into an abstract syntax tree (AST).
+ * @param {Token[]} tokens - The list of tokens to be parsed.
+ * @returns {Node[]} An array of AST nodes.
+ */
+
 export function parseTokens(tokens) {
     let index = 0;
 

package/compiler/parser/statement/function.js

@@ -7,7 +7,7 @@ export const functionStatement = (tokens, index) => {
   statement.name = tokens[index++]?.value;
   index++; // Skip 'function' and function name
   statement.params = [];
-  while (tokens[index]?.value !== ")") {
+  while (tokens[index] && tokens[index]?.value !== ")") {
     statement.params.push(tokens[index]?.value);
     index++; // Skip parameter
     if (tokens[index]?.value === ",") {
@@ -21,7 +21,7 @@ export const functionStatement = (tokens, index) => {
     body.push(result.statement);
     index = result.index; // Update the index
   }
-  if (tokens[index].value === "endfunction") {
+  if (tokens[index] && tokens[index].value === "endfunction") {
     index++;
   }
   statement.body = body;

package/converter/js/convert.js

@@ -1,7 +1,6 @@
-import pkg from 'js-beautify';
+import pkg from "js-beautify";
 const { js_beautify } = pkg;
 
-
 let declaredVariables = new Set();
 
 export function generateCodeFromAst(node) {
@@ -31,12 +30,13 @@ export function generateCodeFromAst(node) {
     case "list":
       return generateList(node);
     default:
-      console.log(node);
+      console.error(`Unknown node type: ${node.type} during conversion.`);
       throw new Error(`Unknown node type: ${node.type}`);
   }
 }
 
 export function generateCodeJsFromAstArray(ast) {
+  declaredVariables = new Set();
   const generatedCode = ast.map(generateCodeFromAst).join("\n");
   return js_beautify(generatedCode);
 }

package/index.js

@@ -3,39 +3,78 @@ import { parseTokens } from "./compiler/parser/parser.js";
 import { interpret } from "./compiler/execute/interpreter.js";
 import { generateCodeJsFromAstArray } from "./converter/js/convert.js";
 
-// The main class for the Mimo language
+
+
+/**
+ * @typedef {import('./compiler/lexer/tokenizer.js').Token} Token
+ */
+
+/**
+ * @typedef {import('./compiler/parser/parser.js').Node} Node
+ */
+
+
+/**
+ * The main class for the Mimo language.
+ */
 export default class Mimo {
   constructor() {
     // Initialize the environment for variables
     this.env = {};
   }
 
-  // Tokenize the given code into a list of tokens
+  /**
+   * Tokenize the given code into a list of tokens.
+   * @param {string} code - The code to be tokenized.
+   * @returns {Promise<Token[]>} A promise that resolves to an array of tokens.
+   */
   async tokenize(code) {
     return generateTokens(code);
   }
 
-  // Parse the list of tokens into an abstract syntax tree (AST)
+  /**
+   * Parse the list of tokens into an abstract syntax tree (AST).
+   * @param {Token[]} tokens - The list of tokens to be parsed.
+   * @returns {Promise<Node[]>} A promise that resolves to an array of AST nodes.
+   */
   async parse(tokens) {
     return parseTokens(tokens);
   }
 
-  // Interpret the AST and execute the code
+  /**
+   * Interpret the AST and execute the code.
+   * @param {Node[]} program - The AST to be interpreted.
+   * @returns {Promise<Object>} A promise that resolves to the result of interpreting the AST.
+   */
   async interpret(program) {
     return interpret(program, this.env);
   }
 
-  // Run the given code by tokenizing, parsing, and interpreting it
+  /**
+   * Run the given code by tokenizing, parsing, and interpreting it.
+   * @param {string} code - The code to be run.
+   * @returns {Promise<{program: Node[], env: Object}>} A promise that resolves to an object containing the AST and the environment.
+   */
   async run(code) {
     const tokens = await this.tokenize(code);
-    const program = await this.parse(tokens);
+    const program = await this.parse(tokens, this.env);
     const env = await this.interpret(program);
     return { program, env };
   }
 
-  // Convert the AST to JavaScript code
+  /**
+   * Clear the environment for variables.
+   */
+  clearEnv() {
+    this.env = {};
+  }
+
+  /**
+   * Convert the AST to JavaScript code.
+   * @param {Node[]} ast - The AST to be converted.
+   * @returns {string} The generated JavaScript code.
+   */
   toJS(ast) {
     return generateCodeJsFromAstArray(ast);
   }
-}
-
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mimo-lang",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "A programming language made in javascript mostly for learning purposes.",
   "keywords": [
     "programing language"
@@ -16,13 +16,15 @@
   "scripts": {
     "mimo": "bun cli.js",
     "dev": "bun index.js",
-    "test": "node test/index.js"
+    "test": "node test/index.js",
+    "build": "vite build"
   },
   "devDependencies": {
     "@types/bun": "latest"
   },
   "dependencies": {
-    "js-beautify": "^1.15.1"
+    "js-beautify": "^1.15.1",
+    "vite": "^5.2.10"
   },
   "repository": {
     "type": "git",

package/vite.config.js

@@ -0,0 +1,17 @@
+// vite.config.js
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  build: {
+    rollupOptions: {
+      input: {
+        main: './index.js' // Specify the entry point as index.js
+      },
+      output: {
+        manualChunks: false,
+        inlineDynamicImports: true,
+        entryFileNames: 'assets/[name].js' // Specify the output file name and directory
+      }
+    }
+  }
+})

package/i.js

@@ -1,30 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-function addJsExtensionToImports(filePath) {
-  const code = fs.readFileSync(filePath, 'utf8');
-  const newCode = code.replace(/from\s+(['"])(.*?)(?<!\.js)\1/g, 'from $1$2.js$1');
-  
-  if (code !== newCode) {
-    fs.writeFileSync(filePath, newCode, 'utf8');
-    console.log(`Updated imports in ${filePath}`);
-  }
-}
-
-function traverseDirectory(dirPath) {
-  const files = fs.readdirSync(dirPath);
-
-  for (const file of files) {
-    const filePath = path.join(dirPath, file);
-    const stats = fs.statSync(filePath);
-
-    if (stats.isDirectory()) {
-      traverseDirectory(filePath);
-    } else if (path.extname(filePath) === '.js') {
-      addJsExtensionToImports(filePath);
-    }
-  }
-}
-
-const rootDir = './';  // replace with your directory path
-traverseDirectory(rootDir);

package/test.js

@@ -1 +0,0 @@
-console.log(a)

package/webpack.config.js

@@ -1,9 +0,0 @@
-const path = require('path');
-
-module.exports = {
-  entry: './index.js', // Entry point of your application
-  output: {
-    filename: 'bundle.js', // Name of the bundled output file
-    path: path.resolve(__dirname, 'dist'), // Output directory
-  },
-};