kadence-lang 0.2.0

package/src/vite-plugin-kadence.js

@@ -0,0 +1,39 @@
+const { compile } = require("./compiler");
+
+/**
+ * Vite plugin for Kadence (.kade) files
+ */
+function kadencePlugin() {
+    return {
+        name: "vite-plugin-kadence",
+
+        transform(code, id) {
+            if (!id.endsWith(".kade")) {
+                return null;
+            }
+
+            // Compile Kadence to JS with Source Maps
+            const result = compile(code, {
+                target: "browser",
+                sourcemap: true,
+                sourceFile: id
+            });
+
+            return {
+                code: result.code,
+                map: result.map
+            };
+        },
+
+        handleHotUpdate({ file, server, read: _read }) {
+            if (file.endsWith(".kade")) {
+                server.ws.send({
+                    type: "full-reload",
+                    path: "*"
+                });
+            }
+        }
+    };
+}
+
+module.exports = { kadencePlugin };

package/stdlib/check-helpers.js

@@ -0,0 +1,13 @@
+"use strict";
+
+function isDefined(val) {
+  return val !== undefined;
+}
+
+function isNull(val) {
+  return val === null;
+}
+
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = { isDefined, isNull };
+}

package/stdlib/check.js

@@ -0,0 +1,57 @@
+const fs = require("fs"); 
+
+function __kadence_echo(val) {
+    const s = String(val);
+    const low = s.toLowerCase();
+    if (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) {
+        if (low.includes('error')) console.log("\x1b[31m" + s + "\x1b[0m");
+        else if (low.includes('warning')) console.log("\x1b[33m" + s + "\x1b[0m");
+        else if (low.includes('success')) console.log("\x1b[32m" + s + "\x1b[0m");
+        else console.log(s);
+    } else {
+        console.log(s);
+    }
+}
+function __kadence_min(val) {
+    if (Array.isArray(val)) return Math.min(...val);
+    return val;
+}
+function __kadence_max(val) {
+    if (Array.isArray(val)) return Math.max(...val);
+    return val;
+}
+function __kadence_add(parent, child) {
+    if (Array.isArray(parent)) {
+        parent.push(child);
+        return parent;
+    }
+    if (typeof parent === 'object' && parent !== null && typeof parent.appendChild === 'function') {
+        parent.appendChild(child);
+        return parent;
+    }
+    throw new Error("Runtime Error: Cannot add item to " + typeof parent);
+}
+ 
+function isNumber (val) { 
+  return typeof val === 'number'; 
+ }
+if (typeof exports !== 'undefined') exports.isNumber = isNumber;
+function isString (val) { 
+  return typeof val === 'string'; 
+ }
+if (typeof exports !== 'undefined') exports.isString = isString;
+function isEmail (text) { 
+  let helper = require(`./check-helpers.js`); 
+  return helper.isEmail(text); 
+ }
+if (typeof exports !== 'undefined') exports.isEmail = isEmail;
+function between (val, min, max) { 
+  if (!((typeof val === 'number'))) { 
+  return false; 
+ }  
+  return val >= min  && val <= max  ; 
+ }
+if (typeof exports !== 'undefined') exports.between = between; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/check.kade

@@ -0,0 +1,21 @@
+note: Validation utilities for Kadence
+
+export function isNumber val
+    return val is a number
+end
+
+export function isString val
+    return val is a string
+end
+
+export function isEmail text
+    let helper = run require "./check-helpers.js"
+    return helper.isEmail(text)
+end
+
+export function between val min max
+    if not (val is a number)
+        return false
+    end
+    return val at least min and val at most max
+end

package/stdlib/color-helpers.js

@@ -0,0 +1,34 @@
+"use strict";
+
+function hexToRgb(hex) {
+  let s = hex.startsWith("#") ? hex.slice(1) : hex;
+  if (s.length !== 6) return "rgb(0, 0, 0)";
+  const r = parseInt(s.slice(0, 2), 16);
+  const g = parseInt(s.slice(2, 4), 16);
+  const b = parseInt(s.slice(4, 6), 16);
+  return `rgb(${r}, ${g}, ${b})`;
+}
+
+function lighten(color, percent) {
+  const match = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+  if (!match) return color;
+  const f = 1 + percent / 100;
+  const r = Math.min(255, Math.round(parseInt(match[1], 10) * f));
+  const g = Math.min(255, Math.round(parseInt(match[2], 10) * f));
+  const b = Math.min(255, Math.round(parseInt(match[3], 10) * f));
+  return color.startsWith("rgba") ? `rgba(${r}, ${g}, ${b}, 1)` : `rgb(${r}, ${g}, ${b})`;
+}
+
+function darken(color, percent) {
+  const match = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+  if (!match) return color;
+  const f = Math.max(0, 1 - percent / 100);
+  const r = Math.round(parseInt(match[1], 10) * f);
+  const g = Math.round(parseInt(match[2], 10) * f);
+  const b = Math.round(parseInt(match[3], 10) * f);
+  return color.startsWith("rgba") ? `rgba(${r}, ${g}, ${b}, 1)` : `rgb(${r}, ${g}, ${b})`;
+}
+
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = { hexToRgb, lighten, darken };
+}

package/stdlib/color.js

@@ -0,0 +1,60 @@
+const fs = require("fs"); 
+
+function __kadence_echo(val) {
+    const s = String(val);
+    const low = s.toLowerCase();
+    if (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) {
+        if (low.includes('error')) console.log("\x1b[31m" + s + "\x1b[0m");
+        else if (low.includes('warning')) console.log("\x1b[33m" + s + "\x1b[0m");
+        else if (low.includes('success')) console.log("\x1b[32m" + s + "\x1b[0m");
+        else console.log(s);
+    } else {
+        console.log(s);
+    }
+}
+function __kadence_min(val) {
+    if (Array.isArray(val)) return Math.min(...val);
+    return val;
+}
+function __kadence_max(val) {
+    if (Array.isArray(val)) return Math.max(...val);
+    return val;
+}
+function __kadence_add(parent, child) {
+    if (Array.isArray(parent)) {
+        parent.push(child);
+        return parent;
+    }
+    if (typeof parent === 'object' && parent !== null && typeof parent.appendChild === 'function') {
+        parent.appendChild(child);
+        return parent;
+    }
+    throw new Error("Runtime Error: Cannot add item to " + typeof parent);
+}
+ 
+function rgb (r, g, b) { 
+  return `rgb(` + r  + `,`  + g  + `,`  + b  + `)` ; 
+ }
+if (typeof exports !== 'undefined') exports.rgb = rgb;
+function rgba (r, g, b, a) { 
+  return `rgba(` + r  + `,`  + g  + `,`  + b  + `,`  + a  + `)` ; 
+ }
+if (typeof exports !== 'undefined') exports.rgba = rgba;
+function hex (hexStr) { 
+  let helper = require(`./color-helpers.js`); 
+  return helper.hexToRgb(hexStr); 
+ }
+if (typeof exports !== 'undefined') exports.hex = hex;
+function randomHex () { 
+  let rand = require(`./random.js`); 
+  let chars = [`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `a`, `b`, `c`, `d`, `e`, `f`]; 
+  let parts = [`#`]; 
+  for (let __i = 0; __i < 6; __i++) { 
+  __kadence_add(parts, (rand.choice(chars))); 
+ }  
+  return parts.join(``); 
+ }
+if (typeof exports !== 'undefined') exports.randomHex = randomHex; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/color.kade

@@ -0,0 +1,24 @@
+note: Color utilities for Kadence
+
+export function rgb r g b
+    return "rgb(" plus r plus "," plus g plus "," plus b plus ")"
+end
+
+export function rgba r g b a
+    return "rgba(" plus r plus "," plus g plus "," plus b plus "," plus a plus ")"
+end
+
+export function hex hexStr
+    let helper = run require "./color-helpers.js"
+    return run helper.hexToRgb hexStr
+end
+
+export function randomHex
+    let rand = run require "./random.js"
+    let chars = list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "a" "b" "c" "d" "e" "f"
+    let parts = list "#"
+    repeat 6 times
+        add (run rand.choice chars) to parts
+    end
+    return join parts with ""
+end

package/stdlib/console.js

@@ -0,0 +1,57 @@
+const fs = require("fs"); 
+
+function __kadence_echo(val) {
+    const s = String(val);
+    const low = s.toLowerCase();
+    if (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) {
+        if (low.includes('error')) console.log("\x1b[31m" + s + "\x1b[0m");
+        else if (low.includes('warning')) console.log("\x1b[33m" + s + "\x1b[0m");
+        else if (low.includes('success')) console.log("\x1b[32m" + s + "\x1b[0m");
+        else console.log(s);
+    } else {
+        console.log(s);
+    }
+}
+function __kadence_min(val) {
+    if (Array.isArray(val)) return Math.min(...val);
+    return val;
+}
+function __kadence_max(val) {
+    if (Array.isArray(val)) return Math.max(...val);
+    return val;
+}
+function __kadence_add(parent, child) {
+    if (Array.isArray(parent)) {
+        parent.push(child);
+        return parent;
+    }
+    if (typeof parent === 'object' && parent !== null && typeof parent.appendChild === 'function') {
+        parent.appendChild(child);
+        return parent;
+    }
+    throw new Error("Runtime Error: Cannot add item to " + typeof parent);
+}
+ 
+function log (message) { 
+  console.log(message);  
+ }
+if (typeof exports !== 'undefined') exports.log = log;
+function error (message) { 
+  console.error(message);  
+ }
+if (typeof exports !== 'undefined') exports.error = error;
+function red (text) { 
+  return `\x1b[31m` + text  + `\x1b[0m` ; 
+ }
+if (typeof exports !== 'undefined') exports.red = red;
+function green (text) { 
+  return `\x1b[32m` + text  + `\x1b[0m` ; 
+ }
+if (typeof exports !== 'undefined') exports.green = green;
+function bold (text) { 
+  return `\x1b[1m` + text  + `\x1b[0m` ; 
+ }
+if (typeof exports !== 'undefined') exports.bold = bold; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/console.kade

@@ -0,0 +1,21 @@
+note: Console and terminal styling for Kadence
+
+export function log message
+    console.log(message)
+end
+
+export function error message
+    console.error(message)
+end
+
+export function red text
+    return "\x1b[31m" plus text plus "\x1b[0m"
+end
+
+export function green text
+    return "\x1b[32m" plus text plus "\x1b[0m"
+end
+
+export function bold text
+    return "\x1b[1m" plus text plus "\x1b[0m"
+end

package/stdlib/crypto-helpers.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const crypto = typeof require !== "undefined" ? require("crypto") : null;
+
+function hash(str, algorithm = "sha256") {
+  if (!crypto) throw new Error("crypto module requires Node.js");
+  return crypto.createHash(algorithm).update(String(str), "utf8").digest("hex");
+}
+
+function randomBytes(n) {
+  if (!crypto) throw new Error("crypto module requires Node.js");
+  return crypto.randomBytes(n).toString("hex");
+}
+
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = { hash, randomBytes };
+}

package/stdlib/crypto.js

@@ -0,0 +1,46 @@
+const fs = require("fs"); 
+
+function __kadence_echo(val) {
+    const s = String(val);
+    const low = s.toLowerCase();
+    if (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) {
+        if (low.includes('error')) console.log("\x1b[31m" + s + "\x1b[0m");
+        else if (low.includes('warning')) console.log("\x1b[33m" + s + "\x1b[0m");
+        else if (low.includes('success')) console.log("\x1b[32m" + s + "\x1b[0m");
+        else console.log(s);
+    } else {
+        console.log(s);
+    }
+}
+function __kadence_min(val) {
+    if (Array.isArray(val)) return Math.min(...val);
+    return val;
+}
+function __kadence_max(val) {
+    if (Array.isArray(val)) return Math.max(...val);
+    return val;
+}
+function __kadence_add(parent, child) {
+    if (Array.isArray(parent)) {
+        parent.push(child);
+        return parent;
+    }
+    if (typeof parent === 'object' && parent !== null && typeof parent.appendChild === 'function') {
+        parent.appendChild(child);
+        return parent;
+    }
+    throw new Error("Runtime Error: Cannot add item to " + typeof parent);
+}
+ 
+let mod = require(`./crypto-helpers.js`); 
+function hash (str) { 
+  return mod.hash(str); 
+ }
+if (typeof exports !== 'undefined') exports.hash = hash;
+function randomBytes (n) { 
+  return mod.randomBytes(n); 
+ }
+if (typeof exports !== 'undefined') exports.randomBytes = randomBytes; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/crypto.kade

@@ -0,0 +1,11 @@
+note: Crypto utilities for Kadence (uses crypto-helpers.js)
+
+let mod = run require "./crypto-helpers.js"
+
+export function hash str
+    return run mod.hash str
+end
+
+export function randomBytes n
+    return run mod.randomBytes n
+end

package/stdlib/datetime.js

@@ -0,0 +1,68 @@
+const fs = require("fs"); 
+
+function __kadence_echo(val) {
+    const s = String(val);
+    const low = s.toLowerCase();
+    if (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) {
+        if (low.includes('error')) console.log("\x1b[31m" + s + "\x1b[0m");
+        else if (low.includes('warning')) console.log("\x1b[33m" + s + "\x1b[0m");
+        else if (low.includes('success')) console.log("\x1b[32m" + s + "\x1b[0m");
+        else console.log(s);
+    } else {
+        console.log(s);
+    }
+}
+function __kadence_min(val) {
+    if (Array.isArray(val)) return Math.min(...val);
+    return val;
+}
+function __kadence_max(val) {
+    if (Array.isArray(val)) return Math.max(...val);
+    return val;
+}
+function __kadence_add(parent, child) {
+    if (Array.isArray(parent)) {
+        parent.push(child);
+        return parent;
+    }
+    if (typeof parent === 'object' && parent !== null && typeof parent.appendChild === 'function') {
+        parent.appendChild(child);
+        return parent;
+    }
+    throw new Error("Runtime Error: Cannot add item to " + typeof parent);
+}
+ 
+function currentTime () { 
+  return new Date(); 
+ }
+if (typeof exports !== 'undefined') exports.currentTime = currentTime;
+function today () { 
+  return new Date(); 
+ }
+if (typeof exports !== 'undefined') exports.today = today;
+function year (d) { 
+  return d.getFullYear(); 
+ }
+if (typeof exports !== 'undefined') exports.year = year;
+function month (d) { 
+  let m = d.getMonth(); 
+  return m + 1 ; 
+ }
+if (typeof exports !== 'undefined') exports.month = month;
+function day (d) { 
+  return d.getDate(); 
+ }
+if (typeof exports !== 'undefined') exports.day = day;
+function toIso (d) { 
+  return d.toISOString(); 
+ }
+if (typeof exports !== 'undefined') exports.toIso = toIso;
+function addDays (d, n) { 
+  let result = new Date(d); 
+  result.setDate(result.getDate() + n ); 
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.addDays = addDays; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/datetime.kade

@@ -0,0 +1,32 @@
+note: Date and time utilities for Kadence
+
+export function currentTime
+    return new Date()
+end
+
+export function today
+    return new Date()
+end
+
+export function year d
+    return d.getFullYear()
+end
+
+export function month d
+    let m = d.getMonth()
+    return m + 1
+end
+
+export function day d
+    return d.getDate()
+end
+
+export function toIso d
+    return d.toISOString()
+end
+
+export function addDays d n
+    let result = new Date(d)
+    result.setDate(result.getDate() + n)
+    return result
+end

package/stdlib/encoding.js

@@ -0,0 +1,55 @@
+const fs = require("fs"); 
+
+function __kadence_echo(val) {
+    const s = String(val);
+    const low = s.toLowerCase();
+    if (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) {
+        if (low.includes('error')) console.log("\x1b[31m" + s + "\x1b[0m");
+        else if (low.includes('warning')) console.log("\x1b[33m" + s + "\x1b[0m");
+        else if (low.includes('success')) console.log("\x1b[32m" + s + "\x1b[0m");
+        else console.log(s);
+    } else {
+        console.log(s);
+    }
+}
+function __kadence_min(val) {
+    if (Array.isArray(val)) return Math.min(...val);
+    return val;
+}
+function __kadence_max(val) {
+    if (Array.isArray(val)) return Math.max(...val);
+    return val;
+}
+function __kadence_add(parent, child) {
+    if (Array.isArray(parent)) {
+        parent.push(child);
+        return parent;
+    }
+    if (typeof parent === 'object' && parent !== null && typeof parent.appendChild === 'function') {
+        parent.appendChild(child);
+        return parent;
+    }
+    throw new Error("Runtime Error: Cannot add item to " + typeof parent);
+}
+ 
+function base64Encode (str) { 
+  let buf = Buffer[`from`](str, `utf8`); 
+  return buf.toString(`base64`); 
+ }
+if (typeof exports !== 'undefined') exports.base64Encode = base64Encode;
+function base64Decode (str) { 
+  let buf = Buffer[`from`](str, `base64`); 
+  return buf.toString(`utf8`); 
+ }
+if (typeof exports !== 'undefined') exports.base64Decode = base64Decode;
+function urlEncode (str) { 
+  return encodeURIComponent(str); 
+ }
+if (typeof exports !== 'undefined') exports.urlEncode = urlEncode;
+function urlDecode (str) { 
+  return decodeURIComponent(str); 
+ }
+if (typeof exports !== 'undefined') exports.urlDecode = urlDecode; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/encoding.kade

@@ -0,0 +1,19 @@
+note: Encoding utilities for Kadence
+
+export function base64Encode str
+    let buf = run Buffer["from"] str "utf8"
+    return run buf.toString "base64"
+end
+
+export function base64Decode str
+    let buf = run Buffer["from"] str "base64"
+    return run buf.toString "utf8"
+end
+
+export function urlEncode str
+    return run encodeURIComponent str
+end
+
+export function urlDecode str
+    return run decodeURIComponent str
+end

package/stdlib/env.js

@@ -0,0 +1,46 @@
+const fs = require("fs"); 
+
+function __kadence_echo(val) {
+    const s = String(val);
+    const low = s.toLowerCase();
+    if (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) {
+        if (low.includes('error')) console.log("\x1b[31m" + s + "\x1b[0m");
+        else if (low.includes('warning')) console.log("\x1b[33m" + s + "\x1b[0m");
+        else if (low.includes('success')) console.log("\x1b[32m" + s + "\x1b[0m");
+        else console.log(s);
+    } else {
+        console.log(s);
+    }
+}
+function __kadence_min(val) {
+    if (Array.isArray(val)) return Math.min(...val);
+    return val;
+}
+function __kadence_max(val) {
+    if (Array.isArray(val)) return Math.max(...val);
+    return val;
+}
+function __kadence_add(parent, child) {
+    if (Array.isArray(parent)) {
+        parent.push(child);
+        return parent;
+    }
+    if (typeof parent === 'object' && parent !== null && typeof parent.appendChild === 'function') {
+        parent.appendChild(child);
+        return parent;
+    }
+    throw new Error("Runtime Error: Cannot add item to " + typeof parent);
+}
+ 
+let processMod = require(`process`); 
+function getEnv (name) { 
+  return processMod.env[name]; 
+ }
+if (typeof exports !== 'undefined') exports.getEnv = getEnv;
+function hasEnv (name) { 
+  return (getEnv(name)) !== undefined ; 
+ }
+if (typeof exports !== 'undefined') exports.hasEnv = hasEnv; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/env.kade

@@ -0,0 +1,11 @@
+note: Environment variable utilities
+
+let processMod = run require "process"
+
+export function getEnv name
+    return processMod.env[name]
+end
+
+export function hasEnv name
+    return (run getEnv name) not equals undefined
+end