kadence-lang 0.2.0

package/stdlib/network.kade

@@ -0,0 +1,38 @@
+note: Network utilities for Kadence
+
+let http = run require "http"
+
+export function serve port handler
+    let server = http.createServer((req, res) => {
+        let response = {
+            send: (body) => {
+                res.writeHead(200, { "Content-Type": "text/plain" })
+                res.end(body)
+            }
+            json: (body) => {
+                res.writeHead(200, { "Content-Type": "application/json" })
+                res.end(JSON.stringify(body))
+            }
+            html: (body) => {
+                res.writeHead(200, { "Content-Type": "text/html" })
+                res.end(body)
+            }
+        }
+        
+        set response.status to (code) => {
+            res.statusCode = code
+            return response
+        }
+
+        run handler req response
+    })
+
+    server.listen(port, () => {
+        say "Server running at http://localhost:{port}/"
+    })
+end
+
+export function fetchJson url
+    let result = await get from url
+    return result
+end

package/stdlib/number.js

@@ -0,0 +1,53 @@
+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 parseNumber (str) { 
+  return Number(str); 
+ }
+if (typeof exports !== 'undefined') exports.parseNumber = parseNumber;
+function formatNumber (num, decimals) { 
+  return num.toFixed(decimals); 
+ }
+if (typeof exports !== 'undefined') exports.formatNumber = formatNumber;
+function isNaNVal (val) { 
+  return Number.isNaN(val); 
+ }
+if (typeof exports !== 'undefined') exports.isNaNVal = isNaNVal;
+function isFiniteVal (val) { 
+  return Number.isFinite(val); 
+ }
+if (typeof exports !== 'undefined') exports.isFiniteVal = isFiniteVal; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/number.kade

@@ -0,0 +1,17 @@
+note: Number utilities for Kadence
+
+export function parseNumber str
+    return convert str to number
+end
+
+export function formatNumber num decimals
+    return run num.toFixed decimals
+end
+
+export function isNaNVal val
+    return run Number.isNaN val
+end
+
+export function isFiniteVal val
+    return run Number.isFinite val
+end

package/stdlib/object-helpers.js

@@ -0,0 +1,44 @@
+"use strict";
+
+function pick(obj, keys) {
+  const r = {};
+  for (const k of keys) {
+    if (Object.prototype.hasOwnProperty.call(obj, k)) r[k] = obj[k];
+  }
+  return r;
+}
+
+function omit(obj, keys) {
+  const set = new Set(keys);
+  const r = {};
+  for (const k of Object.keys(obj)) {
+    if (!set.has(k)) r[k] = obj[k];
+  }
+  return r;
+}
+
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+
+function get(obj, path) {
+  if (obj == null) return undefined;
+  const parts = typeof path === "string" ? path.split(".") : path;
+  let cur = obj;
+  for (const p of parts) {
+    cur = cur == null ? undefined : cur[p];
+  }
+  return cur;
+}
+
+function defaults(obj, defs) {
+  const r = { ...defs };
+  for (const k of Object.keys(obj || {})) {
+    if (r[k] === undefined) r[k] = obj[k];
+  }
+  return r;
+}
+
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = { pick, omit, deepClone, get, defaults };
+}

package/stdlib/object.js

@@ -0,0 +1,59 @@
+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 hasKey (obj, key) { 
+  let ks = Object.keys(obj); 
+  for (let k of ks) { 
+  if (k === key ) { 
+  return true; 
+ }   
+ } 
+  return false; 
+ }
+if (typeof exports !== 'undefined') exports.hasKey = hasKey;
+function getKeys (obj) { 
+  return Object.keys(obj); 
+ }
+if (typeof exports !== 'undefined') exports.getKeys = getKeys;
+function getValues (obj) { 
+  return Object.values(obj); 
+ }
+if (typeof exports !== 'undefined') exports.getValues = getValues;
+function mergeObjects (a, b) { 
+  return Object.assign({}, a, b); 
+ }
+if (typeof exports !== 'undefined') exports.mergeObjects = mergeObjects; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/object.kade

@@ -0,0 +1,23 @@
+note: Object utilities for Kadence
+
+export function hasKey obj key
+    let ks = keys of obj
+    for each k in ks
+        if k equals key
+            return true
+        end
+    end
+    return false
+end
+
+export function getKeys obj
+    return keys of obj
+end
+
+export function getValues obj
+    return values of obj
+end
+
+export function mergeObjects a b
+    return merge a with b
+end

package/stdlib/path.js

@@ -0,0 +1,58 @@
+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 pathMod = require(`path`); 
+function joinPaths (a, b) { 
+  return pathMod.join(a, b); 
+ }
+if (typeof exports !== 'undefined') exports.joinPaths = joinPaths;
+function resolve (path) { 
+  return pathMod.resolve(path); 
+ }
+if (typeof exports !== 'undefined') exports.resolve = resolve;
+function dirname (path) { 
+  return pathMod.dirname(path); 
+ }
+if (typeof exports !== 'undefined') exports.dirname = dirname;
+function basename (path) { 
+  return pathMod.basename(path); 
+ }
+if (typeof exports !== 'undefined') exports.basename = basename;
+function extension (path) { 
+  return pathMod.extname(path); 
+ }
+if (typeof exports !== 'undefined') exports.extension = extension; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/path.kade

@@ -0,0 +1,23 @@
+note: Path utilities for Kadence
+
+let pathMod = run require "path"
+
+export function joinPaths a b
+    return run pathMod.join a b
+end
+
+export function resolve path
+    return run pathMod.resolve path
+end
+
+export function dirname path
+    return run pathMod.dirname path
+end
+
+export function basename path
+    return run pathMod.basename path
+end
+
+export function extension path
+    return run pathMod.extname path
+end

package/stdlib/process-helpers.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const readline = typeof require !== "undefined" ? require("readline") : null;
+
+function readLine(_ignored) {
+  if (!readline) return Promise.reject(new Error("readLine requires Node.js"));
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question("", (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = { readLine };
+}

package/stdlib/process.js

@@ -0,0 +1,62 @@
+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 exit (code) { 
+  if (code === undefined ) { 
+  processMod.exit(0);  
+ }   else { 
+  processMod.exit(code);  
+ }   
+ }
+if (typeof exports !== 'undefined') exports.exit = exit;
+function args () { 
+  let allArgs = processMod.argv; 
+  let properArgs = []; 
+  let idx = 2; 
+  let len = allArgs.length; 
+  while (idx < len ) { 
+  __kadence_add(properArgs, allArgs[idx]);
+  idx++; 
+ }  
+  return properArgs; 
+ }
+if (typeof exports !== 'undefined') exports.args = args;
+function cwd () { 
+  return processMod.cwd(); 
+ }
+if (typeof exports !== 'undefined') exports.cwd = cwd; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/process.kade

@@ -0,0 +1,29 @@
+note: Process control utilities
+
+let processMod = run require "process"
+
+export function exit code
+    if code equals undefined
+        run processMod.exit 0
+    else
+        run processMod.exit code
+    end
+end
+
+export function args
+    let allArgs = processMod.argv
+    let properArgs = list
+    let idx = 2
+    let len = size of allArgs
+    
+    while idx less than len
+        add allArgs[idx] to properArgs
+        increment idx
+    end
+    
+    return properArgs
+end
+
+export function cwd
+    return run processMod.cwd
+end

package/stdlib/promise-helpers.js

@@ -0,0 +1,21 @@
+"use strict";
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function retry(fn, times) {
+  let lastErr;
+  const run = () =>
+    Promise.resolve(fn()).catch((err) => {
+      lastErr = err;
+      if (times <= 1) throw err;
+      times -= 1;
+      return run();
+    });
+  return run();
+}
+
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = { delay, retry };
+}

package/stdlib/promise.js

@@ -0,0 +1,54 @@
+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(`./promise-helpers.js`); 
+function promiseAll (promises) { 
+  return Promise[`all`](promises); 
+ }
+if (typeof exports !== 'undefined') exports.promiseAll = promiseAll;
+function promiseRace (promises) { 
+  return Promise[`race`](promises); 
+ }
+if (typeof exports !== 'undefined') exports.promiseRace = promiseRace;
+function delay (ms) { 
+  return mod.delay(ms); 
+ }
+if (typeof exports !== 'undefined') exports.delay = delay;
+function retry (fn, maxRetries) { 
+  return mod.retry(fn, maxRetries); 
+ }
+if (typeof exports !== 'undefined') exports.retry = retry; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/promise.kade

@@ -0,0 +1,19 @@
+note: Promise utilities for Kadence (uses promise-helpers.js)
+
+let mod = run require "./promise-helpers.js"
+
+export function promiseAll promises
+    return run Promise["all"] promises
+end
+
+export function promiseRace promises
+    return run Promise["race"] promises
+end
+
+export function delay ms
+    return run mod.delay ms
+end
+
+export function retry fn maxRetries
+    return run mod.retry fn maxRetries
+end

package/stdlib/random.js

@@ -0,0 +1,82 @@
+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 float (min, max) { 
+  return min + (Math.random() * (max - min ) ) ; 
+ }
+if (typeof exports !== 'undefined') exports.float = float;
+function integer (min, max) { 
+  let rangeVal = (max - min ) + 1 ; 
+  let factor = Math.random(); 
+  return Math.floor((min + (factor * rangeVal ) )); 
+ }
+if (typeof exports !== 'undefined') exports.integer = integer;
+function choice (items) { 
+  let len = items.length; 
+  if (len === 0 ) { 
+  return ``; 
+ }  
+  let idx = integer(0, (len - 1 )); 
+  return items[idx]; 
+ }
+if (typeof exports !== 'undefined') exports.choice = choice;
+function shuffle (items) { 
+  let res = []; 
+  let temp = []; 
+  for (let x of items) { 
+  __kadence_add(temp, x); 
+ } 
+  let n = temp.length; 
+  for (let __i = 0; __i < n; __i++) { 
+  let idx = integer(0, ((temp.length) - 1 )); 
+  let picked = temp[idx]; 
+  __kadence_add(res, picked);
+  temp.splice(idx, 1); 
+ }  
+  return res; 
+ }
+if (typeof exports !== 'undefined') exports.shuffle = shuffle;
+function uuid () { 
+  let chars = `0123456789abcdef`; 
+  let result = `#`; 
+  for (let __i = 0; __i < 6; __i++) { 
+  let idx = integer(0, 15); 
+  let result = result + (chars[idx]) ;  
+ }  
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.uuid = uuid; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/random.kade

@@ -0,0 +1,46 @@
+note: Random utilities for Kadence
+
+export function float min max
+    return min plus (random times (max minus min))
+end
+
+export function integer min max
+    let rangeVal = (max minus min) plus 1
+    let factor = random
+    return floor (min plus (factor times rangeVal))
+end
+
+export function choice items
+    let len = size of items
+    if len equals 0
+        return ""
+    end
+    let idx = run integer 0 (len minus 1)
+    return items[idx]
+end
+
+export function shuffle items
+    let res = list
+    let temp = list
+    for each x in items
+        add x to temp
+    end
+    let n = size of temp
+    repeat n times
+        let idx = run integer 0 ((size of temp) minus 1)
+        let picked = temp[idx]
+        add picked to res
+        remove item idx from temp
+    end
+    return res
+end
+
+export function uuid
+    let chars = "0123456789abcdef"
+    let result = "#"
+    repeat 6 times
+        let idx = run integer 0 15
+        let result = result plus (chars[idx])
+    end
+    return result
+end

package/stdlib/regex-helpers.js

@@ -0,0 +1,18 @@
+"use strict";
+
+function test(pattern, str) {
+  return new RegExp(pattern).test(str);
+}
+
+function replaceAll(pattern, str, replacement) {
+  return str.replace(new RegExp(pattern, "g"), replacement);
+}
+
+function validateUuid(uuid) {
+  const pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+  return pattern.test(uuid);
+}
+
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = { test, replaceAll, validateUuid };
+}