kadence-lang 0.2.0

package/stdlib/regex.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(`./regex-helpers.js`); 
+function test (pattern, str) { 
+  return mod.test(pattern, str); 
+ }
+if (typeof exports !== 'undefined') exports.test = test;
+function replaceAll (pattern, str, replacement) { 
+  return mod.replaceAll(pattern, str, replacement); 
+ }
+if (typeof exports !== 'undefined') exports.replaceAll = replaceAll; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/regex.kade

@@ -0,0 +1,11 @@
+note: Regex utilities for Kadence (uses regex-helpers.js)
+
+let mod = run require "./regex-helpers.js"
+
+export function test pattern str
+    return run mod.test pattern str
+end
+
+export function replaceAll pattern str replacement
+    return run mod.replaceAll pattern str replacement
+end

package/stdlib/stream.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);
+}
+ 
+function createReader (stream) { 
+  return stream.getReader(); 
+ }
+if (typeof exports !== 'undefined') exports.createReader = createReader;
+async function readAll (stream) { 
+  let reader = createReader(stream); 
+  let result = []; 
+  while (true) { 
+  let { done, value } = await reader.read(); 
+  if (done) { 
+  break;  
+ }  
+  __kadence_add(result, value); 
+ }  
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.readAll = readAll;
+function pipe (source, to, target) { 
+  return source.pipeTo(target); 
+ }
+if (typeof exports !== 'undefined') exports.pipe = pipe; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/stream.kade

@@ -0,0 +1,22 @@
+note: Stream utilities for Kadence.
+
+export function createReader stream
+    return stream.getReader()
+end
+
+export async function readAll stream
+    let reader = run createReader stream
+    let result = list
+    while true
+        let { done, value } = await reader.read()
+        if done
+            break
+        end
+        add value to result
+    end
+    return result
+end
+
+export function pipe source to target
+    return source.pipeTo(target)
+end

package/stdlib/string-helpers.js

@@ -0,0 +1,16 @@
+"use strict";
+
+function escapeHtml(str) {
+  if (str == null) return "";
+  const s = String(str);
+  return s
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = { escapeHtml };
+}

package/stdlib/string.js

@@ -0,0 +1,101 @@
+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 words (text) { 
+  return text.split(` `); 
+ }
+if (typeof exports !== 'undefined') exports.words = words;
+function lines (text) { 
+  return text.split(`\n`); 
+ }
+if (typeof exports !== 'undefined') exports.lines = lines;
+function trimmed (text) { 
+  return text.trim(); 
+ }
+if (typeof exports !== 'undefined') exports.trimmed = trimmed;
+function capitalized (text) { 
+  let len = text.length; 
+  if (len === 0 ) { 
+  return text; 
+ }  
+  let firstChar = ((text[0])).toString().toUpperCase(); 
+  if (text === 1 .length) { 
+  return firstChar; 
+ }  
+  let parts = text.split(``); 
+  let rest = []; 
+  let idx = 1; 
+  while (idx < parts.length ) { 
+  __kadence_add(rest, parts[idx]);
+  idx++; 
+ }  
+  return firstChar + (rest.join(``)) ; 
+ }
+if (typeof exports !== 'undefined') exports.capitalized = capitalized;
+function padStart (text, length, char) { 
+  return text.padStart(length, char); 
+ }
+if (typeof exports !== 'undefined') exports.padStart = padStart;
+function padEnd (text, length, char) { 
+  return text.padEnd(length, char); 
+ }
+if (typeof exports !== 'undefined') exports.padEnd = padEnd;
+function repeated (text, count) { 
+  return text.repeat(count); 
+ }
+if (typeof exports !== 'undefined') exports.repeated = repeated;
+function slice (text, start, endIdx) { 
+  return text.slice(start, endIdx); 
+ }
+if (typeof exports !== 'undefined') exports.slice = slice;
+function toCamelCase (text) { 
+  let parts = text.split(` `); 
+  if (parts === 1 .length) { 
+  return (text).toString().toLowerCase(); 
+ }  
+  let res = ((parts[0])).toString().toLowerCase(); 
+  let idx = 1; 
+  while (idx < parts.length ) { 
+  let part = parts[idx]; 
+  let first = ((part[0])).toString().toUpperCase(); 
+  let rest = slice(part, 1); 
+  res = res + first  + rest ;
+  idx++; 
+ }  
+  return res; 
+ }
+if (typeof exports !== 'undefined') exports.toCamelCase = toCamelCase; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/string.kade

@@ -0,0 +1,66 @@
+note: String utilities for Kadence
+
+export function words text
+    return split text by " "
+end
+
+export function lines text
+    return split text by "\n"
+end
+
+export function trimmed text
+    return trim text
+end
+
+export function capitalized text
+    let len = size of text
+    if len equals 0
+        return text
+    end
+    let firstChar = uppercase (text[0])
+    if size of text equals 1
+        return firstChar
+    end
+    let parts = split text by ""
+    let rest = list
+    let idx = 1
+    while idx less than size of parts
+        add parts[idx] to rest
+        increment idx
+    end
+    return firstChar plus (join rest with "")
+end
+
+export function padStart text length char
+    return text.padStart(length, char)
+end
+
+export function padEnd text length char
+    return text.padEnd(length, char)
+end
+
+export function repeated text count
+    return text.repeat(count)
+end
+
+export function slice text start endIdx
+    return text.slice(start, endIdx)
+end
+
+export function toCamelCase text
+    let parts = split text by " "
+    if size of parts equals 1
+        return lowercase text
+    end
+    
+    let res = lowercase (parts[0])
+    let idx = 1
+    while idx less than size of parts
+        let part = parts[idx]
+        let first = uppercase (part[0])
+        let rest = run slice part 1
+        set res to res plus first plus rest
+        increment idx
+    end
+    return res
+end

package/stdlib/system.js

@@ -0,0 +1,66 @@
+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 os = require(`os`); 
+function platform () { 
+  return os.platform(); 
+ }
+if (typeof exports !== 'undefined') exports.platform = platform;
+function arch () { 
+  return os.arch(); 
+ }
+if (typeof exports !== 'undefined') exports.arch = arch;
+function cpus () { 
+  return os.cpus(); 
+ }
+if (typeof exports !== 'undefined') exports.cpus = cpus;
+function totalMemory () { 
+  return os.totalmem(); 
+ }
+if (typeof exports !== 'undefined') exports.totalMemory = totalMemory;
+function freeMemory () { 
+  return os.freemem(); 
+ }
+if (typeof exports !== 'undefined') exports.freeMemory = freeMemory;
+function homedir () { 
+  return os.homedir(); 
+ }
+if (typeof exports !== 'undefined') exports.homedir = homedir;
+function hostname () { 
+  return os.hostname(); 
+ }
+if (typeof exports !== 'undefined') exports.hostname = hostname; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/system.kade

@@ -0,0 +1,31 @@
+note: System utilities
+
+let os = run require "os"
+
+export function platform
+    return run os.platform
+end
+
+export function arch
+    return run os.arch
+end
+
+export function cpus
+    return run os.cpus
+end
+
+export function totalMemory
+    return run os.totalmem
+end
+
+export function freeMemory
+    return run os.freemem
+end
+
+export function homedir
+    return run os.homedir
+end
+
+export function hostname
+    return run os.hostname
+end

package/stdlib/test-helpers.js

@@ -0,0 +1,18 @@
+"use strict";
+
+/**
+ * Runs fn(); returns { threw: true, error } if it threw, { threw: false } otherwise.
+ * Used by test.assertThrows in Kadence.
+ */
+function assertThrows(fn) {
+  try {
+    fn();
+    return { threw: false };
+  } catch (e) {
+    return { threw: true, error: e };
+  }
+}
+
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = { assertThrows };
+}

package/stdlib/test.js

@@ -0,0 +1,72 @@
+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 term = require(`./console.js`); 
+function suite (name, callback) { 
+  __kadence_echo(`Suite: ` + name ); 
+  if (callback !== undefined ) { 
+  callback();  
+ }  
+  return true; 
+ }
+if (typeof exports !== 'undefined') exports.suite = suite;
+function assertEquals (actual, expected, message) { 
+  if (actual === expected ) { 
+  let colored = term.green(`PASS`); 
+  __kadence_echo(colored + `: `  + message ); 
+  return true; 
+ }   else { 
+  let colored = term.red(`FAIL`); 
+  __kadence_echo(colored + `: `  + message ); 
+  __kadence_echo(`  Expected: ` + expected ); 
+  __kadence_echo(`  Actual: ` + actual ); 
+  return false; 
+ }   
+ }
+if (typeof exports !== 'undefined') exports.assertEquals = assertEquals;
+function assertTrue (value, message) { 
+  if (value) { 
+  let colored = term.green(`PASS`); 
+  __kadence_echo(colored + `: `  + message ); 
+  return true; 
+ }   else { 
+  let colored = term.red(`FAIL`); 
+  __kadence_echo(colored + `: `  + message ); 
+  return false; 
+ }   
+ }
+if (typeof exports !== 'undefined') exports.assertTrue = assertTrue; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/test.kade

@@ -0,0 +1,37 @@
+note: Test utilities for Kadence
+
+let term = run require "./console.js"
+
+export function suite name callback
+    echo "Suite: " plus name
+    if callback not equals undefined
+        run callback
+    end
+    return true
+end
+
+export function assertEquals actual expected message
+    if actual equals expected
+        let colored = run term.green "PASS"
+        echo colored plus ": " plus message
+        return true
+    else
+        let colored = run term.red "FAIL"
+        echo colored plus ": " plus message
+        echo "  Expected: " plus expected
+        echo "  Actual: " plus actual
+        return false
+    end
+end
+
+export function assertTrue value message
+    if value
+        let colored = run term.green "PASS"
+        echo colored plus ": " plus message
+        return true
+    else
+        let colored = run term.red "FAIL"
+        echo colored plus ": " plus message
+        return false
+    end
+end

package/stdlib/url.js

@@ -0,0 +1,50 @@
+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 parseUrl (urlString) { 
+  return new URL(urlString); 
+ }
+if (typeof exports !== 'undefined') exports.parseUrl = parseUrl;
+function buildUrl (href) { 
+  let u = new URL(href); 
+  return u.toString(); 
+ }
+if (typeof exports !== 'undefined') exports.buildUrl = buildUrl;
+function getSearchParam (url, name) { 
+  return url.searchParams[`get`](name); 
+ }
+if (typeof exports !== 'undefined') exports.getSearchParam = getSearchParam; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/url.kade

@@ -0,0 +1,14 @@
+note: URL utilities for Kadence
+
+export function parseUrl urlString
+    return new URL(urlString)
+end
+
+export function buildUrl href
+    let u = new URL(href)
+    return run u.toString
+end
+
+export function getSearchParam url name
+    return run url.searchParams["get"] name
+end

package/stdlib/uuid.js

@@ -0,0 +1,70 @@
+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 rand = require(`./random.js`); 
+function v4 () { 
+  let chars = [`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `a`, `b`, `c`, `d`, `e`, `f`]; 
+  let variants = [`8`, `9`, `a`, `b`]; 
+  let s = ``; 
+  for (let __i = 0; __i < 8; __i++) { 
+  let s = s + (rand.choice(chars)) ;  
+ }  
+  let s = s + `-` ; 
+  for (let __i = 0; __i < 4; __i++) { 
+  let s = s + (rand.choice(chars)) ;  
+ }  
+  let s = s + `-4` ; 
+  for (let __i = 0; __i < 3; __i++) { 
+  let s = s + (rand.choice(chars)) ;  
+ }  
+  let s = s + `-` ; 
+  let s = s + (rand.choice(variants)) ; 
+  for (let __i = 0; __i < 3; __i++) { 
+  let s = s + (rand.choice(chars)) ;  
+ }  
+  let s = s + `-` ; 
+  for (let __i = 0; __i < 12; __i++) { 
+  let s = s + (rand.choice(chars)) ;  
+ }  
+  return s; 
+ }
+if (typeof exports !== 'undefined') exports.v4 = v4;
+function validate (uuid) { 
+  let helper = require(`./regex-helpers.js`); 
+  return helper.validateUuid(uuid); 
+ }
+if (typeof exports !== 'undefined') exports.validate = validate; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); });