vaderjs 1.4.2 → 1.4.3

package/main.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env bun
+
+import { Glob } from 'bun'
+const args = Bun.argv.slice(2)
+import fs from 'fs'
+import path from 'path' 
+ 
+if (!fs.existsSync(process.cwd() + '/app')) {
+    console.error(`App directory not found in ${process.cwd()}/app`)
+    process.exit(1)
+}
+if (!fs.existsSync(process.cwd() + '/public')) {
+    fs.mkdirSync(process.cwd() + '/public')
+} 
+const mode = args.includes('dev') ? 'development' :  args.includes('prod') ? 'production' : null
+if(!mode){
+    console.log(`
+    Usage:
+     bun vaderjs dev - Start development server output in dist/
+     bun vaderjs prod - Build for production  output in dist/
+    `)
+    process.exit(1)
+}
+
+let start = Date.now()
+console.log(`Starting build at ${new Date().toLocaleTimeString()}`) 
+let { port, host, } = require(process.cwd() + '/config').default
+
+if (!fs.existsSync(process.cwd() + '/jsconfig.json')) {
+    let json = {
+        "compilerOptions": {
+            "jsx": "react",
+            "jsxFactory": "e",
+        }
+    }
+    await Bun.write(process.cwd() + '/jsconfig.json', JSON.stringify(json, null, 4))
+}
+
+const bindes = []
+
+const handleReplacements = (code, file) => {
+    let lines = code.split('\n')
+    let newLines = []
+    for (let line of lines) {
+        let hasImport = line.includes('import')
+        if(hasImport && line.includes('.jsx')){
+            line = line.replace('.jsx', '.js')
+        }
+        if(hasImport && line.includes('.css')){ 
+             try {
+                let url = path.join('/' + line.split("'")[1])
+                let css = fs.readFileSync(process.cwd() + url, 'utf-8')
+                line = '';
+                if(!bindes.includes(`<link rel="stylesheet" href="${url}">`)) {
+                    bindes.push(`<link rel="stylesheet" href="${url}">`)
+                } 
+                fs.mkdirSync(process.cwd() + '/dist' + path.dirname(url), { recursive: true })
+                fs.writeFileSync(process.cwd() + '/dist' + url, css)
+             } catch (error) {
+                console.error(error)
+             }
+        } 
+        if (line.toLowerCase().includes('genkey()')) {
+            line = line.toLowerCase().replace('genkey()', `this.key = "${crypto.randomUUID()}"`)
+        }
+        if(!hasImport && line.includes('useFetch')){
+            line = line.replace('useFetch', 'this.useFetch')
+        }
+        if (!hasImport && line.includes('useState')) {
+            let key = line.split(',')[0].split('[')[1].replace(' ', '')
+            let b4 = line
+            b4 = line.replace('useState(', `this.useState('${key}',`)
+            line = b4
+        }
+        if(!hasImport && line.includes('useAsyncState')){
+            let key = line.split(',')[0].split('[')[1].replace(' ', '')
+            let b4 = line
+            b4 = line.replace('useAsyncState(', `this.useAsyncState('${key}',`)
+            line = b4
+        }
+        if (!hasImport && line.includes('useEffect')) {
+            let b4 = line
+            b4 = line.replace('useEffect(', `this.useEffect(`)
+            line = b4
+        }
+        if (!hasImport && line.includes('useRef')) {
+            let b4 = line
+            let key = line.split(' ')[1].split('=')[0]
+            b4 = line.replace('useRef(', `this.useRef('${key}',`)
+            line = b4
+        } 
+        newLines.push(line)
+    }
+    let c = newLines.join('\n')
+    return c
+} 
+ 
+
+async function generateApp() {
+   return new Promise(async (resolve, reject) => {
+    let routes = new Bun.FileSystemRouter({
+        dir: process.cwd() + '/app',
+        style: 'nextjs'
+    })
+    globalThis.routes = routes.routes
+    Object.keys(routes.routes).forEach(async (route) => { 
+        let r = routes.routes[route]
+        let code = await Bun.file(r).text()  
+        code = handleReplacements(code)
+        r = r.replace(process.cwd().replace(/\\/g, '/') + '/app', '')
+        r = r.replace('.jsx', '.js')
+        fs.mkdirSync(path.dirname(process.cwd() + '/dist/' + r), { recursive: true })
+        fs.writeFileSync(process.cwd() + '/dist/' + r, code)
+        fs.mkdirSync(process.cwd() + '/dev', { recursive: true })
+        fs.writeFileSync(path.join(process.cwd() + '/dev/bundler.js'), ` 
+          import { Component, e, useState, useEffect, useFetch, useAsyncState } from 'vaderjs'
+          import { document } from 'vaderjs/document'
+          import fs from 'fs'
+          let path2 = require('path')
+          globalThis.window = {
+            location: {
+                hash: '',
+                host: '',
+            }
+          }
+          globalThis.Component = Component
+          globalThis.e = e
+          globalThis.useState = useState
+          globalThis.genKey = () => {
+            return crypto.randomUUID()
+          };
+          globalThis.document = {
+            createElement: (tag) => {},
+            getElementById: (id) => {},
+          }
+          await Bun.build({
+            entrypoints: [process.cwd() + '/dist/' +  process.env.ENTRYPOINT],
+            minify:true,
+            root:  process.cwd() + '/dist',
+            outdir: process.cwd() + '/dist',
+        })  
+        let isClass = function(element) { 
+            return  element.toString().startsWith('class');
+        };
+        const generatePage = async (data = {path: process.env.INPUT, route: process.env.OUT}) => {
+            const { path, route } = data
+            if(path.includes('root.js')) return
+            let html = await import(path).then(m => m.default)
+            let { head } = await import(path).then(m => m)
+            let isFunction = false
+            globalThis.isServer = true 
+            if(isClass(html)){ 
+                html = new html() 
+                html.Mounted = true
+                html = html.render()
+            }else{
+                isFunction = true 
+                let instance = new Component()
+                html = html.bind(instance)
+                instance.render = html
+                html = instance.render()
+            }  
+  
+            let h  = document(html)  
+            if(!fs.existsSync(process.cwd() + '/dist' + path2.dirname(route))){
+                fs.mkdirSync(process.cwd() + '/dist' + path2.dirname(route), { recursive: true })
+            }
+            let headHtml = ''
+            if(head){ 
+                headHtml = document(head())
+            }
+            Bun.write(process.cwd() + '/dist/' + route + '/index.html', \`<!DOCTYPE html><head>\${headHtml}</head>\${h}
+            <script type="module"> 
+            import c from '\${route === '/' ? './index.js' : route + '/index.js'}'
+            import {render} from '/src/vader/index.js'
+            render(c, document.body.firstChild)
+            </script>
+            \`) 
+         } 
+         generatePage({path: process.env.INPUT, route: process.env.OUT})
+        `)
+       
+        fs.mkdirSync(process.cwd() + '/dist/src/vader', { recursive: true })
+        fs.writeFileSync(process.cwd() + '/dist/src/vader/index.js', await new Bun.Transpiler({
+            loader: 'ts',
+        }).transformSync(await Bun.file(require.resolve('vaderjs')).text()))  
+        const spawn = Bun.spawn({
+            cmd: ['bun', 'run', './dev/bundler.js'],
+            cwd: process.cwd(),
+            stdout: 'inherit',
+            env: {
+                ENTRYPOINT: r,
+                ROOT: process.cwd() + '/app/',
+                OUT: route,
+                INPUT:  `../app/${r.replace('.js', '.jsx')}`,
+            },
+            onExit({exitCode: code}) { 
+                if (code === 0) {
+                    console.log('Build complete')
+                    resolve()
+                } else {
+                    reject()
+                }
+            }
+        })  
+         
+    })
+    
+   })
+
+}
+
+generateApp()
+function handleFiles(){
+   return new Promise(async (resolve, reject) => {
+       try {
+        let glob = new Glob('public/**/*')
+        for await (var i of glob.scan()){
+            let file = i  
+            fs.mkdirSync(path.join(process.cwd() + '/dist', path.dirname(file)), { recursive: true })
+            fs.copyFileSync(file, path.join(process.cwd() + '/dist', file))
+        } 
+        resolve()
+       } catch (error) {
+              reject(error)
+       }
+   }) 
+}
+handleFiles()
+let  isBuilding = false;
+let timeout = null
+if(mode === 'development'){
+    const watcher = fs.watch(path.join(process.cwd() + '/app'), { recursive: true })
+    const publicWatcher = fs.watch(path.join(process.cwd() + '/public'), { recursive: true })
+    publicWatcher.on('change', async (event, filename) => {
+        try { 
+            await handleFiles() 
+            clients.forEach(c => {
+                c.send('reload')
+            })
+        } catch (error) {
+            console.error(error)
+        }
+    })
+    watcher.on('change', async (event, filename) => {
+        try {
+            await generateApp()
+            clients.forEach(c => {
+                c.send('reload')
+            })
+        } catch (error) {
+            console.error(error)
+        }
+       
+    })
+    watcher.on('error', (err) => {
+        console.error(err)
+    })
+}
+globalThis.clients = []
+
+if(mode === 'development'){
+    let server = Bun.serve({
+        port: port || 8080,
+        websocket: {
+            open(ws) {
+                globalThis.clients.push(ws)
+                ws.send('Connected')
+            },
+            message(ws, message) {
+                globalThis.clients.forEach(c => {
+                    c.send(message)
+                })
+            },
+            
+        },
+        async fetch(req, res) {
+            if(res.upgrade(req)){
+                return new Response('Upgraded', { status: 101 })
+            }
+           
+            let url = new URL(req.url) 
+            if(url.pathname.includes('.')){ 
+                let file = await Bun.file(path.join(process.cwd() + '/dist' + url.pathname)) 
+                if(!await file.exists()) return new Response('Not found', { status: 404 })
+                return new Response(await file.text(), {
+                    headers: {
+                        'Content-Type':  file.type
+                    }
+                })
+            } 
+            return new Response(fs.readFileSync(process.cwd() + '/dist/' + url.pathname + '/index.html')  + `
+            <script>
+            let ws = new WebSocket('ws://localhost:${server.port}')
+            ws.onmessage = (e) => {
+                if(e.data === 'reload'){
+                    window.location.reload()
+                }
+                console.log(e.data)
+            } 
+            </script>
+            `, {
+                headers: {
+                    'Content-Type': 'text/html'
+                }
+            }) 
+        }
+    })
+    
+    console.log(`Server running on http://localhost:${server.port}`)
+}else{
+    console.log(`Build complete in ${Date.now() - start}ms at ${new Date().toLocaleTimeString()}`)
+    process.exit(0)
+}

package/package.json

@@ -1,25 +1,9 @@
-{
-  "name": "vaderjs",
-  "description": "A reactive framework for building fast and scalable web applications",
-  "version": "1.4.2",
-  "main": "vader.js",
-  "author": {
-    "name": "Malikwhitten67",
-    "email": "malikwhitterb@gmail.com"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Postr-Inc/Vader.js"
-  },
-  "type": "module",
-  "bin":{
-    "vader":"./vader.js"
-  },
-  "dependencies": {
-    "ws": "latest"
-  },
-  "devDependencies": { 
-    "ws": "latest"
-  }
+{
+    "name": "vaderjs",
+    "version": "1.4.3",
+    "description": "A simple and powerful JavaScript library for building modern web applications.",
+    "main":"./main.js",
+    "bin": {
+        "vaderjs": "./main.js"
+    }
 }

package/.editorconfig

@@ -1,11 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 4
-insert_final_newline = true
-end_of_line = lf
-
-[*.{js,ts}]
-trim_trailing_whitespace = true

package/.vscode/c_cpp_properties.json

@@ -1,21 +0,0 @@
-{
-    "configurations": [
-        {
-            "name": "Win32",
-            "includePath": [
-                "${workspaceFolder}/**"
-            ],
-            "defines": [
-                "_DEBUG",
-                "UNICODE",
-                "_UNICODE"
-            ],
-            "windowsSdkVersion": "10.0.22621.0",
-            "compilerPath": "cl.exe",
-            "cStandard": "c17",
-            "cppStandard": "c++17",
-            "intelliSenseMode": "windows-msvc-x64"
-        }
-    ],
-    "version": 4
-}

package/.vscode/settings.json

@@ -1,12 +0,0 @@
-{
-    "files.associations": {
-        "stdlib.h": "c",
-        "stdio.h": "c",
-        "fstream": "cpp",
-        "istream": "cpp",
-        "xstring": "cpp",
-        "ostream": "cpp",
-        "system_error": "cpp",
-        "xlocale": "cpp"
-    }
-}