starlight-cli 1.1.15 → 1.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starlight-cli",
-  "version": "1.1.15",
+  "version": "1.1.17",
   "description": "Starlight Programming Language CLI",
   "bin": {
     "starlight": "index.js"

package/src/evaluator.js

@@ -3,7 +3,6 @@ const fs = require('fs');
 const Lexer = require('./lexer');
 const Parser = require('./parser');
 const path = require('path');
-
 class ReturnValue {
   constructor(value) { this.value = value; }
 }
@@ -204,7 +203,51 @@ formatValue(value, seen = new Set()) {
         if (arg && typeof arg === 'object') return Object.keys(arg).length;
         return 0;
     });
+this.global.define('lower', arg => {
+    if (typeof arg !== 'string') return String(arg).toLowerCase();
+    return arg.toLowerCase();
+  });
+this.global.define('toStr', arg => String(arg));
+
+  this.global.define('upper', arg => {
+    if (typeof arg !== 'string') return String(arg).toUpperCase();
+    return arg.toUpperCase();
+  });
+
+  this.global.define('trim', arg => {
+    if (typeof arg !== 'string') return String(arg).trim();
+    return arg.trim();
+  });
+
+  this.global.define('startsWith', (str, prefix) => {
+    if (typeof str !== 'string') str = String(str);
+    if (typeof prefix !== 'string') prefix = String(prefix);
+    return str.startsWith(prefix);
+  });
+
+  this.global.define('endsWith', (str, suffix) => {
+    if (typeof str !== 'string') str = String(str);
+    if (typeof suffix !== 'string') suffix = String(suffix);
+    return str.endsWith(suffix);
+  });
+
+  this.global.define('includes', (str, substr) => {
+    if (typeof str !== 'string') str = String(str);
+    if (typeof substr !== 'string') substr = String(substr);
+    return str.includes(substr);
+  });
 
+  this.global.define('repeat', (str, times) => {
+    if (typeof str !== 'string') str = String(str);
+    return str.repeat(Number(times) || 0);
+  });
+
+  this.global.define('replace', (str, search, replacement) => {
+    if (typeof str !== 'string') str = String(str);
+    if (typeof search !== 'string') search = String(search);
+    if (typeof replacement !== 'string') replacement = String(replacement);
+    return str.split(search).join(replacement);
+  });
     this.global.define('print', arg => { console.log(arg); return null; });
     this.global.define('type', arg => {
         if (Array.isArray(arg)) return 'array';
@@ -353,6 +396,72 @@ this.global.define('range', (...args) => {
 
   return result;
 });
+this.global.define('floor', arg => Math.floor(Number(arg)));
+this.global.define('ceil', arg => Math.ceil(Number(arg)));
+this.global.define('round', arg => Math.round(Number(arg)));
+this.global.define('abs', arg => Math.abs(Number(arg)));
+this.global.define('pow', (base, exp) => Math.pow(Number(base), Number(exp)));
+this.global.define('sqrt', arg => Math.sqrt(Number(arg)));
+this.global.define('min', (...args) => Math.min(...args.map(Number)));
+this.global.define('max', (...args) => Math.max(...args.map(Number)));
+this.global.define('randomFloat', (min, max) => {
+    min = Number(min); max = Number(max);
+    if (isNaN(min) || isNaN(max)) return 0;
+    return Math.random() * (max - min) + min;
+});
+
+this.global.define('push', (arr, val) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('push() expects an array', null, this.source);
+    arr.push(val); return arr.length;
+});
+this.global.define('pop', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('pop() expects an array', null, this.source);
+    return arr.pop();
+});
+this.global.define('shift', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('shift() expects an array', null, this.source);
+    return arr.shift();
+});
+this.global.define('unshift', (arr, val) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('unshift() expects an array', null, this.source);
+    arr.unshift(val); return arr.length;
+});
+this.global.define('sort', (arr, fn) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('sort() expects an array', null, this.source);
+    if (fn && typeof fn === 'function') return arr.sort(fn);
+    return arr.sort();
+});
+this.global.define('reverse', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('reverse() expects an array', null, this.source);
+    return arr.reverse();
+});
+
+this.global.define('has', (obj, key) => obj && typeof obj === 'object' ? obj.hasOwnProperty(key) : false);
+this.global.define('merge', (obj1, obj2) => {
+    if (!obj1 || typeof obj1 !== 'object') obj1 = {};
+    if (!obj2 || typeof obj2 !== 'object') obj2 = {};
+    return { ...obj1, ...obj2 };
+});
+
+this.global.define('uuid', () => {
+    // simple random UUID v4
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+});
+this.global.define('timestamp', () => Date.now());
+this.global.define('clone', arg => {
+    if (Array.isArray(arg)) return [...arg];
+    if (arg && typeof arg === 'object') return { ...arg };
+    return arg; // primitive types
+});
+this.global.define('typeOf', arg => {
+    if (arg === null) return 'null';
+    if (Array.isArray(arg)) return 'array';
+    return typeof arg;
+});
 
     this.global.define('ask', prompt => {
         const readlineSync = require('readline-sync');
@@ -409,6 +518,271 @@ this.global.define('sleep', async (ms) => {
 this.global.define('str', arg => {
     return String(arg);
 });
+this.global.define('now', () => Date.now()); 
+this.global.define('formatDate', (timestamp, locale = 'en-US', options = {}) => {
+  if (timestamp === null || timestamp === undefined) timestamp = Date.now();
+  const t = typeof timestamp === 'number' ? timestamp : Number(timestamp);
+  if (isNaN(t)) t = Date.now();
+  return new Date(t).toLocaleString(locale, options);
+});
+
+this.global.define('readFile', path => {
+  if (typeof path !== 'string') path = String(path);
+  try {
+    return fs.readFileSync(path, 'utf-8');
+  } catch (e) {
+    throw new RuntimeError('readFile error: ' + e.message, null, this.source);
+  }
+});
+this.global.define('writeFile', (path, content) => {
+  if (typeof path !== 'string') path = String(path);
+  if (typeof content !== 'string') content = String(content);
+  try {
+    fs.writeFileSync(path, content, 'utf-8');
+    return true;
+  } catch (e) {
+    throw new RuntimeError('writeFile error: ' + e.message, null, this.source);
+  }
+});
+
+this.global.define('split', (str, separator) => {
+  if (typeof str !== 'string') str = String(str);
+  if (separator === undefined) separator = '';
+  return str.split(separator);
+});
+
+this.global.define('join', (arr, separator = '') => {
+  if (!Array.isArray(arr)) throw new RuntimeError('join() expects an array', null, this.source);
+  return arr.join(separator);
+});
+
+this.global.define('substring', (str, start, end) => {
+  if (typeof str !== 'string') str = String(str);
+  start = Number(start) || 0;
+  end = end !== undefined ? Number(end) : undefined;
+  return str.substring(start, end);
+});
+
+this.global.define('padStart', (str, targetLength, padString = ' ') => {
+  if (typeof str !== 'string') str = String(str);
+  targetLength = Number(targetLength) || 0;
+  return str.padStart(targetLength, padString);
+});
+
+this.global.define('padEnd', (str, targetLength, padString = ' ') => {
+  if (typeof str !== 'string') str = String(str);
+  targetLength = Number(targetLength) || 0;
+  return str.padEnd(targetLength, padString);
+});
+this.global.define('unique', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('unique() expects an array', null, this.source);
+    return [...new Set(arr)];
+});
+
+this.global.define('indexOf', (arr, val) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('indexOf() expects an array', null, this.source);
+    return arr.indexOf(val);
+});
+
+this.global.define('includesArr', (arr, val) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('includesArr() expects an array', null, this.source);
+    return arr.includes(val);
+});
+
+this.global.define('flatten', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('flatten() expects an array', null, this.source);
+    return arr.flat(Infinity);
+});
+
+this.global.define('randomChoice', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('randomChoice() expects an array', null, this.source);
+    return arr[Math.floor(Math.random() * arr.length)];
+});
+
+this.global.define('entries', obj => {
+    if (!obj || typeof obj !== 'object') throw new RuntimeError('entries() expects an object', null, this.source);
+    return Object.entries(obj);
+});
+
+this.global.define('invert', obj => {
+    if (!obj || typeof obj !== 'object') throw new RuntimeError('invert() expects an object', null, this.source);
+    const result = {};
+    for (const key in obj) result[obj[key]] = key;
+    return result;
+});
+
+this.global.define('isEmpty', arg => {
+    if (arg == null) return true;
+    if (Array.isArray(arg) || typeof arg === 'string') return arg.length === 0;
+    if (typeof arg === 'object') return Object.keys(arg).length === 0;
+    return false;
+});
+
+this.global.define('deepClone', arg => {
+    return JSON.parse(JSON.stringify(arg));
+});
+
+this.global.define('capitalize', str => {
+    if (typeof str !== 'string') str = String(str);
+    if (str.length === 0) return '';
+    return str[0].toUpperCase() + str.slice(1);
+});
+
+this.global.define('reverseStr', str => {
+    if (typeof str !== 'string') str = String(str);
+    return str.split('').reverse().join('');
+});
+
+this.global.define('trimStart', str => {
+    if (typeof str !== 'string') str = String(str);
+    return str.trimStart();
+});
+
+this.global.define('trimEnd', str => {
+    if (typeof str !== 'string') str = String(str);
+    return str.trimEnd();
+});
+
+this.global.define('clamp', (value, min, max) => {
+    value = Number(value); min = Number(min); max = Number(max);
+    return Math.min(Math.max(value, min), max);
+});
+
+this.global.define('sign', value => {
+    value = Number(value);
+    return Math.sign(value);
+});
+
+this.global.define('appendFile', (path, content) => {
+    if (typeof path !== 'string') path = String(path);
+    if (typeof content !== 'string') content = String(content);
+    try {
+        fs.appendFileSync(path, content, 'utf-8');
+        return true;
+    } catch (e) {
+        throw new RuntimeError('appendFile error: ' + e.message, null, this.source);
+    }
+});
+
+this.global.define('exists', path => {
+    if (typeof path !== 'string') path = String(path);
+    return fs.existsSync(path);
+});
+
+this.global.define('mkdir', path => {
+    if (typeof path !== 'string') path = String(path);
+    if (!fs.existsSync(path)) fs.mkdirSync(path, { recursive: true });
+    return true;
+});
+this.global.define('count', (arr, value) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('count() expects an array', null, this.source);
+    return arr.filter(x => x === value).length;
+});
+
+this.global.define('uniqueBy', (arr, fn) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('uniqueBy() expects an array', null, this.source);
+    const seen = new Set();
+    const result = [];
+    for (const item of arr) {
+        const key = fn ? fn(item) : item;
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(item);
+        }
+    }
+    return result;
+});
+this.global.define('getProp', (obj, key, defaultValue = null) => {
+    if (!obj || typeof obj !== 'object') return defaultValue;
+    const keys = key.split('.');
+    let current = obj;
+    for (const k of keys) {
+        if (current[k] === undefined) return defaultValue;
+        current = current[k];
+    }
+    return current;
+});
+
+this.global.define('setProp', (obj, key, value) => {
+    if (!obj || typeof obj !== 'object') throw new RuntimeError('setProp() expects an object', null, this.source);
+    const keys = key.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        if (!current[keys[i]] || typeof current[keys[i]] !== 'object') current[keys[i]] = {};
+        current = current[keys[i]];
+    }
+    current[keys[keys.length - 1]] = value;
+    return obj;
+});
+
+this.global.define('mergeDeep', (obj1, obj2) => {
+    const isObject = val => val && typeof val === 'object';
+    const result = {...obj1};
+    for (const key in obj2) {
+        if (isObject(obj2[key]) && isObject(result[key])) {
+            result[key] = this.global.get('mergeDeep')(result[key], obj2[key]);
+        } else {
+            result[key] = obj2[key];
+        }
+    }
+    return result;
+});
+this.global.define('camelCase', str => {
+    if (typeof str !== 'string') str = String(str);
+    return str
+        .replace(/[-_ ]+./g, s => s.charAt(s.length - 1).toUpperCase())
+        .replace(/^[A-Z]/, s => s.toLowerCase());
+});
+
+this.global.define('kebabCase', str => {
+    if (typeof str !== 'string') str = String(str);
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/\s+/g, '-')
+        .replace(/_+/g, '-')
+        .toLowerCase();
+});
+
+this.global.define('repeatStr', (str, times) => {
+    if (typeof str !== 'string') str = String(str);
+    return str.repeat(Number(times) || 0);
+});
+this.global.define('randomInt', (min, max) => {
+    min = Number(min); max = Number(max);
+    if (isNaN(min) || isNaN(max)) return 0;
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+});
+
+this.global.define('lerp', (a, b, t) => {
+    a = Number(a); b = Number(b); t = Number(t);
+    return a + (b - a) * t;
+});
+
+this.global.define('degToRad', deg => Number(deg) * (Math.PI / 180));
+this.global.define('radToDeg', rad => Number(rad) * (180 / Math.PI));
+this.global.define('readJSON', path => {
+    const content = this.global.get('readFile')(path);
+    return JSON.parse(content);
+});
+
+this.global.define('writeJSON', (path, obj) => {
+    const content = JSON.stringify(obj, null, 2);
+    return this.global.get('writeFile')(path, content);
+});
+
+this.global.define('deleteFile', path => {
+    if (typeof path !== 'string') path = String(path);
+    if (!fs.existsSync(path)) return false;
+    fs.unlinkSync(path);
+    return true;
+});
+
+this.global.define('rmdir', path => {
+    if (typeof path !== 'string') path = String(path);
+    if (!fs.existsSync(path)) return false;
+    fs.rmSync(path, { recursive: true, force: true });
+    return true;
+});
 
 }
 
@@ -422,10 +796,17 @@ async evaluate(node, env = this.global) {
     case 'SldeployStatement': return await this.evalSldeploy(node, env);
     case 'AskStatement': return await this.evalAsk(node, env);
     case 'DefineStatement': return await this.evalDefine(node, env);
+    case 'FunctionExpression':
+  return this.evalFunctionExpression(node, env);
+case 'SliceExpression':
+  return await this.evalSlice(node, env);
+
     case 'ExpressionStatement': return await this.evaluate(node.expression, env);
     case 'BinaryExpression': return await this.evalBinary(node, env);
     case 'LogicalExpression': return await this.evalLogical(node, env);
     case 'UnaryExpression': return await this.evalUnary(node, env);
+    case 'ConditionalExpression':
+  return await this.evalConditional(node, env);
     case 'Literal': return node.value;
     case 'Identifier': return env.get(node.name, node, this.source);
     case 'IfStatement': return await this.evalIf(node, env);
@@ -528,6 +909,36 @@ async evalProgram(node, env) {
   }
   return result;
 }
+async evalSlice(node, env) {
+  try {
+    const arr = await this.evaluate(node.object, env);
+    const start = node.start ? await this.evaluate(node.start, env) : 0;
+    const end = node.end ? await this.evaluate(node.end, env) : arr.length;
+
+    if (!Array.isArray(arr)) {
+      throw new RuntimeError(
+        'Slice target must be an array',
+        node,
+        this.source,
+        env
+      );
+    }
+
+    const s = start < 0 ? Math.max(arr.length + start, 0) : Math.min(start, arr.length);
+    const e = end < 0 ? Math.max(arr.length + end, 0) : Math.min(end, arr.length);
+
+    return arr.slice(s, e);
+
+  } catch (err) {
+    if (err instanceof RuntimeError) throw err;
+    throw new RuntimeError(
+      err.message || 'Error evaluating slice expression',
+      node,
+      this.source,
+      env
+    );
+  }
+}
 
 async evalStartStatement(node, env) {
   try {
@@ -576,6 +987,24 @@ async evalStartStatement(node, env) {
     );
   }
 }
+async evalConditional(node, env) {
+  try {
+    const test = await this.evaluate(node.test, env);
+    if (test) {
+      return await this.evaluate(node.consequent, env);
+    } else {
+      return await this.evaluate(node.alternate, env);
+    }
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error evaluating conditional expression',
+      node,
+      this.source,
+      env
+    );
+  }
+}
 
 async evalRaceClause(node, env) {
   try {
@@ -1186,6 +1615,41 @@ async evalFor(node, env) {
     );
   }
 }
+evalFunctionExpression(node, env) {
+  if (!node.body || !Array.isArray(node.params)) {
+    throw new RuntimeError(
+      'Invalid function expression',
+      node,
+      this.source,
+      env
+    );
+  }
+
+  const evaluator = this;
+
+  const fn = async function (...args) {
+    const localEnv = new Environment(env);
+
+    for (let i = 0; i < node.params.length; i++) {
+      const param = node.params[i];
+      const paramName = typeof param === 'string' ? param : param.name;
+      localEnv.define(paramName, args[i]);
+    }
+
+    try {
+      const result = await evaluator.evaluate(node.body, localEnv);
+      return result === undefined ? null : result;
+    } catch (e) {
+      if (e instanceof ReturnValue) return e.value === undefined ? null : e.value;
+      throw e;
+    }
+  };
+  fn.params = node.params;
+  fn.body = node.body;
+  fn.env = env;
+
+  return fn;
+}
 
 evalFunctionDeclaration(node, env) {
   try {
@@ -1273,7 +1737,6 @@ async evalCall(node, env) {
     );
   }
 }
-
 async evalIndex(node, env) {
   try {
     const obj = await this.evaluate(node.object, env);
@@ -1306,7 +1769,6 @@ async evalIndex(node, env) {
     );
   }
 }
-
 async evalObject(node, env) {
   try {
     const out = {};