bimba-cli 0.1.1

package/README.md

@@ -0,0 +1,15 @@
+# bimba-cli
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.0.26. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/bunfig.toml

@@ -0,0 +1 @@
+preload = ["./plugin.ts"]

package/index.ts

@@ -0,0 +1,148 @@
+#!~/.bun/bin bun
+
+import { parseArgs } from "util";
+import ansis from 'ansis';
+import { imbaPlugin, stats } from './plugin.ts'
+import fs from 'fs'
+import path from 'path';
+import { $ } from "bun";
+
+let flags = {};
+let folders = {};
+
+try {
+    const { values, positionals } = parseArgs({
+        args: Bun.argv,
+        options: {
+            watch: { type: 'boolean' },
+            outdir: { type: 'string' },
+            help: { type: 'boolean' },
+            minify: { type: 'boolean' },
+            target: { type: 'string' },
+            sourcemap: { type: 'string' },
+        },
+        strict: true,
+        allowPositionals: true,
+    });
+    flags = values;
+    flags.entry = Bun.argv[2];
+    folders = positionals;
+}
+catch (error) {
+    if (error instanceof Error)
+        console.log(error.message);
+    else
+        console.log("Could not resolve CLI arguments. Read help to know them: " + theme.flags('--entry file.imba'));
+    process.exit(1);
+}
+
+const theme = {
+    flags: ansis.fg(5),
+    count: ansis.fg(15).bold,
+	start: ansis.fg(252).bg(233),
+	filedir: ansis.fg(15),
+	success: ansis.fg(40),
+	failure: ansis.fg(196),
+	time: ansis.fg(41),
+	link: ansis.fg(15),
+	online: ansis.fg(40).bg(22)
+};
+
+// help: more on bun building params here: https://bun.sh/docs/bundler
+if(flags.help) {
+    console.log("");
+    console.log("Bimba requeres an .imba file as the first argument.");
+    console.log("By default the provided .imba file will be launched (the project will be compiled on the fly by Bun):");
+    console.log("   "+theme.flags('bimba <file.imba>')+"           The entrypoint of the imba project");
+    console.log("");
+    console.log("To compile Imba project to .js file the outdir should be specified:");
+    console.log("   "+theme.flags('--outdir <folder>')+"                          Compile imba files to specified folder");
+    console.log("");
+    console.log("There are other options that could be used when compiling .imba files:");
+    console.log("   "+theme.flags('--minify')+"                                 Minify compiled .js files");
+    console.log("   "+theme.flags('--sourcemap <inline|external|none>')+"     How should be sourcemap files be included in the .js");
+    console.log("   "+theme.flags('--platform <browser|node>')+"                Flag that will be passed to Imba compiler ('node' value does not work in Bun)");
+    console.log("");
+    console.log("The watch switch is applied in both scenarios (when running and when building Imba sources):");
+    console.log("   "+theme.flags('--watch')+"              Watch for changes in the entrypoint folder");
+    console.log("");
+    process.exit(1);
+}
+
+
+// no entrypoint
+if(!flags.entry) {
+    console.log("");
+    console.log("No entrypoint provided: "+theme.flags('bimba file.imba'));
+    console.log("For more information: "+theme.flags('--help'));
+    console.log("");
+    process.exit(1);
+}
+
+
+// build
+if(flags.outdir){
+    bundle();
+    watch(bundle);
+}
+else {
+    run();
+    watch(run);
+}
+
+function watch(callback) {
+    if (flags.watch) {
+        const watcher = fs.watch(path.dirname(flags.entry), {recursive: true}, async (event, filename) => ( callback() ));
+    
+        process.on("SIGINT", () => {
+            if(watcher) {
+                watcher.close();
+                process.exit(0);
+            }
+        });
+    }
+}
+
+async function run() {
+    await $`bun run ${path.resolve(flags.entry)}`;
+}
+
+
+async function bundle() {
+    if (!fs.existsSync(flags.entry)) {
+        console.log(theme.failure('Error.') + ` The specified entrypoint does not exist: ${theme.filedir(flags.entry)}`);
+        process.exit(1);
+    }
+
+    //if (!fs.existsSync(flags.bundle)){ fs.mkdirSync(flags.bundle);}
+
+    stats.failed = 0
+    stats.compiled = 0
+    stats.errors = 0
+    stats.bundled = 0
+
+    const start = Date.now();
+
+    console.log("──────────────────────────────────────────────────────────────────────");
+    console.log(theme.start(`Start building the Imba entrypoint: ${theme.filedir(flags.entry)}`));
+
+    const result = await Bun.build({
+        entrypoints: [flags.entry],
+        outdir: flags.outdir,
+        target: flags.target || 'browser',
+        sourcemap: flags.sourcemap || 'none',
+        minify: flags.minify || true,
+        plugins: [imbaPlugin]
+    });
+
+    if(stats.failed)
+        console.log(theme.start(theme.failure("Failure.") +` Imba compiler failed to proceed ${theme.count(stats.failed)} file${stats.failed > 1 ? 's' : ''}`));
+    else
+        console.log(theme.start(theme.success("Success.") +` It took ${theme.time(Date.now() - start)} ms to bundle ${theme.count(stats.bundled)} file${stats.bundled > 1 ? 's' : ''} to the folder: ${theme.filedir(flags.outdir)}`));
+
+    if(!result.success && !stats.errors){
+        for (const log of result.logs) {
+            console.log(log);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "bimba-cli",
+  "version": "0.1.1",
+  "repository": "github:HeapVoid/bimba",
+  "module": "index.ts",
+  "bin": {
+    "bimba": "./index.ts"
+  },
+  "description": "The CLI tool to run Imba projects under Bun",
+  "keywords": ["imba", "bun", "plugin"],
+  "license": "MIT",
+  "type": "module",
+  "devDependencies": {
+    "ansis": "^2.2.0",
+    "imba": "^2.0.0-alpha.234"
+  }
+}

package/plugin.ts

@@ -0,0 +1,217 @@
+import { plugin, type BunPlugin } from "bun";
+import ansis from 'ansis';
+import * as compiler from 'imba/compiler'
+import dir from 'path'
+import fs from 'fs'
+
+// theme for messages printed in terminal
+// color pallete can be seen here: https://raw.githubusercontent.com/webdiscus/ansis/master/docs/img/ansi256.png
+// for more details read the project page: https://github.com/webdiscus/ansis
+const theme = {
+  action: ansis.fg(237),
+  folder: ansis.fg(240),
+  filename: ansis.fg(15),
+  success: ansis.fg(40),
+  failure: ansis.fg(15).bg(124),
+};
+
+const cache = process.cwd() + '/.cache/';
+if (!fs.existsSync(cache)){ fs.mkdirSync(cache);}
+
+// this should be reset from outside to get results of entrypoint building
+export let stats = {
+  failed: 0,
+  compiled: 0,
+  cached: 0,
+  bundled: 0,
+  errors: 0
+};
+
+export const imbaPlugin: BunPlugin = {
+  name: "imba",
+  async setup(build) {
+
+      // when there is import without file extension
+      build.onResolve({filter: /^.*[^.]{5}$/ }, ({ path, importer }) => {
+      
+      let filename = path;
+      // resolve relative path
+      if (path.startsWith('.')) { filename = dir.resolve(dir.dirname(importer), filename) };
+
+      // assume that the file is .js
+      try { return {path: Bun.resolveSync(filename + '.js', '.')}}
+      catch (error) {
+        // assume that the file is .mjs
+        try { return {path: Bun.resolveSync(filename + '.mjs', '.')}}
+        catch (error) {
+          // assume that the file is .cs
+          try { return {path: Bun.resolveSync(filename + '.cjs', '.')}}
+          catch (error) {
+            // assume that the file is .imba
+            try { return {path: Bun.resolveSync(filename + '.imba', '.')}}
+            catch (error) {
+              // if direct resolution failed
+              filename += '.imba';
+              
+              // assume that the relative path should be resolved relative to importer
+              let fn = dir.resolve(dir.dirname(importer), filename);
+              if (fs.existsSync(fn)) return {path: fn};
+              // assume that the relative path should be resolved relative to node_modules
+              fn = dir.resolve('./node_modules', filename);
+              if (fs.existsSync(fn)) return {path: fn};
+              // assume that the relative path should be resolved relative to project root
+              fn = dir.resolve(process.cwd(), filename);
+              if (fs.existsSync(fn)) return {path: fn};
+              
+              // if the path still is unresolved throw error and leave the further resolution on Bun's resolver
+              if (error instanceof Error) {
+                throw new Error(error.message);
+              }
+              else
+                throw new Error('Could not resolve file: ' + path);
+            }
+          }
+        }
+      }
+    })
+
+    // when an .imba file is imported...
+    build.onLoad({ filter: /\.imba$/ }, async ({ path }) => {
+      
+      const f = dir.parse(path)
+      let contents = '';
+      
+      // return the cached version if it exists
+      const cached = cache + Bun.hash(path + fs.statSync(path).mtimeMs) + '_' + f.name + '.js';;
+      if (fs.existsSync(cached)) {
+        stats.bundled++;
+        stats.cached++;
+        //console.log(theme.action("cached: ") + theme.folder(f.dir + '/') + theme.filename(f.base) + " - " + theme.success("ok"));
+        return {
+          contents: await Bun.file(cached).text(),
+          loader: "js",
+        };
+      }
+
+      // if no cached version read and compile it with the imba compiler
+      const file = await Bun.file(path).text();
+      const out = compiler.compile(file, {
+        sourcePath: path,
+        platform: 'browser'
+      })
+      
+      // print about file complitaion
+      console.write(theme.action("compiling: ") + theme.folder(f.dir + '/') + theme.filename(f.base) + " - ");
+
+      // the file has been successfully compiled
+      if (!out.errors || !out.errors.length) {
+        stats.bundled++;
+        stats.compiled++;
+        contents = out.js;
+        await Bun.write(cached, contents);
+        console.write(theme.success("cached" + "\n"));
+      }
+      // there were errors during compilation
+      else {
+        console.write(theme.failure(" fail ") + "\n");
+        stats.failed++;
+        for (let i = 0; i < out.errors.length; i++) {
+          if(out.errors[i]) printerr(out.errors[i]);
+        }
+        stats.errors++;
+      }
+      
+      // and return the compiled source code as "js"
+      return {
+        contents,
+        loader: "js",
+      };
+    });
+  }
+};
+
+plugin(imbaPlugin);
+
+
+// -------------------------------------------------------------------------------
+// print pretty messages produced by the imba compiler 
+// -------------------------------------------------------------------------------
+
+type imbaCompilerError = {
+  toSnippet: Function;
+  toError: Function;
+  message: string;
+  range: {
+    start: {
+      line: number
+    }
+  }
+}
+
+// print an error generated by the imba compiler
+function printerr(err: imbaCompilerError) {
+  
+  // halper function to produce empty strings
+  const fill = (len = 0) => {return new Array(len + 1).join(' ')}
+  
+  // set color theme for an error message
+  const colors = {
+    code: ansis.fg(252).bg(238),
+    margin: ansis.fg(229).bg(145),
+    error: ansis.fg(196).bg(52),
+    ecode: ansis.fg(196).bg(238).bold,
+  };
+
+  // gather the needed information from the compiler error
+  const snippet = err.toSnippet().split("\n");
+  const display = {
+    error: " " + err.message + " ",
+    outdent: fill(10),
+    source: snippet[1] + "  ",
+    margin: " line " + err.range.start.line + " ",
+    errs: snippet[2].indexOf('^'),
+    erre: snippet[2].lastIndexOf('^') + 1,
+  };
+
+  // calculate parameters for priniting a message
+  const center = display.margin.length + display.errs + Math.floor((display.erre - display.errs) / 2);
+  const half = Math.ceil((display.error.length - 1) / 2);
+  const start = Math.max(0, center - half);
+  const end = start + display.error.length;
+  const total = Math.max(display.margin.length + display.source.length, end);
+
+  // print emtpy line
+  console.log('');
+
+  // print line with the error message
+  console.log(
+    display.outdent +
+    colors.margin(fill(Math.min(start, display.margin.length))) + 
+    colors.code(fill(Math.max(0, start - display.margin.length))) + 
+    colors.error(display.error) +
+    colors.margin(fill(Math.max(0, display.margin.length - end))) +
+    colors.code(fill(Math.min(total - display.margin.length, total - end)))
+  );
+
+  // print line with the source code
+  console.log(
+    display.outdent + 
+    colors.margin(display.margin) + 
+    colors.code(display.source.slice(0,display.errs)) + 
+    colors.error(display.source.slice(display.errs,display.erre)) + 
+    colors.code(display.source.slice(display.erre)) +
+    colors.code(fill(total - display.source.length - display.margin.length))
+  );
+
+  // print empty line to balance the view 
+  // later we can put something usefull here
+  // for example a link to online docs about the error
+  console.log(
+    display.outdent + 
+    colors.margin(fill(display.margin.length)) + 
+    colors.code(fill(total - display.margin.length))
+  );
+
+  // print emtpy line
+  console.log('');
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    /* Linting */
+    "skipLibCheck": true,
+    "strict": true,
+    "noFallthroughCasesInSwitch": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}