vaderjs 1.4.1-lv56aadeg5 → 1.4.2-bml56

package/vader_dev.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+import { exec } from "child_process";
+import fs from "fs";
+globalThis.currentCommand = null;
+globalThis.isRunning = false;
+let vaderisInstalled = process.cwd() + "/node_modules/vaderjs/binaries/vader.js";
+if (!fs.existsSync(process.cwd() + "/_dev")) {
+  fs.mkdirSync(process.cwd() + "/_dev");
+  !fs.existsSync(process.cwd() + "/_dev/readme.md") && fs.writeFileSync(process.cwd() + "/_dev/readme.md", `This folder is used by vader.js to store important files, deletables include: Bun, Chrome - These should only be uninstalled if you need to reinstall them.`);
+}
+
+if (!fs.existsSync(process.cwd() + "/_dev/vader.js")) {
+  console.log("Copying vader to dev folder....");
+  fs.copyFileSync(vaderisInstalled, process.cwd() + "/_dev/vader.js");
+}
+
+function checkIFBundleIsInstalled() {
+  if (fs.existsSync(process.cwd() + "/_dev/bun")) {
+    return new Promise((resolve, reject) => {
+      resolve(true);
+    });
+  }
+  return new Promise((resolve, reject) => {
+    exec("bun -v", (err, stdout, stderr) => { 
+      if (err) {
+        reject(err);
+      }
+      if (stdout) {
+        resolve(`Bun.js is installed: ${stdout}`);
+      }
+      if (stderr) {
+        reject(`Bun.js is not installed: ${stderr}`);
+      }
+    });
+  });
+}
+
+function run() {
+  if(!fs.existsSync(process.cwd() + "/pages")) {
+    fs.mkdirSync(process.cwd() + "/pages");
+  }
+  if(!fs.existsSync(process.cwd() + "/public")) {
+    fs.mkdirSync(process.cwd() + "/public");
+  } 
+  if(!fs.existsSync(process.cwd() + "/src")) {
+    fs.mkdirSync(process.cwd() + "/src");
+  }
+  if (!fs.existsSync(process.cwd() + "/package.json")) {
+    fs.writeFileSync(process.cwd() + "/package.json", JSON.stringify({ name: "my_app", version: "1.0.0" }, null, 2));
+    return;
+  }
+  let packageJson = JSON.parse(fs.readFileSync(process.cwd() + "/package.json").toString());
+  if (!packageJson.scripts) {
+    packageJson.scripts = {};
+  }
+  packageJson.scripts["dev"] = "bun run ./_dev/vader.js dev";
+  packageJson.scripts["build"] = "bun run ./_dev/vader.js build";
+  packageJson.scripts["start"] = "bun run ./_dev/vader.js start";
+  if (!packageJson.dependencies) {
+    packageJson.dependencies = {};
+  }
+  fs.writeFileSync(process.cwd() + "/package.json", JSON.stringify(packageJson, null, 2));
+
+  if (currentCommand) {
+    let child = exec(currentCommand);
+    child.stdout.pipe(process.stdout);
+    child.stderr.pipe(process.stderr);
+    child.on("exit", (code) => {
+      process.exit(code);
+    });
+    child.on("message", (message) => {
+      console.log(message.toString());
+    });
+    child.on("error", (err) => {
+      console.error(err);
+    });
+
+    return;
+  }
+
+  console.log(` 
+  Vader.js is a reactive framework for building interactive applications for the web built ontop of bun.js!
+            
+  Usage: npx vaderjs <command> 
+            
+   Commands:
+        
+   vaderjs run dev  -p <number>    Start the development server
+            
+   vaderjs run build   Build the project to ./dist
+            
+   vaderjs run start  -p <number>  Production Mode (default 3000 or process.env.PORT)
+              
+   Learn more about vader:      https://vader-js.pages.dev/
+                
+   `);
+}
+ 
+let Commands = {
+  dev: `bun run dev`,
+  build: `bun run build`,
+  start: `bun run start`,
+};
+let port = process.argv.includes("-p") || process.argv.includes("--port") ? process.argv[process.argv.indexOf("-p") + 1] || process.argv[process.argv.indexOf("--port") + 1] || process.env.PORT || 3000 : process.env.PORT || 3000;
+switch (true) {
+  case process.argv.includes("dev") && !process.argv.includes("build") && !process.argv.includes("start"):
+    currentCommand = Commands.dev + (port ? ` -p ${port}` : "");
+    break;
+  case process.argv.includes("build") && !process.argv.includes("dev") && !process.argv.includes("start"):
+    currentCommand = Commands.build + (port ? ` -p ${port}` : "");
+    break;
+  case process.argv.includes("start") && !process.argv.includes("dev") && !process.argv.includes("build"):
+    currentCommand = Commands.start + (port ? ` -p ${port}` : "");
+    break;
+  default:
+    currentCommand = null;
+    break;
+}
+checkIFBundleIsInstalled()
+.then((stdout) => {
+  if (stdout && !isRunning) {
+    if (!fs.existsSync(process.cwd() + "/_dev/bun")) {
+      fs.writeFileSync(process.cwd() + "/_dev/bun", `Installed: ${stdout}`);
+    }
+    run();
+    globalThis.isRunning = true;
+  }
+})
+.catch(async (err) => {
+  console.log("Bun.js is not installed. Installing....");
+  let installScipt = {
+    windows: 'powershell -c "irm bun.sh/install.ps1|iex',
+    others: "curl -fsSL https://bun.sh/install.sh | bash",
+  };
+  let scriptotRun = process.platform === "win32" ? installScipt.windows : installScipt.others;
+  exec(scriptotRun, async (err, stdout, stderr) => {
+    if (err) {
+      console.log("Error installing bun.js, may want to install manually");
+      process.exit(1);
+    }
+    if (stdout) {
+      if (!process.platform === "win32") {
+        await new Promise((resolve, reject) => {
+          console.log(`Adding bun.js to path...`); 
+          exec("source ~/.bashrc", (err, stdout, stderr) => {
+            if (err) {
+              console.log("Error installing bun.js");
+              return;
+            }
+            if (stdout) {
+              run();
+            }
+            if (stderr) {
+              console.log("Error installing bun.js");
+              process.exit(1);
+            }
+          });
+        });
+        exec("chmod +x bun.sh/install.sh", (err, stdout, stderr) => {
+          if (err) {
+            console.log("Error installing bun.js");
+            return;
+          }
+          if (stdout) {
+            console.log("Bun.js installed successfully");
+            run();
+          }
+          if (stderr) {
+            console.log("Error installing bun.js");
+            process.exit(1);
+          }
+        });
+      }
+      run();
+    }
+  });
+});

package/@integrations/ssg.js

@@ -1,163 +0,0 @@
-import fs from 'fs';
-import playwright from 'playwright';
-globalThis.routeDocuments = {}
-let context = process.env.isVader === 'true' ? true : false
-/**
- * 
- * @param {Object} config 
- * @param {string} config.pages - The directory where the pages are located
- * @param {string} config.output - The directory where the pages are to be outputted
- */
-
-
-import http from 'http';
-let hasGenerated = []
-let server = http.createServer((req, res) => {
-  if (!req.url.includes(".")) {
-    let params = new URLSearchParams(req.url.split("?")[1]);
-    let folder = params.get("folder");
-
-    let content = globalThis.routeDocuments[folder]
-    res.writeHead(200, { "Content-Type": "text/html" });
-
-    res.end(content);
-  } else {
-    if (req.url.includes('./')) {
-      req.url = req.url.replace('./', '/')
-    }
-    const filePath = process.cwd() + "/dist/" + req.url;
-
-    fs.readFile(filePath, (err, data) => {
-      if (err) {
-        res.writeHead(404, {
-          "Content-Type": filePath.includes("js")
-            ? "text/javascript"
-            : "text/html",
-        });
-        res.end("File not found");
-      } else {
-        res.writeHead(200, {
-          "Content-Type": filePath.includes("js")
-            ? "text/javascript"
-            : "text/html",
-        });
-        res.end(data);
-      }
-    });
-  }
-});
-
-const generateHTML = (routeData) => {
-  console
-   
-  let { path, file, isParam, params,kind, isCatchAll, query, pathname } = routeData;
-  console.log(path, file, isParam, isCatchAll, query, pathname)
-  let baseFolder =  file.split('/').filter(f => f !== 'dist').join('/')
-  if (file.includes('./dist')) {
-    baseFolder = file.split('./dist')[1]
-  }
- 
-
-  let html = `
-<!DOCTYPE html>
-  <html>
-   <head> 
-   
-<title>Vaderjs v1.3.3</title> 
-<script id="v">
-   window.$SERVER = true
-   </script>
-</head>
-   <body>
-    
-   <div id="app"></div>
-   <script id="router" type="module">
-    import Router from '/router.js' 
-    
-    const rt = new Router
-    ${Object.keys(routeData.params).length > 0 ? Object.keys(routeData.params).map((param, i) => {
-    return `rt.get('/${pathname}/:${param}', ' ${baseFolder}')`
-    }): ''}
-
-    let c = await import('${baseFolder}')  
-    if(Object.keys(c).includes('$prerender') && c.$prerender === false){
-      document.head.setAttribute('prerender', 'false')
-    }
-    ${
-      !isCatchAll ? `rt.get($SERVER? '/' : '${pathname}', c)` :  `rt.get($SERVER? '/' : '${pathname}/*', c)`
-    }
-     
-    rt.listen()
-   </script>
-   </body>
-  </html>`
-  return html;
-
-}
-/**
- * @integration Server Side Generator
- * @description Generate a static webapp from your Vader.js application
- * @returns 
- */
-const ssg = async (config) => {
-  return new Promise(async (resolve, reject) => {
-    let { pages, output } = config;
-    if(!fs.existsSync(`${process.cwd()}/_dev/meta/routes.json`)){
-      process.exit()
-    }
-    let routes = JSON.parse(fs.readFileSync(`${process.cwd()}/_dev/meta/routes.json`).toString())
-    for (var i in routes) {
-      let route = routes[i];
-       
-      if(route.path.includes('[')){
-         continue
-      }
-      let html = generateHTML(route);
-      globalThis.routeDocuments[routes[i].path] = html;
-      let browser = await playwright.chromium.launch({
-        headless: true,
-        executablePath: process.platform === 'win32' ? '' : '/usr/bin/chromium-browser'
-      });
-      globalThis.browser = browser;
-      let page = await browser.newPage();
-      await page.goto(`http://localhost:8700?folder=${routes[i].path}`);
-      await page.evaluate(() => {
-        document.querySelector('script#v').innerHTML = `window.$SERVER = false`
-        if(document.head.getAttribute('prerender') === 'false'){
-          document.querySelector("#app").innerHTML = "";
-        }
-      });
-      let content = await page.content(); 
-      if (output.includes('./dist')) {
-        output = output.split('./dist')[1]
-      }
-      let path = '/dist/' + output  + routes[i].path + '/index.html';
-      fs.writeFileSync(process.cwd() + path, content)
-      hasGenerated.push(routes[i].path)
-    }
-
-    if (hasGenerated.length === routes.length) {
-      console.log(`Static site generation complete`)
-      browser.close()
-      server.close()
-      resolve() 
-      process.exit()
-    }
-  })
-} 
-
-if(context){
-server.listen(8700);
-await ssg({ pages: './pages', output: './dist' })
-}
-
-export default {
-  name: 'Vaderjs Static Site Generator',
-  version: '1.0.0',
-  useRuntime: 'node',
-  entryPoint: process.cwd() + '/node_modules/vaderjs/@integrations/ssg.js',
-  on: ['build', 'dev'],
-}
-
-
-// Path:integrations/ssg.js

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Pascal
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/binaries/IPC/index.js

@@ -1,277 +0,0 @@
-import { WebSocketServer } from "ws";
-import WebSocket from "ws";
-/**
- * @class IPC
- * @description Inter-Process Communication - allows you to communicate with vaderjs using Bun.js
- */
-class IPC {
-  constructor(config = { port: 3434 }) {
-    this.server = {
-      port: config.port,
-      /**
-       * @property {IPC} instance - The instance of the IPC server
-       */
-      instance: null,
-      clients: [],
-      /**
-       *
-       * @private
-       */
-      sendMsg: (msg) => {
-        this.server.clients.forEach((client) => {
-          client.send(JSON.stringify({ IPC_TYPE: this.type, msg }));
-        });
-      },
-    };
-    /**
-     * @enum {Object} typeEnums - The type of process to spawn
-     */
-    this.typeEnums = {
-      /**
-       * @enum {Number} WATCHER - The file watching process
-       */
-      WATCHER: 1,
-      /**
-       * @enum {Number} PAGEGENERATOR - The page generator process
-       */
-      PAGEGENERATOR: 2,
-      /**
-       * @enum {Number} DFT - The default process
-       */
-      DFT: 3,
-    };
-
-    this.listeners = [];
-    this.type = this.typeEnums.DFT;
-  }
-  /**
-   * @property {Boolean} NOLISTEN - Whether to listen for incoming messages or not
-   */
-  NOLISTEN = false;
-  /**
-   * @Object Console
-   * @description The console object to use for logging - Bun.spawn has 0 way of reading logs from the spawned process so this is a workaround
-   */
-  Console = {
-    log: (msg, IPC_TYPE) => {
-      this.server.clients.forEach((client) => {
-        client.send(JSON.stringify({ IPC_TYPE: PROTOCOL, CONSOLE: true, LOG: true, msg }));
-      });
-    },
-    error: (msg, errorLevel, IPC_TYPE) => {
-      this.server.clients.forEach((client) => {
-        client.send(JSON.stringify({ IPC_TYPE: PROTOCOL, CONSOLE: true, ERROR: true, errorLevel, msg }));
-      });
-    },
-    warn: (msg, IPC_TYPE) => {
-      this.server.clients.forEach((client) => {
-        client.send(JSON.stringify({ IPC_TYPE: PROTOCOL, CONSOLE: true, WARN: true, msg }));
-      });
-    },
-    info: (msg, IPC_TYPE) => {
-      this.server.clients.forEach((client) => {
-        client.send(JSON.stringify({ IPC_TYPE: PROTOCOL, CONSOLE: true, INFO: true, msg }));
-      });
-    },
-    debug: (msg, IPC_TYPE) => {
-      this.server.clients.forEach((client) => {
-        client.send(JSON.stringify({ IPC_TYPE: PROTOCOl, CONSOLE: true, DEBUG: true, msg }));
-      });
-    },
-  };
-
-  spawnServer(type = this.typeEnums.DFT) {
-    this.isntSpawned = false;
-    if (!this.server.instance) {
-      // if used in achildProcess reconnect to the main running server
-      this.server.instance = new WebSocketServer({ port: this.server.port });
-    } else {
-      // switch type
-      this.server.instance.clients.forEach((client) => {
-        client.send(JSON.stringify({ PROTO_CHANGE: true, IPC_TYPE: type }));
-      });
-    }
-
-    this.server.instance.on("connection", (ws) => {
-      this.server.clients.push(ws);
-
-      this.server.instance.clients.forEach((client) => {
-        client.send(JSON.stringify({ ESTABLISHED: true, IPC_TYPE: type }));
-      });
-      ws.on("message", (msg) => {
-        msg = JSON.parse(msg);
-        if (msg.CLIENTINIT) {
-          let port = msg.port;
-          ws.send(JSON.stringify({ ESTABLISHED: true, IPC_TYPE: type }));
-          return;
-        } else if (msg.SERVERINIT) {
-          ws.send(JSON.stringify({ ESTABLISHED: true, IPC_TYPE: type }));
-          return;
-        }
-
-        this.server.clients.forEach((client) => {
-          client.send(JSON.stringify(msg));
-        });
-      });
-    });
-
-    this.server.instance.on("close", () => {
-      this.server.clients = [];
-    });
-
-    // spawn if nolisten is false
-    this.isntSpawned = true;
-  }
-
-  /**
-   * @method newServer
-   * @description Creates a new IPC server instance
-   * @param {IPC.typeEnums} proto
-   * @param {Object} config
-   * @returns
-   */
-  async newServer(proto = 0, config = { port: 3434 }) {
-    const client = new WebSocket(`ws://localhost:${config.port}`);
-
-    client.on("open", () => {
-      client.send(JSON.stringify({ SERVERINIT: true, IPC_TYPE: proto }));
-    });
-    client.on("message", (msg) => {
-      if (msg.ESTABLISHED && msg.IPC_TYPE === proto) {
-        config?.onMessage(msg);
-      }
-    });
-    let port = config.port;
-
-    const sendMsg = (msg) => {
-      if (!client.readyState) {
-        let i = setInterval(() => {
-          if (client.readyState) {
-            client.send(JSON.stringify({ IPC_TYPE: proto, msg, port, isServer: true }));
-            clearInterval(i);
-          }
-        }, 1000);
-        return;
-      }
-      client.send(JSON.stringify({ IPC_TYPE: proto, msg, port, isServer: true }));
-    };
-
-    sendMsg({ ESTABLISHED: true, IPC_TYPE: proto, port });
-    return {
-      sendMsg: (msg) => {
-        sendMsg(msg);
-      },
-      /**
-       * @method Console
-       * @description The console object to use for logging - Bun.spawn has 0 way of reading logs from the spawned process so this is a workaround
-       */
-      Console: {
-        log: (msg) => {
-          sendMsg({ CONSOLE: true, data: msg });
-        },
-        error: (msg, errorLevel) => {
-          sendMsg({ CONSOLE: true, ERROR: true, errorLevel, msg });
-        },
-        warn: (msg) => {
-          sendMsg({ CONSOLE: true, WARN: true, msg });
-        },
-        info: (msg) => {
-          sendMsg({ CONSOLE: true, INFO: true, msg });
-        },
-      },
-      listen: (callback) => {
-        client.on("message", (msg) => {
-          callback(msg);
-        });
-      },
-      onError: (callback) => {
-        client.on("error", (err) => {
-          callback(err);
-        });
-      },
-    };
-  }
-
-  listen(callback) {
-    this.server.instance.on("message", (msg) => {
-      callback(msg);
-    });
-  }
-
-  client(config = { use: this.typeEnums.DFT, port: 0, callback: () => {} }) {
-    if (!this.server.instance) {
-      this.spawnServer();
-    }
-    const ws = new WebSocket(`ws://localhost:${config.port}`);
-    ws.on("open", () => {
-      console.log(config);
-    });
-    ws.send(JSON.stringify({ CLIENTINIT: true, IPC_TYPE: config.use, port: config.port }));
-
-    function listen(callback) {
-      ws.on("message", (msg) => {
-        callback(msg);
-      });
-    }
-    return {
-      Console: {
-        read: (callback) => {
-          listen((msg) => {
-            msg = JSON.parse(msg.toString());
-            if (msg.isServer && msg.IPC_TYPE === config.use && msg.port === config.port && msg?.msg?.CONSOLE) {
-              callback(msg);
-            }
-          });
-        },
-        write: (msg) => {
-          ws.send(JSON.stringify({ CONSOLE_LOG: true, msg }));
-        },
-      },
-      sendMsg: (msg) => {
-        ws.send(JSON.stringify({ IPC_TYPE: config.use, msg }));
-      },
-      listen: (callback) => {
-        ws.on("message", (msg) => {
-          callback(msg);
-        });
-      },
-      close: () => {
-        ws.close();
-      },
-      onError: (callback) => {
-        ws.on("error", (err) => {
-          callback(err);
-        });
-      },
-    };
-  }
-
-  sendMsg(batch, callback) {
-    switch (true) {
-      case Array.isArray(batch):
-        console.log(`Using incremental sending`);
-        let timeBetween = 1000;
-        batch.forEach((msg, i) => {
-          setTimeout(() => {
-            this.server.sendMsg(msg);
-          }, i * timeBetween);
-        });
-        break;
-      case typeof batch === "string":
-        this.server.sendMsg(batch);
-        break;
-      default:
-        this.server.sendMsg(batch.toString());
-        break;
-    }
-  }
-}
-
-/**
- * @module IPCServer
- * @description The IPC server instance
- 
- */
-let IPCServer = new IPC({ port: 3434 });
-
-export default IPCServer;