@slim-lang/core 1.2.0

package/packages/slim/server/main.slim

@@ -0,0 +1,423 @@
+use http from "http"
+use * as fs from "fs"
+use * as nodePath from "path"
+import process from 'node:process';
+
+export type ServerInstance = typeof Server;
+
+export struct RedirectRoute {
+    from: string
+    to: string
+}
+
+export struct StaticRoute {
+    from: string
+    to: string
+}
+
+export struct SlimServerConf {
+    port: int = 3000
+    dev: bool = false
+    redirects: object[] = [{}]
+    statics: object[] = [{}]
+}
+
+class Server {
+    constructor(port: int = 3000) {
+        this.port = port;
+        this.routes = [];
+        this.apiRoutes = {};
+        this.clients = [];
+        this.staticDirs = [];
+        this.dev = false;
+
+        this.#loadConfig();
+    }
+
+    #loadConfig() {
+        let configDir = process.cwd();
+        let raw: object = {};
+
+        try {
+            const slimConf = JSON.parse(fs.readFileSync(nodePath.join(process.cwd(), "slimconfig.json"), "utf8"));
+            if (slimConf.main) configDir = nodePath.dirname(nodePath.resolve(slimConf.main));
+        } catch (e) {}
+
+        try {
+            raw = JSON.parse(fs.readFileSync(nodePath.join(configDir, "slimserver.json"), "utf8"));
+        } catch (e) {}
+
+        const conf = SlimServerConf.new(raw);
+
+        this.port = conf.port;
+        this.dev = conf.dev || process.env.SLIM_DEV === "1";
+
+        this.redirect(conf.redirects);
+
+        const statics = conf.statics.map(entry => {
+            if (empty entry) return entry;
+            return { from: entry.from, to: nodePath.resolve(configDir, entry.to) };
+        });
+
+        this.static(statics);
+    }
+
+	page(path: string, render: function, options?: object) {
+		let additionalScript = ""
+		let scriptId = 0;
+
+		func renderTag(content: string[]) {
+			const tags: object = {
+				"css": {
+					tag: "link",
+					attr: "href",
+					additionalAttrs: {
+						rel: "stylesheet"
+					}
+				},
+				"js": {
+					tag: "script",
+					attr: "src"
+				},
+			}
+
+			content.forEach(c => {
+			    const ext = c.split(".").pop();
+
+			    if (ext in tags) {
+			     	const tag = tags[ext].tag;
+				    const attr = tags[ext].attr;
+					const varName = `${tag}_${scriptId++}`;
+					let additional = ""
+
+					if ("additionalAttrs" in tags[ext]) {
+						const additionalAttrs = tags[ext].additionalAttrs
+
+						Object.keys(additionalAttrs).forEach(e => {
+							additional += `${varName}.${e} = "${additionalAttrs[e]}"`
+						})
+					}
+
+				    additionalScript += `
+			       		const ${varName} = document.createElement("${tag}");
+						${varName}.${attr} = ${JSON.stringify(c)};
+						${additional}
+			        	document.head.appendChild(${varName});
+					`;
+			    }
+			});
+		}
+
+        if(options) {
+            if ("head" in options) {
+                const headLinks: string[] = options.head
+
+                renderTag(headLinks)
+            }
+            if ("title" in options) {
+                const title: string = options.title
+
+                additionalScript += `document.title = "${title}";`
+            }
+            if ("icon" in options) {
+                const icon: string = options.icon
+
+                additionalScript += `
+                    link = document.createElement("link");
+                    link.rel = "icon";
+                    link.href = "${icon}";
+                    document.head.appendChild(link);
+                `
+            }
+            if ("onload" in options) {
+                const onload: function = options.onload
+
+                additionalScript += `
+                    const __onload = ${String(onload)};__onload({ port: ${this.port}});
+                `
+            }
+        }
+
+        this.get(path, async (req, res, params) => {
+            const isDev = this.dev
+			let html = render({ dev: isDev, params });
+			const eventsScript = __flush_events__();
+
+            if(kindof html == "promise") {
+                html = await html
+            }
+
+            if(kindof html == "object") {
+                res.writeHead(200, {
+                    "Content-Type": "text/json; charset=utf-8",
+                    "Cache-Control": "no-store"
+                });
+                res.end(JSON.stringify(html))
+
+                return
+            }
+
+			html += `<script>`
+
+			html += additionalScript
+
+            if (isDev) {
+                html += `
+                    (function () {
+                        let connectedBefore = false;
+
+                        const es = new EventSource("/__slim_reload__");
+
+                        es.onopen = () => {
+                            if (connectedBefore) {
+                                location.reload();
+                                return;
+                            }
+                            connectedBefore = true;
+                        };
+                    })();`;
+			}
+
+            html += `</script>`
+
+            if (eventsScript) {
+                html += `<script>${eventsScript}</script>`
+            }
+
+            res.writeHead(200, {
+                "Content-Type": "text/html; charset=utf-8",
+                "Cache-Control": "no-store"
+            });
+
+            res.end(html);
+        });
+    }
+
+    get(path: string, callback: function) {
+        const compiled = this.compileRoute(path);
+        this.routes.push({ regex: compiled.regex, keys: compiled.keys, callback });
+    }
+
+    escapeRegex(str: string) {
+        const specials = ".^$*+?()[]{}|\\";
+        let out = "";
+
+        for (const ch of str) {
+            if (specials.includes(ch)) out += "\\";
+            out += ch;
+        }
+
+        return out;
+    }
+
+    compileRoute(route: string) {
+        const keys = [];
+
+        const pattern = route.split("/").map(segment => {
+            if (segment.length > 2 && segment.startsWith("{") && segment.endsWith("}")) {
+                keys.push(segment.slice(1, -1));
+                return "([^/]+)";
+            }
+
+            return this.escapeRegex(segment);
+        }).join("/");
+
+        return { regex: new RegExp("^" + pattern + "$"), keys };
+    }
+
+    contentType(file: string) {
+        const types: object = {
+            html: "text/html",
+            css: "text/css",
+            js: "text/javascript",
+            mjs: "text/javascript",
+            json: "application/json",
+            svg: "image/svg+xml",
+            png: "image/png",
+            jpg: "image/jpeg",
+            jpeg: "image/jpeg",
+            gif: "image/gif",
+            webp: "image/webp",
+            ico: "image/x-icon",
+            woff: "font/woff",
+            woff2: "font/woff2",
+            ttf: "font/ttf",
+            txt: "text/plain"
+        };
+
+        const ext = file.split(".").pop().toLowerCase();
+        const mime = types[ext] ?? "application/octet-stream";
+        const isText = mime.startsWith("text/") || mime == "application/json" || mime == "image/svg+xml";
+
+        return isText ? `${mime}; charset=utf-8` : mime;
+    }
+
+    colorStatus(status: int) {
+        const text = String(status);
+
+        if (!process.stdout.isTTY) return text;
+
+        const esc = String.fromCharCode(27);
+        let color = "32";
+
+        if (status >= 500) color = "31";
+        else if (status >= 400) color = "33";
+        else if (status >= 300) color = "36";
+
+        return `${esc}[${color}m${text}${esc}[0m`;
+    }
+
+    api(path: string, handler: function) {
+        this.apiRoutes[path] = handler;
+    }
+
+    redirect(paths: object[]) {
+        for(const path of paths) {
+            if(empty path) continue
+
+            RedirectRoute.verify(path)
+
+            const from = path.from
+            const to = path.to
+
+            this.get(from, async (req, res) => {
+                res.writeHead(200, {
+                    "Content-Type": "text/html; charset=utf-8",
+                    "Cache-Control": "no-store"
+                });
+
+                res.end(`<script>window.location.href="${to}"</script>`);
+            })
+        }
+    }
+
+    static(paths: object[]) {
+        for(const path of paths) {
+            if(empty path) continue
+
+            StaticRoute.verify(path)
+
+            const from = path.from
+            const to = path.to
+
+            const root = nodePath.resolve(to);
+
+            if (!fs.existsSync(root)) {
+                log(`[SlimServer] Static setup ("${from}" -> "${to}"): directory not found: ${to}`);
+            }
+
+            this.staticDirs.push({ prefix: from, dir: to });
+        }
+    }
+
+    start() {
+        this.get("/__slim_reload__", (req, res) => {
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive"
+            });
+
+            res.write("retry: 300\n\n");
+
+            this.clients.push(res);
+
+            req.on("close", () => {
+                this.clients = this.clients.filter(x => x !== res);
+            });
+        });
+
+        http.createServer((req, res) => {
+            const url = req.url.split("?")[0];
+
+            if (this.dev && url != "/__slim_reload__") {
+                const started = Date.now();
+
+                res.on("finish", () => {
+                    const ms = Date.now() - started;
+                    log(`${req.method} ${req.url} ${this.colorStatus(res.statusCode)} in ${ms}ms`);
+                });
+            }
+
+            for (const route of this.routes) {
+                const match = url.match(route.regex);
+
+                if (match) {
+                    const params: object = {};
+                    route.keys.forEach((key, i) => {
+                        params[key] = decodeURIComponent(match[i + 1]);
+                    });
+
+                    route.callback(req, res, params);
+                    return;
+                }
+            }
+
+            const apiRoute = this.apiRoutes[url];
+
+            if (apiRoute) {
+                let body = "";
+                req.on("data", chunk => { body += chunk });
+                req.on("end", async () => {
+                    let data = null;
+
+                    if (body) {
+                        try {
+                            data = JSON.parse(body);
+                        } catch (e) {
+                            res.writeHead(400, { "Content-Type": "application/json" });
+                            res.end(JSON.stringify({ error: "Invalid JSON body" }));
+                            return;
+                        }
+                    }
+
+                    try {
+                        const result = await apiRoute(data, req);
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify(result ?? null));
+                    } catch (e) {
+                        res.writeHead(500, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: e && e.message ? e.message : String(e) }));
+                    }
+                });
+                return;
+            }
+
+            for (const mount of this.staticDirs) {
+                if (url == mount.prefix || url.startsWith(mount.prefix + "/")) {
+                    let relative = url.slice(mount.prefix.length);
+                    while (relative.startsWith("/")) relative = relative.slice(1);
+
+                    const root = nodePath.resolve(mount.dir);
+                    const filePath = nodePath.join(root, relative);
+
+                    if (filePath != root && !filePath.startsWith(root + nodePath.sep)) {
+                        res.writeHead(403);
+                        res.end("403");
+                        return;
+                    }
+
+                    fs.promises.readFile(filePath).then(data => {
+                        res.writeHead(200, {
+                            "Content-Type": this.contentType(filePath),
+                            "Cache-Control": "no-store"
+                        });
+                        res.end(data);
+                    }).catch(() => {
+                        res.writeHead(404);
+                        res.end("404");
+                    });
+
+                    return;
+                }
+            }
+
+            res.writeHead(404);
+            res.end("404");
+        }).listen(this.port);
+
+        log(`http://localhost:${this.port}`);
+    }
+}
+
+export { Server };

package/packages/slim/time/main.slim

@@ -0,0 +1,66 @@
+export default class TimeHelper {
+    static #convertMsToUnix(ms: int) {
+        if(sizeof ms > 12) return Math.floor(ms / 1000)
+        return ms
+    }
+    static now(): int {
+        return Date.now()
+    }
+    static toUnix(time: int): int {
+        return this.#convertMsToUnix(time)
+    }
+    static toDate(time: int, {
+        format = "{{dd}}.{{MM}}.{{yyyy}} {{hh}}:{{mm}}:{{ss}}:{{ii}}",
+        ampm = false
+    } = {}): string {
+        const unix: int = this.#convertMsToUnix(time)
+        const dateNow: Date = new Date(unix * 1000)
+
+        const pad: function = (value, len = 2) => String(value).padStart(len, "0")
+
+        let hours: int = dateNow.getHours()
+        let ampmSuffix: string = ""
+
+        if (ampm) {
+            ampmSuffix = hours >= 12 ? "PM" : "AM"
+            hours %= 12
+
+            if (hours === 0) {
+                hours = 12
+            }
+        }
+
+        const map: object = {
+            "{{d}}": dateNow.getDate(),
+            "{{dd}}": pad(dateNow.getDate()),
+
+            "{{M}}": dateNow.getMonth() + 1,
+            "{{MM}}": pad(dateNow.getMonth() + 1),
+
+            "{{yy}}": String(dateNow.getFullYear()).slice(-2),
+            "{{yyyy}}": dateNow.getFullYear(),
+
+            "{{h}}": hours,
+            "{{hh}}": pad(hours),
+
+            "{{m}}": dateNow.getMinutes(),
+            "{{mm}}": pad(dateNow.getMinutes()),
+
+            "{{s}}": dateNow.getSeconds(),
+            "{{ss}}": pad(dateNow.getSeconds()),
+
+            "{{i}}": dateNow.getMilliseconds(),
+            "{{ii}}": pad(dateNow.getMilliseconds(), 3),
+
+            "{{ampm}}": ampmSuffix
+        }
+
+        let result: string = format
+
+        for (const [token, value] of Object.entries(map)) {
+            result = result.replaceAll(token, value)
+        }
+
+        return result
+    }
+}

package/packages/slim/types/common.slim

@@ -0,0 +1,6 @@
+export type SymbolInstance(v) {
+    return kindof v == "symbol"
+}
+export type AnyArray(v) {
+    return typeof v == "object" and Array.isArray(v)
+}

package/packages/slim/types/formats.slim

@@ -0,0 +1,23 @@
+export func __isJSON(value) {
+    try {
+        JSON.parse(value)
+        return true
+    }
+    catch (e) {
+        return false
+    }
+}
+
+export type HTMLObject(v) {
+    return v instanceof HTMLElement
+}
+export type HTMLString(v) {
+    return /<\/?[^>]+(>|$)/g.test(v)
+}
+export type JSONString(v) {
+    return __isJSON(v)
+}
+
+export type SemVer(v) {
+    return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(v);
+}

package/packages/slim/types/hash.slim

@@ -0,0 +1,6 @@
+export type SHA256(v) {
+    return sizeof v == 64
+}
+export type QuickHash(v) {
+    return sizeof v == 8
+}

package/packages/slim/types/mails.slim

@@ -0,0 +1,3 @@
+export type gmail(v) {
+    return /^[a-z0-9.]+@gmail\.com$/i.test(v)
+}

package/packages/slim/types/numerical.slim

@@ -0,0 +1,9 @@
+export type nonZero(v) {
+    return (kindof v == "int" or kindof v == "float") && v != 0
+}
+export type even(v) {
+    return kindof v == "int" && v % 2 == 0
+}
+export type odd(v) {
+    return kindof v == "int" && v % 2 != 0
+}

package/packages/slim/types/time.slim

@@ -0,0 +1,3 @@
+export type TimeStamp(v) {
+    return sizeof v > 12
+}

package/run-dev-slim.js

@@ -0,0 +1,133 @@
+import fs from "fs";
+import chokidar from "chokidar";
+import { spawn } from "child_process";
+
+const config = JSON.parse(
+    fs.readFileSync("slimconfig.json", "utf8")
+);
+
+const entry = `dist/${config.main}.js`;
+const hot = process.argv.includes("--hot");
+
+let app = null;
+let rebuilding = false;
+let pending = false;
+
+function run() {
+    app = spawn("node", ["--enable-source-maps", "--no-warnings", entry], {
+        stdio: "inherit",
+        detached: process.platform !== "win32",
+        env: {
+            ...process.env,
+            SLIM_DEV: "1",
+            SLIM_HOT: hot ? "1" : "0"
+        }
+    });
+
+    app.on("exit", code => {
+        if (code && code !== 0)
+            console.log(`Application exited with code ${code}`);
+    });
+}
+
+function stop() {
+    return new Promise(resolve => {
+        if (!app || app.killed) {
+            app = null;
+            return resolve();
+        }
+
+        const proc = app;
+
+        proc.once("exit", () => {
+            app = null;
+            resolve();
+        });
+
+        const killTree = signal => {
+            if (process.platform === "win32") {
+                spawn("taskkill", ["/pid", String(proc.pid), "/T", "/F"]);
+            } else {
+                try {
+                    process.kill(-proc.pid, signal);
+                } catch {
+                    proc.kill(signal);
+                }
+            }
+        };
+
+        killTree("SIGTERM");
+
+        setTimeout(() => {
+            if (app === proc && !proc.killed) {
+                killTree("SIGKILL");
+            }
+        }, 1000);
+    });
+}
+
+function compile() {
+    return new Promise(resolve => {
+        const compiler = spawn("node", ["src/compile.js"], {
+            stdio: "inherit"
+        });
+
+        compiler.on("exit", code => {
+            resolve(code === 0);
+        });
+    });
+}
+
+async function rebuild() {
+    if (rebuilding) {
+        pending = true;
+        return;
+    }
+
+    rebuilding = true;
+
+    console.clear();
+    console.log("Compiling...");
+
+    const ok = await compile();
+
+    if (ok) {
+        await stop();
+        run();
+        console.log("Ready");
+    }
+
+    rebuilding = false;
+
+    if (pending) {
+        pending = false;
+        rebuild();
+    }
+}
+
+await rebuild();
+
+const watchTarget = config.watch ?? ".";
+
+const watcher = chokidar.watch(watchTarget, {
+    ignoreInitial: true,
+    awaitWriteFinish: {
+        stabilityThreshold: 150,
+        pollInterval: 50
+    },
+    ignored: p => /(^|[\\/])(node_modules|dist|\.git)([\\/]|$)/.test(p)
+});
+
+watcher.on("all", (_, file) => {
+    if (!file || !file.endsWith(".slim")) return;
+    console.log(`Changed: ${file}`);
+    rebuild();
+});
+
+process.on("SIGINT", async () => {
+    watcher.close();
+
+    await stop();
+
+    process.exit(0);
+});

package/run-slim.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { readFileSync } from 'fs';
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const config = JSON.parse(readFileSync(path.join(__dirname, 'slimconfig.json'), 'utf8'));
+const mainFile = config.main;
+
+const dist = path.join(__dirname, 'dist', `${mainFile}.js`);
+const args = ['--enable-source-maps', '--no-warnings', dist];
+
+const proc = spawn('node', args, { stdio: 'inherit' });
+
+proc.on('exit', (code) => {
+    process.exit(code);
+});