novac 2.2.0 → 2.2.2

package/novac/src/core/types.js

@@ -1,112 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,244 +0,0 @@
-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);
-  },
-};