chocola 1.1.2 → 1.1.3

package/compiler/index.js

@@ -0,0 +1,197 @@
+import { throwError, genRandomId, incrementAlfabet } from "./utils.js";
+import { JSDOM } from "jsdom";
+import path from "path";
+import { promises as fs } from "fs";
+import { getComponents, getSrcIndex, processStylesheet } from "./pipeline.js";
+import chalk from 'chalk';
+import beautify from "js-beautify";
+import { getChocolaConfig } from "../utils.js";
+
+
+const logSeparation = chalk.yellow(`
+________________________________________________________________________
+========================================================================
+        `);
+
+/**
+ * Compiles a static build of your Chocola project from the directory provided.
+ * @param {import("fs").PathLike} __rootdir 
+ * @param {string} __srcdir 
+ */
+export default async function runtime(__rootdir) {
+    console.log(chalk.bold.hex("#945e33")(`\n                     RUNNING CHOCOLA BUNDLER`))
+    console.log(logSeparation);
+    console.log(chalk.hex("#945e33")(`
+
+
+     ▄████▄   ██░ ██  ▒█████   ▄████▄   ▒█████   ██▓    ▄▄▄      
+     ▒██▀ ▀█  ▓██░ ██▒▒██▒  ██▒▒██▀ ▀█  ▒██▒  ██▒▓██▒   ▒████▄    
+     ▒▓█    ▄ ▒██▀▀██░▒██░  ██▒▒▓█    ▄ ▒██░  ██▒▒██░   ▒██  ▀█▄  
+     ▒▓▓▄ ▄██▒░▓█ ░██ ▒██   ██░▒▓▓▄ ▄██▒▒██   ██░▒██░   ░██▄▄▄▄██ 
+     ▒ ▓███▀ ░░▓█▒░██▓░ ████▓▒░▒ ▓███▀ ░░ ████▓▒░░██████▒▓█   ▓██▒
+     ░ ░▒ ▒  ░ ▒ ░░▒░▒░ ▒░▒░▒░ ░ ░▒ ▒  ░░ ▒░▒░▒░ ░ ▒░▓  ░▒▒   ▓▒█░
+     ░  ▒    ▒ ░▒░ ░  ░ ▒ ▒░   ░  ▒     ░ ▒ ▒░ ░ ░ ▒  ░ ▒   ▒▒ ░
+     ░         ░  ░░ ░░ ░ ░ ▒  ░        ░ ░ ░ ▒    ░ ░    ░   ▒   
+     ░ ░       ░  ░  ░    ░ ░  ░ ░          ░ ░      ░  ░     ░  ░
+    ░                         ░                                  
+
+
+        `));
+    let __srcdir = "src";
+    let __outDir = "dist";
+    let __libDir = "lib";
+    let __emptyOutDir = true;
+
+    const config = await getChocolaConfig(__rootdir);
+    const bundleConfig = config.bundle;
+
+    if (bundleConfig.srcDir) { __srcdir = bundleConfig.srcDir }
+    else { console.warn(chalk.bold.yellow("WARNING!"), 'srcDir not defined in chocola.config.json file: using default "src" directory.') }
+
+    if (bundleConfig.outDir) { __outDir = bundleConfig.outDir }
+    else { console.warn(chalk.bold.yellow("WARNING!"), 'outDir not defined in chocola.config.json file: using default "dist" directory.') }
+
+    if (bundleConfig.libDir) { __libDir = bundleConfig.libDir }
+    else { console.warn(chalk.bold.yellow("WARNING!"), 'libDir not defined in chocola.config.json file: using default "lib" directory.') }
+
+    if (bundleConfig.emptyOutDir) {
+        __emptyOutDir = bundleConfig.emptyOutDir;
+        console.log(`> using emptyOutDir = ${__emptyOutDir}`);
+    } else {
+        console.log(`> using default emptyOutDir = ${__emptyOutDir}`);
+    }
+
+    console.log(logSeparation);
+
+    const outDirPath = path.join(__rootdir, __outDir);
+    const srcPath = path.join(__rootdir, __srcdir);
+    const srcComponents = path.join(srcPath, __libDir);
+
+    if (__emptyOutDir) {
+        await fs.rm(path.join(outDirPath), { recursive: true, force: true });
+        await fs.mkdir(path.join(outDirPath));
+    }
+
+    let indexFiles = await getSrcIndex(srcPath);
+    let srcHtmlFile = indexFiles.srcHtmlFile;
+    let srcChocoFile = indexFiles.srcChocoFile;
+
+    console.log(`       LOADING COMPONENTS`)
+
+    const foundComponents = await getComponents(srcComponents);
+
+    let loadedComponents = foundComponents.loadedComponents;
+    let notDefComps = foundComponents.notDefComps;
+
+    const srcDirData = {
+        index: srcHtmlFile || srcChocoFile,
+        components: foundComponents.componentsLib,
+    };
+
+    console.log(chalk.bold.green(">"), "Components found in", chalk.green.underline(srcComponents) + ":");
+    console.log("   ", srcDirData.components, "\n");
+
+    if (notDefComps.length > 0) {
+        console.warn(chalk.bold.yellow("WARNING!"), "The following components don't include a default export:");
+        console.log("   ", notDefComps);
+    }
+
+    console.log(logSeparation);
+    console.log(`       BUNDLING STATIC BUILD`);
+    console.log(chalk.bold.green(">"), "Creating Chocola static build in directory", chalk.green.underline(outDirPath) + "\n");
+    console.log(logSeparation);
+
+    const dom = new JSDOM(srcDirData.index);
+    const doc = dom.window.document;
+    const appContainer = doc.querySelector("app");
+
+    if (!appContainer) {
+        throwError("Index page must have an " + chalk.blue("<app>") + " element");
+    }
+
+    const appElements = Array.from(appContainer.children);
+
+    let runtimeChunks = [];
+    let runtimeScript = "";
+    let compIdColl = [];
+    let letter;
+
+    appElements.forEach(el => {
+        const tagName = el.tagName.toLowerCase();
+        const compName = tagName + ".js";
+
+        const ctx = {};
+        for (const attr of el.attributes) {
+            if (attr.name.startsWith("ctx.")) {
+                const key = attr.name.slice(4);
+                ctx[key] = attr.value;
+            }
+        }
+
+        const instance = loadedComponents.get(compName);
+        if (instance && instance.body) {
+            let body = instance.body;
+            body = body.replace(/\$\{ctx\.(\w+)\}/g, (_, key) => ctx[key] || "");
+            const fragment = JSDOM.fragment(body);
+            const firstChild = fragment.firstChild;
+            if (firstChild && firstChild.nodeType === 1) {
+                if (instance.script || instance.effects) {
+                    let script;
+                    let effects;
+                    const compId = "chid-" + genRandomId(compIdColl);
+                    firstChild.setAttribute("chid", compId);
+                    instance.script && (script = instance.script.toString())
+
+                    if (!letter) {
+                        letter = "a";
+                    } else {
+                        letter = incrementAlfabet(letter);
+                    }
+
+                    script = script.replace(/RUNTIME/g, `${letter}RUNTIME`);
+
+                    runtimeChunks.push(`
+const ${letter} = document.querySelector('[chid="${compId}"]');
+${script}
+${letter}RUNTIME(${letter}, ${JSON.stringify(ctx)});`);
+                }
+            }
+            el.replaceWith(fragment);
+        } else {
+            console.warn(chalk.yellow(`${compName} component could not be loaded`));
+        }
+    });
+
+    runtimeScript = runtimeChunks.join("\n");
+
+    let fileIds = [];
+
+    const docLinks = Array.from(doc.querySelectorAll("link"));
+
+    for (const link of docLinks) {
+        const rel = link.rel;
+        if (rel === "stylesheet") await processStylesheet(link, __rootdir, __srcdir, outDirPath, fileIds);
+    }
+
+
+    const runtimeFilename = "run-" + genRandomId(fileIds, 6) + ".js";
+    const runtimeFileContents = `document.addEventListener("DOMContentLoaded", () => {${runtimeScript}})`;
+    await fs.writeFile(path.join(outDirPath, runtimeFilename), runtimeFileContents);
+    const runtimeScriptEl = doc.createElement("script");
+    runtimeScriptEl.type = "module";
+    runtimeScriptEl.src = "./" + runtimeFilename;
+    doc.body.appendChild(runtimeScriptEl);
+    const finalHtml = dom.serialize();
+    const prettyHtml = beautify.html(finalHtml, { indent_size: 2 });
+
+    await fs.writeFile(path.join(outDirPath, "index.html"), prettyHtml);
+
+
+    console.log(`
+              ▄▄  ▄▄▄  ▄▄▄▄    ▄▄▄▄   ▄▄▄  ▄▄  ▄▄ ▄▄▄▄▄  ██ 
+              ██ ██▀██ ██▄██   ██▀██ ██▀██ ███▄██ ██▄▄   ██ 
+            ▄▄█▀ ▀███▀ ██▄█▀   ████▀ ▀███▀ ██ ▀██ ██▄▄▄  ▄▄ 
+                                                
+        `);
+    console.log(chalk.bold.green(">"), "Project bundled succesfully at", chalk.green.underline(outDirPath) + "\n\n");
+}

package/compiler/pipeline.js

@@ -0,0 +1,109 @@
+import { promises as fs } from "fs";
+import { loadWithAssets, throwError, genRandomId } from "./utils.js";
+import { readMyFile, checkFile } from "./fs.js";
+import path from "path";
+
+/**
+ * Returns a collection with the found components, the loaded ones (unpacked) and the undefined ones.
+ * @param {import("node:fs").PathLike} libDir 
+ * @returns {{
+ * componentsLib: PathLike[],
+ * loadedComponents: Object[],
+ * notDefComps: PathLike[]
+ * }}
+ */
+export async function getComponents(libDir) {
+    let componentsLib = [];
+    let loadedComponents = new Map();
+    let notDefComps = [];
+
+    const components = await fs.readdir(libDir);
+
+    for (const comp of components) {
+        if (!comp.endsWith(".js") || comp[0] !== comp[0].toUpperCase()) continue;
+
+        componentsLib.push(comp);
+
+        const module = await loadWithAssets(path.join(libDir, comp));
+
+        if (typeof module.default !== "function") {
+            notDefComps.push(comp);
+            continue;
+        }
+
+        const instance = module.default();
+
+        if (instance.bodyPath) {
+            instance.body = await fs.readFile(
+                path.resolve(libDir, instance.bodyPath),
+                "utf8"
+            );
+        }
+
+        loadedComponents.set(comp.toLowerCase(), instance);
+    }
+
+    return { componentsLib, loadedComponents, notDefComps };
+}
+
+/**
+ * Returns the Chocola project index HTML or .chocola file contents.
+ * If both HTML and .choco index file exist, it will throw an error.
+ * Note: It throws an error when using .choco files since it is not supported yet.
+ * @param {PathLike} srcPath 
+ * @returns {{
+ * srcHtmlFile: string | null,
+ * srcChocoFile: string | null
+ * }}
+ */
+export async function getSrcIndex(srcPath) {
+    const srcHtmlPath = path.join(srcPath, "index.html");
+    const srcChocoPath = path.join(srcPath, "index.choco");
+
+    const htmlExists = await checkFile(srcHtmlPath);
+    const chocoExists = await checkFile(srcChocoPath);
+
+    let srcHtmlFile = null;
+    let srcChocoFile = null;
+
+    if (htmlExists && chocoExists) {
+        throwError("Can't have both .choco and .html source index files at a time: please remove one of the two");
+    }
+
+    if (htmlExists) {
+        try {
+            srcHtmlFile = await readMyFile(srcHtmlPath);
+            return { srcHtmlFile: srcHtmlFile, srcChocoFile: srcChocoFile }
+        } catch (err) {
+            throwError(err);
+        }
+    }
+
+    if (chocoExists) {
+        throwError(".choco files are not supported yet")
+    }
+}
+
+/**
+ * Generates the new CSS files attached to the build index.html.
+ * @param {HTMLLinkElement} link 
+ * @param {PathLike} __rootdir 
+ * @param {PathLike} __srcdir 
+ * @param {PathLike} outDirPath 
+ * @param {Array} fileIds 
+ */
+export async function processStylesheet(link, __rootdir, __srcdir, outDirPath, fileIds) {
+    try {
+        const href = link.href;
+        const stylesheetPath = path.join(__rootdir, __srcdir, href);
+        const css = await fs.readFile(stylesheetPath, { encoding: "utf8" });
+        const cssFileName = "css-" + genRandomId(fileIds, 6) + ".css";
+
+        await fs.writeFile(path.join(outDirPath, cssFileName), css);
+
+        link.setAttribute("href", "./" + cssFileName);
+    } catch (err) {
+        throwError(err)
+    }
+}
+

package/compiler/utils.js

@@ -0,0 +1,66 @@
+import fs from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+import chalk from "chalk";
+
+export function throwError(err) {
+    console.log(chalk.red.bold("Error!"), "A fatal error has ocurred:\n");
+    throw new Error(err)
+}
+
+/**
+ * Returns the given module function adjusted to work with NPM without any dependency.
+ * @param {import("fs").PathLike} filePath 
+ * @returns {Function}
+ */
+export async function loadWithAssets(filePath) {
+    let code = await fs.readFile(filePath, "utf8");
+
+    const importRegex = /import\s+(\w+)\s+from\s+["'](.+?\.(html|css))["'];?/g;
+
+    let match;
+    while ((match = importRegex.exec(code))) {
+        const varName = match[1];
+        const relPath = match[2];
+
+        const absPath = path.resolve(path.dirname(filePath), relPath);
+        let content = await fs.readFile(absPath, "utf8");
+
+        const replacement = `const ${varName} = ${JSON.stringify(content)};`;
+
+        code = code.replace(match[0], replacement);
+    }
+
+    const dataUrl =
+        "data:text/javascript;base64," +
+        Buffer.from(code).toString("base64");
+
+    const mod = await import(dataUrl);
+    return mod;
+}
+
+export function genRandomId(compIdColl, length = 10) {
+    const id = Math.random().toString(36).substring(2, length + 2);
+    if (compIdColl.includes(id)) { return genRandomCompId() }
+    else {
+        compIdColl.push(id);
+        return id
+    }
+};
+
+export function incrementAlfabet(letters) {
+    const alfabet = "abcdefghijklmnopqrstuvwxyz";
+    let arr = letters.split("");
+    let i = arr.length - 1;
+    while (i >= 0) {
+        let pos = alfabet.indexOf(arr[i]);
+        if (pos < 25) {
+            arr[i] = alfabet[pos + 1];
+            return arr.join("");
+        } else {
+            arr[i] = "a";
+            i--;
+        }
+    }
+    return "a" + arr.join("");
+}

package/dev/index.js

@@ -0,0 +1,64 @@
+import http from "http";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import compile from "../compiler/index.js";
+import { getChocolaConfig } from "../utils.js";
+
+export async function serve(__rootdir) {
+  await compile(__rootdir);
+
+  let __outdir = "dist";
+  let __config = {
+    hostname: "127.0.0.1",
+    port: 3000,
+  }
+
+  const config = await getChocolaConfig(__rootdir);
+  const devConfig = config.dev;
+
+  if (devConfig.hostname) { __config.hostname = devConfig.hostname }
+  else { console.warn(chalk.bold.yellow("WARNING!"), `hostname not defined in chocola.config.json file: using default ${__config.hostname} hostname.`) }
+
+  if (devConfig.port) { __config.port = devConfig.port }
+  else { console.warn(chalk.bold.yellow("WARNING!"), `port not defined in chocola.config.json file: using default ${__config.port} port.`) }
+
+  const server = http.createServer((req, res) => {
+    let filePath = path.join(
+      __outdir,
+      req.url === "/" ? "index.html" : req.url
+    );
+
+    const extname = String(path.extname(filePath)).toLowerCase();
+    const mimeTypes = {
+      ".html": "text/html",
+      ".js": "text/javascript",
+      ".css": "text/css",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".jpg": "image/jpg",
+      ".gif": "image/gif",
+    };
+
+    const contentType = mimeTypes[extname] || "application/octet-stream";
+
+    fs.readFile(filePath, (error, content) => {
+      if (error) {
+        if (error.code === "ENOENT") {
+          res.writeHead(404, { "Content-Type": "text/html" });
+          res.end("<h1>404 Not Found</h1>", "utf-8");
+        } else {
+          res.writeHead(500);
+          res.end("Error interno: " + error.code);
+        }
+      } else {
+        res.writeHead(200, { "Content-Type": contentType });
+        res.end(content, "utf-8");
+      }
+    });
+  });
+
+  server.listen(__config.port, __config.hostname, () => {
+    console.log(`Chocola App running at http://${__config.hostname}:${__config.port}/`);
+  });
+}

package/index.js

@@ -1,3 +1,31 @@
-import runtime from "./runtime/index.js";
+import compile from "./compiler/index.js";
+import * as development from "./dev/index.js";
 
-export async function build(__rootdir, __srcdir) { runtime(__rootdir, __srcdir); }
+/**
+ * An intrinsic object that contains the Chocola App methods.
+ */
+export const app = {
+    /**
+     *  Initializes your Chocola App using a root directory and a source directory.
+     * 
+     * ```js
+     * import { app } from "chocola"
+     import path from "path";
+     import { fileURLToPath } from "url";
+     
+     const __filename = fileURLToPath(import.meta.url);
+     const __dirname = path.dirname(__filename);
+     
+     app.build(__dirname, "src");
+     ```
+     * @example
+     * @param {PathLike} __rootdir the directory where your Chocola App is
+     * @param {PathLike} __srcdir the directory where your app sources files are
+     * @returns {Object}
+     */
+    build(__rootdir, __srcdir) { compile(__rootdir, __srcdir) }
+}
+
+export const dev = {
+    server(__rootdir, __srcdir, port) { development.serve(__rootdir, __srcdir, port) }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chocola",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Chocola pipeline for web apps.",
   "keywords": [
     "web",

package/utils.js

@@ -0,0 +1,17 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { throwError } from "./compiler/utils.js";
+
+/**
+ * Returns `chocola.config.json` as an object.
+ * @param {import("fs").PathLike} __rootdir 
+ * @returns {Object}
+ */
+export async function getChocolaConfig(__rootdir) {
+    try {
+        const config = await fs.readFile(path.join(__rootdir, "chocola.config.json"), "utf-8");
+        return JSON.parse(config);
+    } catch(err) {
+        throwError("An error ocurred while fetching the Chocola config file:\n" + err);
+    }
+}

package/runtime/index.js

@@ -1,116 +0,0 @@
-import { throwError } from "./utils.js";
-import { JSDOM } from "jsdom";
-import path from "path";
-import { promises as fs } from "fs";
-import { getComponents, getSrcIndex } from "./pipeline.js";
-import chalk from 'chalk';
-import beautify from "js-beautify";
-
-
-const logSeparation = chalk.yellow(`
-________________________________________________________________________
-========================================================================
-        `)
-
-export default async function runtime(__rootdir, __srcdir) {
-    console.log(chalk.bold.hex("#945e33")(`\n                     RUNNING CHOCOLA BUNDLER`))
-    console.log(logSeparation);
-    console.log(chalk.hex("#945e33")(`
-
-
-     ▄████▄   ██░ ██  ▒█████   ▄████▄   ▒█████   ██▓    ▄▄▄      
-     ▒██▀ ▀█  ▓██░ ██▒▒██▒  ██▒▒██▀ ▀█  ▒██▒  ██▒▓██▒   ▒████▄    
-     ▒▓█    ▄ ▒██▀▀██░▒██░  ██▒▒▓█    ▄ ▒██░  ██▒▒██░   ▒██  ▀█▄  
-     ▒▓▓▄ ▄██▒░▓█ ░██ ▒██   ██░▒▓▓▄ ▄██▒▒██   ██░▒██░   ░██▄▄▄▄██ 
-     ▒ ▓███▀ ░░▓█▒░██▓░ ████▓▒░▒ ▓███▀ ░░ ████▓▒░░██████▒▓█   ▓██▒
-     ░ ░▒ ▒  ░ ▒ ░░▒░▒░ ▒░▒░▒░ ░ ░▒ ▒  ░░ ▒░▒░▒░ ░ ▒░▓  ░▒▒   ▓▒█░
-     ░  ▒    ▒ ░▒░ ░  ░ ▒ ▒░   ░  ▒     ░ ▒ ▒░ ░ ░ ▒  ░ ▒   ▒▒ ░
-     ░         ░  ░░ ░░ ░ ░ ▒  ░        ░ ░ ░ ▒    ░ ░    ░   ▒   
-     ░ ░       ░  ░  ░    ░ ░  ░ ░          ░ ░      ░  ░     ░  ░
-    ░                         ░                                  
-
-        `));
-    console.log(logSeparation);
-
-    const srcPath = path.join(__rootdir, __srcdir);
-    const srcComponents = path.join(srcPath, "lib")
-
-    let indexFiles = await getSrcIndex(srcPath);
-    let srcHtmlFile = indexFiles.srcHtmlFile;
-    let srcChocoFile = indexFiles.srcChocoFile;
-
-    const outDirPath = path.join(__rootdir, "dist");
-
-    console.log(`                                                                                                   
-     ▄▄▄▄  ▄▄▄  ▄▄   ▄▄ ▄▄▄▄   ▄▄▄  ▄▄  ▄▄ ▄▄▄▄▄ ▄▄  ▄▄ ▄▄▄▄▄▄ ▄▄▄▄ 
-    ██▀▀▀ ██▀██ ██▀▄▀██ ██▄█▀ ██▀██ ███▄██ ██▄▄  ███▄██   ██  ███▄▄ 
-    ▀████ ▀███▀ ██   ██ ██    ▀███▀ ██ ▀██ ██▄▄▄ ██ ▀██   ██  ▄▄██▀ 
-                                                                
-        `)
-
-    const foundComponents = await getComponents(srcComponents);
-
-    let loadedComponents = foundComponents.loadedComponents;
-    let notDefComps = foundComponents.notDefComps;
-
-    const srcDirData = {
-        index: srcHtmlFile || srcChocoFile,
-        components: foundComponents.componentsLib,
-    };
-
-    console.log(chalk.bold.green(">"), "Components found in", chalk.green.underline(srcComponents) + ":");
-    console.log("   ", srcDirData.components, "\n");
-
-    if (notDefComps.length > 0) {
-        console.warn(chalk.bold.yellow("WARNING!"), "The following components don't include a default export:");
-        console.log("   ", notDefComps);
-    }
-
-    console.log(logSeparation);
-
-    console.log(`                       
-               ▄▄▄▄  ▄▄ ▄▄ ▄▄ ▄▄    ▄▄▄▄  ▄▄ ▄▄  ▄▄  ▄▄▄▄ 
-               ██▄██ ██ ██ ██ ██    ██▀██ ██ ███▄██ ██ ▄▄ 
-               ██▄█▀ ▀███▀ ██ ██▄▄▄ ████▀ ██ ██ ▀██ ▀███▀ 
-                                           
-            `);
-    console.log(chalk.bold.green(">"), "Creating Chocola static build in directory", chalk.green.underline(outDirPath) + "\n");
-
-    console.log(logSeparation)
-
-    const dom = new JSDOM(srcDirData.index);
-    const doc = dom.window.document;
-    const appContainer = doc.querySelector("app");
-
-    if (!appContainer) {
-        throwError("Index page must have an " + chalk.blue("<app>") + " element");
-    }
-
-    const appElements = Array.from(appContainer.children);
-
-    appElements.forEach(el => {
-        const tagName = el.tagName.toLowerCase();
-        const compName = tagName + ".js";
-
-        const instance = loadedComponents.get(compName);
-        if (instance && instance.body) {
-            const fragment = JSDOM.fragment(instance.body);
-            el.replaceWith(fragment);
-        } else {
-            console.warn(chalk.yellow(`No se pudo renderizar ${compName}`));
-        }
-    });
-
-    const finalHtml = dom.serialize();
-    const prettyHtml = beautify.html(finalHtml, { indent_size: 2 });
-    await fs.writeFile(path.join(outDirPath, "index.html"), prettyHtml);
-
-
-    console.log(`
-              ▄▄  ▄▄▄  ▄▄▄▄    ▄▄▄▄   ▄▄▄  ▄▄  ▄▄ ▄▄▄▄▄  ██ 
-              ██ ██▀██ ██▄██   ██▀██ ██▀██ ███▄██ ██▄▄   ██ 
-            ▄▄█▀ ▀███▀ ██▄█▀   ████▀ ▀███▀ ██ ▀██ ██▄▄▄  ▄▄ 
-                                                
-        `);
-    console.log(chalk.bold.green(">"), "Project bundled succesfully at", chalk.green.underline(outDirPath) + "\n\n");
-}

package/runtime/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "@chocola/runtime",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "SadGabi",
-  "license": "ISC",
-  "type": "module"
-}

package/runtime/pipeline.js

@@ -1,67 +0,0 @@
-import { pathToFileURL } from "node:url";
-import { promises as fs } from "fs";
-import { throwError } from "./utils.js";
-import { readMyFile, checkFile } from "./fs.js";
-import path from "path";
-
-export async function getComponents(libDir) {
-    let componentsLib = [];
-    let loadedComponents = new Map();
-    let notDefComps = [];
-
-    try {
-        const components = await fs.readdir(libDir);
-
-        if (!components) {
-            throwError("Your src directory must have a `lib` folder for your components");
-        }
-
-        for (const comp of components) {
-            if (!comp.endsWith(".js") && comp[0] !== comp[0].toUpperCase()) continue;
-
-            componentsLib.push(comp);
-
-            const fileUrl = pathToFileURL(path.join(libDir, comp)).href;
-            const module = await import(fileUrl);
-
-            if (typeof module.default === "function") {
-                const instance = module.default();
-                loadedComponents.set(comp.toLowerCase(), instance);
-            } else {
-                notDefComps.push(comp)
-            }
-        }
-
-        return {componentsLib, loadedComponents, notDefComps};
-    } catch (err) {
-        throwError(err);
-    }
-}
-
-export async function getSrcIndex(srcPath) {
-    const srcHtmlPath = path.join(srcPath, "index.html");
-    const srcChocoPath = path.join(srcPath, "index.choco");
-
-    const htmlExists = await checkFile(srcHtmlPath);
-    const chocoExists = await checkFile(srcChocoPath);
-
-    let srcHtmlFile = null;
-    let srcChocoFile = null;
-
-    if (htmlExists && chocoExists) {
-        throwError("Can't have both .choco and .html source index files at a time: please remove one of the two");
-    }
-
-    if (htmlExists) {
-        try {
-            srcHtmlFile = await readMyFile(srcHtmlPath);
-            return {srcHtmlFile: srcHtmlFile, srcChocoFile: srcChocoFile}
-        } catch (err) {
-            throwError(err);
-        }
-    }
-
-    if (chocoExists) {
-        throwError(".choco files are not supported yet")
-    }
-}

package/runtime/utils.js

@@ -1,6 +0,0 @@
-import chalk from "chalk";
-
-export function throwError(err) {
-    console.log(chalk.red.bold("Error!"), "A fatal error has ocurred:\n");
-    throw new Error(err)
-}