kadence-lang 0.2.0

package/stdlib/file.js

@@ -0,0 +1,94 @@
+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 fsMod = require(`fs`); 
+function listDir (path) { 
+  return fsMod.readdirSync(path); 
+ }
+if (typeof exports !== 'undefined') exports.listDir = listDir;
+function exists (path) { 
+  return fsMod.existsSync(path); 
+ }
+if (typeof exports !== 'undefined') exports.exists = exists;
+function mkdir (path) { 
+  fsMod.mkdirSync(path);  
+ }
+if (typeof exports !== 'undefined') exports.mkdir = mkdir;
+function append (path, content) { 
+  fsMod.appendFileSync(path, content);  
+ }
+if (typeof exports !== 'undefined') exports.append = append;
+function unlink (path) { 
+  fsMod.unlinkSync(path);  
+ }
+if (typeof exports !== 'undefined') exports.unlink = unlink;
+function readFile (path) { 
+  return fsMod.readFileSync(path, `utf8`); 
+ }
+if (typeof exports !== 'undefined') exports.readFile = readFile;
+function writeFile (path, content) { 
+  fsMod.writeFileSync(path, content);  
+ }
+if (typeof exports !== 'undefined') exports.writeFile = writeFile;
+function copyFile (src, dest) { 
+  fsMod.copyFileSync(src, dest);  
+ }
+if (typeof exports !== 'undefined') exports.copyFile = copyFile;
+function removeDir (path) { 
+  fsMod.rmSync(path); 
+  { recursive: true, force: true };  
+ }
+if (typeof exports !== 'undefined') exports.removeDir = removeDir;
+function copyDir (src, dest) { 
+  fsMod.cpSync(src, dest); 
+  { recursive: true };  
+ }
+if (typeof exports !== 'undefined') exports.copyDir = copyDir;
+function stat (path) { 
+  return fsMod.statSync(path); 
+ }
+if (typeof exports !== 'undefined') exports.stat = stat;
+function isDirectory (path) { 
+  let s = stat(path); 
+  return s.isDirectory(); 
+ }
+if (typeof exports !== 'undefined') exports.isDirectory = isDirectory;
+function isFile (path) { 
+  let s = stat(path); 
+  return s.isFile(); 
+ }
+if (typeof exports !== 'undefined') exports.isFile = isFile; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/file.kade

@@ -0,0 +1,57 @@
+note: File system utilities for Kadence (uses Node fs)
+
+let fsMod = run require "fs"
+
+export function listDir path
+    return run fsMod.readdirSync path
+end
+
+export function exists path
+    return run fsMod.existsSync path
+end
+
+export function mkdir path
+    run fsMod.mkdirSync path
+end
+
+export function append path content
+    run fsMod.appendFileSync path content
+end
+
+export function unlink path
+    run fsMod.unlinkSync path
+end
+
+export function readFile path
+    return run fsMod.readFileSync path "utf8"
+end
+
+export function writeFile path content
+    run fsMod.writeFileSync path content
+end
+
+export function copyFile src dest
+    run fsMod.copyFileSync src dest
+end
+
+export function removeDir path
+    run fsMod.rmSync path { recursive: true, force: true }
+end
+
+export function copyDir src dest
+    run fsMod.cpSync src dest { recursive: true }
+end
+
+export function stat path
+    return run fsMod.statSync path
+end
+
+export function isDirectory path
+    let s = run stat path
+    return s.isDirectory()
+end
+
+export function isFile path
+    let s = run stat path
+    return s.isFile()
+end

package/stdlib/html.js

@@ -0,0 +1,65 @@
+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 tag (name, content) { 
+  return `<` + name  + `>`  + content  + `</`  + name  + `>` ; 
+ }
+if (typeof exports !== 'undefined') exports.tag = tag;
+function div (content) { 
+  return tag(`div`, content); 
+ }
+if (typeof exports !== 'undefined') exports.div = div;
+function span (content) { 
+  return tag(`span`, content); 
+ }
+if (typeof exports !== 'undefined') exports.span = span;
+function p (content) { 
+  return tag(`p`, content); 
+ }
+if (typeof exports !== 'undefined') exports.p = p;
+function h1 (content) { 
+  return tag(`h1`, content); 
+ }
+if (typeof exports !== 'undefined') exports.h1 = h1;
+function link (content) { 
+  return tag(`a`, content); 
+ }
+if (typeof exports !== 'undefined') exports.link = link;
+function img (content) { 
+  return tag(`img`, content); 
+ }
+if (typeof exports !== 'undefined') exports.img = img; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/html.kade

@@ -0,0 +1,29 @@
+note: HTML tag helpers for Kadence
+
+export function tag name content
+    return "<" plus name plus ">" plus content plus "</" plus name plus ">"
+end
+
+export function div content
+    return run tag "div" content
+end
+
+export function span content
+    return run tag "span" content
+end
+
+export function p content
+    return run tag "p" content
+end
+
+export function h1 content
+    return run tag "h1" content
+end
+
+export function link content
+    return run tag "a" content
+end
+
+export function img content
+    return run tag "img" content
+end

package/stdlib/json.js

@@ -0,0 +1,63 @@
+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 fsMod = require(`fs`); 
+function readJson (path) { 
+  if (!((fsMod.existsSync(path)))) { 
+  return null; 
+ }  
+  let content = fsMod.readFileSync(path, `utf8`); 
+  return JSON.parse(content); 
+ }
+if (typeof exports !== 'undefined') exports.readJson = readJson;
+function writeJson (path, data) { 
+  let str = JSON.stringify(data); 
+  fsMod.writeFileSync(path, str);  
+ }
+if (typeof exports !== 'undefined') exports.writeJson = writeJson;
+function format (data) { 
+  return JSON.stringify(data, null, 2); 
+ }
+if (typeof exports !== 'undefined') exports.format = format;
+function parseSafe (text) { 
+  try { 
+  return JSON.parse(text); 
+ }  catch(e) { 
+  return null; 
+ }   
+ }
+if (typeof exports !== 'undefined') exports.parseSafe = parseSafe; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/json.kade

@@ -0,0 +1,28 @@
+note: JSON utilities for Kadence
+
+let fsMod = run require "fs"
+
+export function readJson path
+    if not (run fsMod.existsSync path)
+        return null
+    end
+    let content = run fsMod.readFileSync path "utf8"
+    return parse json from content
+end
+
+export function writeJson path data
+    let str = stringify data to json
+    run fsMod.writeFileSync path str
+end
+
+export function format data
+    return JSON.stringify(data, null, 2)
+end
+
+export function parseSafe text
+    try
+        return parse json from text
+    catch e
+        return null
+    end
+end

package/stdlib/list.js

@@ -0,0 +1,109 @@
+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 first (array) { 
+  return array[0]; 
+ }
+if (typeof exports !== 'undefined') exports.first = first;
+function lastOf (array) { 
+  let n = array.length; 
+  let idx = n - 1 ; 
+  return array[idx]; 
+ }
+if (typeof exports !== 'undefined') exports.lastOf = lastOf;
+function isEmpty (array) { 
+  let len = array.length; 
+  return len === 0 ; 
+ }
+if (typeof exports !== 'undefined') exports.isEmpty = isEmpty;
+function length (array) { 
+  return array.length; 
+ }
+if (typeof exports !== 'undefined') exports.length = length;
+function contains (array, itemToFind) { 
+  let found = false; 
+  for (let x of array) { 
+  if (x === itemToFind ) { 
+  let found = true;  
+ }   
+ } 
+  return found; 
+ }
+if (typeof exports !== 'undefined') exports.contains = contains;
+function unique (array) { 
+  let result = []; 
+  for (let x of array) { 
+  let found = false; 
+  for (let r of result) { 
+  if (r === x ) { 
+  found = true;  
+ }   
+ } 
+  if (!(found)) { 
+  __kadence_add(result, x); 
+ }   
+ } 
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.unique = unique;
+function shuffle (array) { 
+  let output = []; 
+  for (let x of array) { 
+  __kadence_add(output, x); 
+ } 
+  let i = (output.length) - 1 ; 
+  while (i > 0 ) { 
+  let rand = require(`./random.js`); 
+  let j = rand.int(0, (i + 1 )); 
+  let temp = output[i]; 
+  output[i] = output[j]; 
+  output[j] = temp; 
+  i--; 
+ }  
+  return output; 
+ }
+if (typeof exports !== 'undefined') exports.shuffle = shuffle;
+function makeRange (start, endNum) { 
+  let result = []; 
+  let current = start; 
+  while (current < (endNum + 1 ) ) { 
+  __kadence_add(result, current);
+  current++; 
+ }  
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.makeRange = makeRange; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/list.kade

@@ -0,0 +1,75 @@
+note: List utilities for Kadence
+
+export function first array
+    return array[0]
+end
+
+export function lastOf array
+    let n = size of array
+    let idx = n minus 1
+    return array[idx]
+end
+
+export function isEmpty array
+    let len = size of array
+    return len equals 0
+end
+
+export function length array
+    return size of array
+end
+
+export function contains array itemToFind
+    let found = false
+    for each x in array
+        if x equals itemToFind
+            let found = true
+        end
+    end
+    return found
+end
+
+export function unique array
+    let result = list
+    for each x in array
+        let found = false
+        for each r in result
+            if r equals x
+                found = true
+            end
+        end
+        if not found
+            add x to result
+        end
+    end
+    return result
+end
+export function shuffle array
+    let output = list
+    for each x in array
+        add x to output
+    end
+    
+    let i = (size of output) minus 1
+    while i more than 0
+        let rand = run require "./random.js"
+        let j = run rand.int 0 (i plus 1)
+        
+        let temp = output[i]
+        output[i] = output[j]
+        output[j] = temp
+        
+        decrement i
+    end
+    return output
+end
+
+export function makeRange start endNum
+    let result = list
+    let current = start
+    while current less than (endNum plus 1)
+        add current to result
+        increment current
+    end
+    return result
+end

package/stdlib/math.js

@@ -0,0 +1,76 @@
+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 hypotenuse (a, b) { 
+  return Math.sqrt(((a * a ) + (b * b ) )); 
+ }
+if (typeof exports !== 'undefined') exports.hypotenuse = hypotenuse;
+function areaOfCircle (radius) { 
+  return Math.PI * radius  * radius ; 
+ }
+if (typeof exports !== 'undefined') exports.areaOfCircle = areaOfCircle;
+function isEven (n) { 
+  if ((n / 2) * 2  === n ) { 
+  return true; 
+ }   else { 
+  return false; 
+ }   
+ }
+if (typeof exports !== 'undefined') exports.isEven = isEven;
+function clamp (val, minVal, maxVal) { 
+  if (val < minVal ) { 
+  return minVal; 
+ }   else if (val > maxVal ) { 
+  return maxVal; 
+ }   else { 
+  return val; 
+ }   
+ }
+if (typeof exports !== 'undefined') exports.clamp = clamp;
+function randomFloat (min, max) { 
+  let r = Math.random(); 
+  return min + (r * (max - min ) ) ; 
+ }
+if (typeof exports !== 'undefined') exports.randomFloat = randomFloat;
+function toRadians (deg) { 
+  return deg * (Math.PI / 180) ; 
+ }
+if (typeof exports !== 'undefined') exports.toRadians = toRadians;
+function toDegrees (rad) { 
+  return rad * (180 / Math.PI) ; 
+ }
+if (typeof exports !== 'undefined') exports.toDegrees = toDegrees; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/math.kade

@@ -0,0 +1,39 @@
+note: Math utilities for Kadence
+
+export function hypotenuse a b
+    return square root ((a * a) plus (b * b))
+end
+
+export function areaOfCircle radius
+    return pi * radius * radius
+end
+
+export function isEven n
+    if (n / 2) * 2 equals n
+        return true
+    else
+        return false
+    end
+end
+
+export function clamp val minVal maxVal
+    if val less than minVal
+        return minVal
+    elif val more than maxVal
+        return maxVal
+    else
+        return val
+    end
+end
+export function randomFloat min max
+    let r = random
+    return min plus (r * (max minus min))
+end
+
+export function toRadians deg
+    return deg * (pi / 180)
+end
+
+export function toDegrees rad
+    return rad * (180 / pi)
+end

package/stdlib/network.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 http = require(`http`); 
+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);  
+ }  }; 
+  response.status = (code) => { 
+  res.statusCode = code; 
+  return response; 
+ } ;
+  handler(req, response);  
+ } ); 
+  server.listen(port, () => { 
+  __kadence_echo(`Server running at http://localhost:${port}/`);  
+ } );  
+ }
+if (typeof exports !== 'undefined') exports.serve = serve;
+function fetchJson (url) { 
+  let result = await fetch(url).then(r => r.json()); 
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.fetchJson = fetchJson; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); });