novac 2.0.1 → 2.2.0

package/novac/src/core/types.js

@@ -0,0 +1,112 @@
+class NovaValue {
+  constructor(inner) { this.inner = inner; }
+  get type() { return this.constructor.name; }
+  valueOf() { return this.inner?.valueOf?.() ?? this.inner; }
+  toString() { return String(this.valueOf()); }
+}
+class NovaNumber   extends NovaValue { constructor(n) { super(Number(n)); } }
+class NovaString   extends NovaValue { constructor(s) { super(String(s)); } }
+class NovaBool     extends NovaValue { constructor(b) { super(!!b); } }
+class NovaNull     extends NovaValue { constructor() { super(null); } toString() { return 'null'; } valueOf() { return null; } }
+class NovaFunction extends NovaValue {
+  constructor(fn, scope=null, args=[]) { super(fn); this.scope=scope; this.args=args; }
+  call(thisArg, ...args) {
+    if (typeof this.inner === 'function') return this.inner.apply(thisArg, args);
+  }
+}
+class NovaTemplateString extends NovaValue {
+  constructor(parts=[]) { super(parts.join('')); this.parts=parts; }
+}
+class NovaPointer extends NovaValue {
+  constructor(value, readFn=null, writeFn=null, address=null) {
+    super(value); this.readFn=readFn; this.writeFn=writeFn; this.address=address??Symbol('ptr');
+  }
+  read()    { return this.readFn ? this.readFn(this.valueOf()) : this.valueOf(); }
+  write(v)  { if (this.writeFn) this.writeFn(v, this.address); this.inner=v; }
+  toString(){ return '<Pointer@' + this.address.toString().slice(7,13) + '=' + this.inner + '>'; }
+}
+// Symbol used to attach a meta protocol to a NovaObject
+const NOVA_META = Symbol('NOVA_META');
+
+class NovaObject extends NovaValue {
+  constructor(obj={}) { super(obj); }
+
+  // Attach a meta descriptor: { get(k), set(k,v), missing(k) }
+  attachMeta(meta) { this[NOVA_META] = meta; }
+
+  get(k) {
+    const m = this[NOVA_META];
+    if (m) {
+      // If key exists, use meta.get if defined
+      if (k in this.inner) {
+        if (m.get) return m.get(k, this.inner[k]);
+        return this.inner[k];
+      }
+      // Key missing — use meta.missing
+      if (m.missing) return m.missing(k);
+      return undefined;
+    }
+    return this.inner[k];
+  }
+
+  set(k, v) {
+    const m = this[NOVA_META];
+    if (m && m.set) { m.set(k, v, this.inner); return; }
+    this.inner[k] = v;
+  }
+
+  delete(k)  { delete this.inner[k]; }
+  keys()     { return Object.keys(this.inner); }
+  values()   { return Object.values(this.inner); }
+  entries()  { return Object.entries(this.inner); }
+  has(k) { return Object.hasOwnProperty(this.inner, k); }
+  toCallable(){ return (vals) => new NovaObject(Object.fromEntries(vals.map((v,i)=>[i,v]))); }
+}
+class NovaArray extends NovaValue {
+  constructor(arr=[]) { super(arr); }
+  get(i)     { return this.inner[i]; }
+  set(i,v)   { this.inner[i]=v; }
+  delete(i)  { this.inner.splice(Number(i),1); }
+  push(v)    { this.inner.push(v); }
+  get length(){ return this.inner.length; }
+  toCallable(){ return (vals) => new NovaArray(vals); }
+}
+class NovaRange extends NovaValue {
+  constructor(start, end, step=1) { super({start,end,step}); this.start=start; this.end=end; this.step=step; }
+  toArray() {
+    const arr=[];
+    if (this.step>0) { for (let i=this.start;i<=this.end;i+=this.step) arr.push(i); }
+    else             { for (let i=this.start;i>=this.end;i+=this.step) arr.push(i); }
+    return arr;
+  }
+  includes(v) { return v>=Math.min(this.start,this.end)&&v<=Math.max(this.start,this.end); }
+  get length(){ return Math.max(0,Math.floor(Math.abs(this.end-this.start)/Math.abs(this.step))+1); }
+  toString()  { return 'Range(' + this.start + '..' + this.end + ')'; }
+}
+/** Struct instance — typed object created by a struct declaration */
+class NovaStruct extends NovaValue {
+  constructor(typeName, inner={}) { super(inner); this.typeName=typeName; }
+  get(k)    { return this.inner[k]; }
+  set(k,v)  { this.inner[k]=v; }
+  delete(k) { delete this.inner[k]; }
+  toString() {
+    const fields = Object.entries(this.inner).map(([k,v])=>k+': '+String(v)).join(', ');
+    return this.typeName + ' { ' + fields + ' }';
+  }
+}
+/** Enum value — access via .variant, .enumType, .value, .typeName */
+class NovaEnum extends NovaValue {
+  constructor(typeName, variant, value=null) {
+    super(value);
+    this.typeName = typeName;
+    this.variant  = variant;
+    this.enumType = typeName;   // .enumType instead of .type (avoids NovaValue getter clash)
+  }
+  toString() { return this.typeName + '::' + this.variant; }
+}
+module.exports = {
+  NovaValue, NovaNumber, NovaString, NovaBool, NovaNull,
+  NovaFunction, NovaTemplateString, NovaPointer,
+  NovaObject, NovaArray, NovaRange, NovaStruct, NovaEnum,
+  NOVA_META,
+};

package/novac/src/index.js

@@ -0,0 +1,28 @@
+const { Lexer }    = require('./core/lexer');
+const { Parser }   = require('./core/parser');
+const { Formatter } = require('./core/formatter');
+const { Executor, Scope, TypeRegistry } = require('./core/executor');
+const stdlib       = require('./runtime/stdlib');
+
+function run(source, builtins) {
+  const fullstd = { ...stdlib, ...builtins };
+  const parser   = new Parser(source);
+  const ast      = parser.parse();
+  const executor = new Executor(source, fullstd);
+  // Inject caller-provided builtins (e.g. document, request) directly into
+  // globalScope so Nova scripts can reference them as top-level variables.
+  // Without this they only land at globalScope.variables.std (as std.document)
+  // which is not how Nova scripts address them.
+  if (builtins) {
+    for (const [k, v] of Object.entries(builtins)) {
+      executor.globalScope.set(k, v);
+    }
+  }
+  return executor.run(ast);
+}
+
+function tokenize(source) { return new Lexer(source).tokenize(); }
+function parse(source)    { return new Parser(source).parse(); }
+function format(source)   { return new Formatter(source).format(); }
+
+module.exports = { run, tokenize, parse, format, Lexer, Parser, Formatter, Executor, Scope, TypeRegistry };

package/novac/src/runtime/stdlib.js

@@ -0,0 +1,244 @@
+const { NovaArray, NovaObject, NovaRange, NovaBool, NovaNull } = require("../core/types");
+
+module.exports = {
+  print: (...args) => console.log(...args),
+
+  // ── Math ──
+  Math: {
+    abs:   Math.abs,   ceil:  Math.ceil, floor: Math.floor,
+    round: Math.round, sqrt:  Math.sqrt, pow:   Math.pow,
+    max:   Math.max,   min:   Math.min,  log:   Math.log,
+    log2:  Math.log2,  log10: Math.log10,
+    sin:   Math.sin,   cos:   Math.cos,  tan:   Math.tan,
+    PI:    Math.PI,    E:     Math.E,
+    trunc: Math.trunc, sign:  Math.sign,
+    random: Math.random,
+    clamp: (v, lo, hi) => Math.min(Math.max(v, lo), hi),
+    floorTo(a, b) { return Math.floor(a / b) * b; },
+    ceilTo(a, b) { return Math.ceil(a / b) * b; },
+    factorial(n) {
+      //memo to optimize for larger n
+      const memo = [1];
+      function fact(x) {
+        if (x < 0) return NaN;
+        if (x === 0) return 1;
+        if (memo[x] !== undefined) return memo[x];
+        return memo[x] = x * fact(x - 1);
+      }
+      return fact(n);
+    },
+    fibonacci(n) {
+      //memo to optimize for larger n
+      const memo = [0, 1];
+      function fib(x) {
+        if (x < 0) return NaN;
+        if (memo[x] !== undefined) return memo[x];
+        return memo[x] = fib(x - 1) + fib(x - 2);
+      }
+      return fib(n);
+    },
+    divmod(a, b) {
+      if (b === 0) throw new Error("Division by zero");
+      const q = Math.floor(a / b);
+      const r = a - q * b;
+      return [q, r];
+    },
+  },
+
+  // ── Array utils ──
+  Array: {
+    from:    (it) => new NovaArray(Array.from(it instanceof NovaArray ? it.inner : (it ?? []))),
+    of:      (...args) => new NovaArray(args),
+    range:   (start, end, step = 1) => new NovaRange(start, end, step),
+    isArray: (v) => v instanceof NovaArray || Array.isArray(v),
+    fill:    (n, val) => new NovaArray(Array(n).fill(val)),
+    zip:     (...arrs) => {
+      const inners = arrs.map(a => a instanceof NovaArray ? a.inner : a);
+      const len    = Math.min(...inners.map(a => a.length));
+      return new NovaArray(Array.from({ length: len }, (_, i) => new NovaArray(inners.map(a => a[i]))));
+    },
+  },
+
+  // ── Object utils ──
+  Object: {
+    keys:    (o) => new NovaArray(o instanceof NovaObject ? Object.keys(o.inner) : Object.keys(o)),
+    values:  (o) => new NovaArray(o instanceof NovaObject ? Object.values(o.inner) : Object.values(o)),
+    entries: (o) => new NovaArray((o instanceof NovaObject ? Object.entries(o.inner) : Object.entries(o)).map(([k,v]) => new NovaArray([k,v]))),
+    assign:  (target, ...sources) => {
+      const t = target instanceof NovaObject ? target.inner : target;
+      for (const s of sources) Object.assign(t, s instanceof NovaObject ? s.inner : s);
+      return target;
+    },
+    freeze:  (o) => { Object.freeze(o instanceof NovaObject ? o.inner : o); return o; },
+    has:     (o, k) => o instanceof NovaObject ? k in o.inner : (k in (o ?? {})),
+    create:  (proto) => new NovaObject(Object.create(proto instanceof NovaObject ? proto.inner : proto)),
+  },
+
+  // ── String utils ──
+  String: {
+    from:         (v) => String(v),
+    padStart:     (s, n, ch = " ") => String(s).padStart(n, ch),
+    padEnd:       (s, n, ch = " ") => String(s).padEnd(n, ch),
+    repeat:       (s, n) => String(s).repeat(n),
+    includes:     (s, sub) => String(s).includes(sub),
+    startsWith:   (s, sub) => String(s).startsWith(sub),
+    endsWith:     (s, sub) => String(s).endsWith(sub),
+    trim:         (s) => String(s).trim(),
+    split:        (s, sep) => new NovaArray(String(s).split(sep)),
+    replace:      (s, from, to) => String(s).replace(from, to),
+    replaceAll:   (s, from, to) => String(s).replaceAll(from, to),
+    toUpper:      (s) => String(s).toUpperCase(),
+    toLower:      (s) => String(s).toLowerCase(),
+    charAt:       (s, i) => String(s).charAt(i),
+    charCodeAt:   (s, i) => String(s).charCodeAt(i),
+    fromCharCode: (...codes) => String.fromCharCode(...codes),
+    slice:        (s, a, b) => String(s).slice(a, b),
+    indexOf:      (s, sub) => String(s).indexOf(sub),
+  },
+
+  // ── Type checks ──
+  is: {
+    number:   (v) => typeof v === "number",
+    string:   (v) => typeof v === "string",
+    bool:     (v) => typeof v === "boolean" || v instanceof NovaBool,
+    array:    (v) => v instanceof NovaArray || Array.isArray(v),
+    object:   (v) => v instanceof NovaObject,
+    null:     (v) => v == null || v instanceof NovaNull,
+    func:     (v) => typeof v === "function" || (v?.args !== undefined && v?.body !== undefined),
+    range:    (v) => v instanceof NovaRange,
+    integer:  (v) => Number.isInteger(v),
+    finite:   (v) => Number.isFinite(v),
+    NaN:      (v) => Number.isNaN(v),
+  },
+
+  // ── Conversion ──
+  num:  (v) => Number(v),
+  str:  (v) => String(v),
+  bool: (v) => Boolean(v),
+  int:  (v) => Math.trunc(Number(v)),
+
+  // ── I/O ──
+  console: {
+    log:   console.log,
+    warn:  console.warn,
+    error: console.error,
+    info:  console.info,
+    time:  console.time,
+    timeEnd: console.timeEnd,
+  },
+
+  // ── Time ──
+  Date: {
+    now:    () => Date.now(),
+    create: (...args) => new Date(...args),
+  },
+
+  // ── JSON ──
+  json: {
+    parse:     (s) => JSON.parse(s),
+    stringify: (v, sp) => JSON.stringify(v instanceof NovaObject ? v.inner : (v instanceof NovaArray ? v.inner : v), null, sp),
+  },
+
+  // ── Promise / async ──
+  Promise: {
+    resolve: (v)       => Promise.resolve(v),
+    reject:  (v)       => Promise.reject(v),
+    all:     (arr)     => Promise.all(arr instanceof NovaArray ? arr.inner : arr),
+    race:    (arr)     => Promise.race(arr instanceof NovaArray ? arr.inner : arr),
+    allSettled: (arr)  => Promise.allSettled(arr instanceof NovaArray ? arr.inner : arr),
+    any:     (arr)     => Promise.any(arr instanceof NovaArray ? arr.inner : arr),
+  },
+
+  // ── Functional helpers ──
+  fn: {
+    identity: (x)        => x,
+    compose:  (...fns)   => (x) => fns.reduceRight((v, f) => f(v), x),
+    pipe:     (...fns)   => (x) => fns.reduce((v, f) => f(v), x),
+    memoize:  (f)        => { const c = new Map(); return (x) => { if (!c.has(x)) c.set(x, f(x)); return c.get(x); }; },
+    once:     (f)        => { let called = false, result; return (...a) => { if (!called) { called = true; result = f(...a); } return result; }; },
+    partial:  (f, ...a)  => (...b) => f(...a, ...b),
+    curry:    (f)        => { const a = (args) => args.length >= f.length ? f(...args) : (...more) => a([...args, ...more]); return a([]); },
+    noop:     ()         => undefined,
+    always:   (x)        => () => x,
+    flip:     (f)        => (a, b) => f(b, a),
+    not:      (f)        => (...a) => !f(...a),
+  },
+
+  // ── Errors ──
+  error: (msg) => { throw new Error(msg); },
+
+  // ── Range ──
+  range: (start, end, step = 1) => new NovaRange(start, end, step),
+
+  range: (start, end, step) => new NovaRange(start, end, step !== undefined ? step : 1),
+
+  fnum: (min, max, initial) => {
+    let v = Math.min(Math.max(initial !== undefined ? initial : min, min), max);
+    return { get value(){ return v; }, set value(nv){ v = Math.min(Math.max(Number(nv),min),max); }, valueOf(){ return v; }, toString(){ return String(v); } };
+  },
+  fint: (min, max, initial) => {
+    let v = Math.min(Math.max(Math.trunc(initial !== undefined ? initial : min), min), max);
+    return { get value(){ return v; }, set value(nv){ v = Math.min(Math.max(Math.trunc(Number(nv)),min),max); }, valueOf(){ return v; }, toString(){ return String(v); } };
+  },
+  convertCase: (str, target) => {
+    const words = String(str).replace(/([a-z])([A-Z])/g,'$1 $2').replace(/[-_]/g,' ').split(' ');
+    const m = { snake: w=>w.join('_'), camel: w=>w.map((s,i)=>i?s[0].toUpperCase()+s.slice(1).toLowerCase():s.toLowerCase()).join(''), pascal: w=>w.map(s=>s[0].toUpperCase()+s.slice(1).toLowerCase()).join(''), kebab: w=>w.join('-'), upper: w=>str.toUpperCase(), lower: w=>str.toLowerCase() };
+    return (m[target] || (()=>str))(words.map(s=>s.toLowerCase()));
+  },
+  randomWord: () => {
+    const v = 'aeiou';
+    const c = 'bcdfghjklmnpqrstvwxyz';
+    const pick = a => a[Math.floor(Math.random() * a.length)];
+    const patterns = ['CV','CVC','VC','CVV','CCV','VCC'];
+    const makeSyllable = () => patterns[Math.floor(Math.random() * patterns.length)].split('').map(p => p === 'C' ? pick(c) : pick(v)).join('');
+    const count = Math.floor(Math.random() * 3) + 1;
+    return Array.from({ length: count }, () => makeSyllable()).join('');
+  },
+  randomName: (format, minLen = 4, maxLen = 9) => {
+    const pick = a => a[Math.floor(Math.random() * a.length)];
+    const consonants = ['b','c','d','f','g','h','j','k','l','m','n','p','r','s','t','v','w','z'];
+    const consonantClusters = ['br','cr','dr','fr','gr','pr','tr','bl','cl','fl','gl','pl','sl','sc','sk','sm','sn','sp','st','str','ch','sh','th','wh','qu'];
+    const vowels = ['a','e','i','o','u','ae','ai','au','ea','ee','ei','ie','io','oa','oe','oi','oo','ou','ui','y','ay','ey','oy'];
+
+    const randomF = () => {
+      if (Math.random() < 0.35) return pick(consonantClusters);
+      return pick(consonants);
+    };
+    const randomL = () => {
+      if (Math.random() < 0.6) return pick(vowels);
+      return pick(['a','e','i','o','u']);
+    };
+    const parseFormat = str => {
+      if (typeof str !== 'string' || !str) return null;
+      const normalized = str.toLowerCase().trim();
+      if (!/^[fl]+$/.test(normalized)) return null;
+      return normalized.split('');
+    };
+    const makePieces = () => {
+      const blocks = Math.floor(Math.random() * 3) + 2;
+      const generated = [];
+      for (let i = 0; i < blocks; i++) {
+        const prev = generated[i - 1];
+        generated.push(i === 0 ? 'f' : (prev === 'f' ? 'l' : 'f'));
+      }
+      return generated;
+    };
+    const buildName = pieces => pieces.map(chunk => chunk === 'f' ? randomF() : randomL()).join('');
+    const normalizedMin = Math.max(1, Math.floor(minLen));
+    const normalizedMax = Math.max(normalizedMin, Math.floor(maxLen));
+    const pieces = parseFormat(format) || makePieces();
+
+    let name = buildName(pieces);
+    let attempts = 0;
+    while ((name.length < normalizedMin || name.length > normalizedMax) && attempts < 10) {
+      if (!parseFormat(format)) {
+        name = buildName(makePieces());
+      } else {
+        name = buildName(pieces);
+      }
+      attempts += 1;
+    }
+
+    return name[0].toUpperCase() + name.slice(1);
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "novac",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "a rewrite version of my package nvlang",
   "license": "MIT",
   "author": "purcwix",
@@ -8,7 +8,8 @@
   "main": "./bin/novac",
   "bin": {
     "novac": "./bin/novac",
-    "nvml": "./bin/nvml"
+    "nvml": "./bin/nvml",
+    "nvc": "./bin/nvc"
   },
   "directories": {
     "example": "examples",
@@ -20,6 +21,8 @@
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^14.0.2",
-    "serialize-javascript": "^7.0.5"
+    "node-addon-api": "latest",
+    "serialize-javascript": "^7.0.5",
+    "ssh2": "^1.17.0"
   }
 }