novac 2.0.1 → 2.2.0

package/novac/kits/kitnovacweb/nvml/index.js

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * NVML — Full pipeline
+ *
+ * Usage:
+ *   const nvml = require('./nvml');
+ *   const html = nvml.compile(source, { novaRunner, novaEmitter });
+ *   const doc  = nvml.execute(source, { novaRunner });
+ *   const html = nvml.renderDoc(doc, { novaEmitter });
+ */
+
+const { Lexer }    = require('./lexer');
+const { Parser }   = require('./parser');
+const { Executor, NvmlDocument, makeBfObject } = require('./executor');
+const { Renderer } = require('./renderer');
+
+/**
+ * Parse NVML source into AST (no side effects).
+ */
+function parse(source) {
+  return new Parser(source).parse();
+}
+
+/**
+ * Execute AST into a live NvmlDocument.
+ * @param {object} ast
+ * @param {object} opts
+ *   novaRunner(code, doc) — called for server-side Nova scripts
+ *   existingDoc — reuse an existing document (for incremental re-runs)
+ */
+function executeAst(ast, opts = {}) {
+  const exec = new Executor(opts.novaRunner || null);
+  return exec.execute(ast, opts.existingDoc || null);
+}
+
+/**
+ * Render a live NvmlDocument to an HTML string.
+ * @param {NvmlDocument} doc
+ * @param {object} opts
+ *   novaEmitter(code) — compiles Nova code to JS for client scripts
+ */
+function renderDoc(doc, opts = {}) {
+  const renderer = new Renderer({ novaEmitter: opts.novaEmitter || null });
+  return renderer.render(doc);
+}
+
+/**
+ * Full pipeline: source → HTML
+ */
+function compile(source, opts = {}) {
+  const ast = parse(source);
+  const doc = executeAst(ast, opts);
+  return renderDoc(doc, opts);
+}
+
+/**
+ * Execute source and return both doc + html.
+ */
+function run(source, opts = {}) {
+  const ast  = parse(source);
+  const doc  = executeAst(ast, opts);
+  const html = renderDoc(doc, opts);
+  return { doc, html, ast };
+}
+
+module.exports = { parse, executeAst, renderDoc, compile, run, NvmlDocument, makeBfObject };

package/novac/kits/kitnovacweb/nvml/lexer.js

@@ -0,0 +1,263 @@
+'use strict';
+
+// ══════════════════════════════════════════════════════════════════════
+//  NVML Lexer v2
+//  New tokens:
+//    HASH         #signal-name  (reactive signal ref)
+//    BANG_IDENT   !event        (event emit shorthand)
+//    AT_IDENT     @config @visual @ss @component @state @computed @effect @route @slot @use
+//    ELEMENT      {tag}  {element.tag}  {component.Name}
+//    LBRACKET [   RBRACKET ]
+//    LPAREN (     (multiline string / expression)
+//    COLONCOLON ::
+//    ARROW        ->   (one-way binding)
+//    DARROW       <->  (two-way binding)
+//    QUESTION     ?    (conditional render)
+//    TILDE        ~    (transition/animation hint)
+//    EQ =   COMMA ,   PIPE |   STRING   IDENT   NUMBER   DOT   DOTDOT   EOF
+// ══════════════════════════════════════════════════════════════════════
+
+const TT = {
+  AT_IDENT:    'AT_IDENT',
+  ELEMENT:     'ELEMENT',
+  LBRACKET:    'LBRACKET',
+  RBRACKET:    'RBRACKET',
+  LPAREN:      'LPAREN',
+  RPAREN:      'RPAREN',
+  COLONCOLON:  'COLONCOLON',
+  ARROW:       'ARROW',      // ->
+  DARROW:      'DARROW',     // <->
+  QUESTION:    'QUESTION',   // ?
+  TILDE:       'TILDE',      // ~
+  HASH:        'HASH',       // #signalName
+  BANG_IDENT:  'BANG_IDENT', // !eventName
+  EQ:          'EQ',
+  COMMA:       'COMMA',
+  PIPE:        'PIPE',
+  STRING:      'STRING',
+  IDENT:       'IDENT',
+  NUMBER:      'NUMBER',
+  DOT:         'DOT',
+  DOTDOT:      'DOTDOT',
+  EOF:         'EOF',
+};
+
+class Token {
+  constructor(type, value, line, col) {
+    this.type  = type;
+    this.value = value;
+    this.line  = line;
+    this.col   = col;
+  }
+  toString() { return `Token(${this.type}, ${JSON.stringify(this.value)}, ${this.line}:${this.col})`; }
+}
+
+class LexError extends Error {
+  constructor(msg, line, col) {
+    super(`[NVML Lexer ${line}:${col}] ${msg}`);
+    this.name = 'LexError';
+  }
+}
+
+class Lexer {
+  constructor(source) {
+    this.src    = source;
+    this.pos    = 0;
+    this.line   = 1;
+    this.col    = 1;
+    this.tokens = [];
+  }
+
+  peek(offset = 0) { return this.src[this.pos + offset] ?? '\0'; }
+  isAtEnd()        { return this.pos >= this.src.length; }
+
+  advance() {
+    const ch = this.src[this.pos++];
+    if (ch === '\n') { this.line++; this.col = 1; } else { this.col++; }
+    return ch;
+  }
+
+  addToken(type, value) {
+    this.tokens.push(new Token(type, value, this.line, this.col));
+  }
+
+  error(msg) { throw new LexError(msg, this.line, this.col); }
+
+  skipWhitespaceAndComments() {
+    while (!this.isAtEnd()) {
+      const ch = this.peek();
+      if (ch === ' ' || ch === '\t' || ch === '\r' || ch === '\n') { this.advance(); continue; }
+      // line comment
+      if (ch === '/' && this.peek(1) === '/') {
+        while (!this.isAtEnd() && this.peek() !== '\n') this.advance();
+        continue;
+      }
+      // block comment
+      if (ch === '/' && this.peek(1) === '*') {
+        this.advance(); this.advance();
+        while (!this.isAtEnd()) {
+          if (this.peek() === '*' && this.peek(1) === '/') { this.advance(); this.advance(); break; }
+          this.advance();
+        }
+        continue;
+      }
+      break;
+    }
+  }
+
+  readQuotedString(quote) {
+    let val = '';
+    while (!this.isAtEnd()) {
+      const ch = this.advance();
+      if (ch === '\\') {
+        const esc = this.advance();
+        switch (esc) {
+          case 'n': val += '\n'; break; case 't': val += '\t'; break;
+          case 'r': val += '\r'; break; case '\\': val += '\\'; break;
+          default:  val += esc;
+        }
+        continue;
+      }
+      if (ch === quote) break;
+      val += ch;
+    }
+    return val;
+  }
+
+  readParenString() {
+    let val = '', depth = 1;
+    while (!this.isAtEnd()) {
+      const ch = this.advance();
+      if (ch === '(') { depth++; val += ch; continue; }
+      if (ch === ')') { depth--; if (depth === 0) break; val += ch; continue; }
+      val += ch;
+    }
+    return val;
+  }
+
+  readElement() {
+    let name = '';
+    while (!this.isAtEnd() && this.peek() !== '}') name += this.advance();
+    if (this.isAtEnd()) this.error("Unterminated element name, expected '}'");
+    this.advance();
+    return name.trim();
+  }
+
+  readIdent(firstChar) {
+    let val = firstChar;
+    while (!this.isAtEnd() && /[a-zA-Z0-9_\-]/.test(this.peek())) val += this.advance();
+    return val;
+  }
+
+  readNumber(firstChar) {
+    let val = firstChar;
+    while (!this.isAtEnd() && /[0-9\.]/.test(this.peek())) val += this.advance();
+    return parseFloat(val);
+  }
+
+  tokenize() {
+    while (true) {
+      this.skipWhitespaceAndComments();
+      if (this.isAtEnd()) { this.addToken(TT.EOF, null); break; }
+
+      const line = this.line, col = this.col;
+      const ch = this.advance();
+
+      switch (ch) {
+        case '[': {
+          if (this.peek() === '.' && this.peek(1) === '.') {
+            this.advance(); this.advance();
+            if (this.peek() === ']') {
+              this.advance();
+              this.tokens.push(new Token(TT.DOTDOT, '..', line, col));
+            } else { this.error("Expected ']' after '..'"); }
+          } else {
+            this.tokens.push(new Token(TT.LBRACKET, '[', line, col));
+          }
+          break;
+        }
+        case ']': this.tokens.push(new Token(TT.RBRACKET, ']', line, col)); break;
+        case '(': {
+          const val = this.readParenString();
+          this.tokens.push(new Token(TT.STRING, val, line, col));
+          break;
+        }
+        case ')': this.tokens.push(new Token(TT.RPAREN, ')', line, col)); break;
+        case ',': this.tokens.push(new Token(TT.COMMA, ',', line, col)); break;
+        case '|': this.tokens.push(new Token(TT.PIPE, '|', line, col)); break;
+        case '=': this.tokens.push(new Token(TT.EQ, '=', line, col)); break;
+        case '?': this.tokens.push(new Token(TT.QUESTION, '?', line, col)); break;
+        case '~': this.tokens.push(new Token(TT.TILDE, '~', line, col)); break;
+        case '-': {
+          if (this.peek() === '>') { this.advance(); this.tokens.push(new Token(TT.ARROW, '->', line, col)); }
+          else this.error("Unexpected '-', did you mean '->'?");
+          break;
+        }
+        case '<': {
+          if (this.peek() === '-' && this.peek(1) === '>') {
+            this.advance(); this.advance();
+            this.tokens.push(new Token(TT.DARROW, '<->', line, col));
+          } else { this.error("Unexpected '<', did you mean '<->'?"); }
+          break;
+        }
+        case ':': {
+          if (this.peek() === ':') { this.advance(); this.tokens.push(new Token(TT.COLONCOLON, '::', line, col)); }
+          else this.error("Unexpected ':', did you mean '::'?");
+          break;
+        }
+        case '.': {
+          if (this.peek() === '.') { this.advance(); this.tokens.push(new Token(TT.DOTDOT, '..', line, col)); }
+          else this.tokens.push(new Token(TT.DOT, '.', line, col));
+          break;
+        }
+        case '#': {
+          // #signalName — reactive signal reference
+          if (/[a-zA-Z_]/.test(this.peek())) {
+            const name = this.readIdent(this.advance());
+            this.tokens.push(new Token(TT.HASH, name, line, col));
+          } else { this.error("Expected signal name after '#'"); }
+          break;
+        }
+        case '!': {
+          // !eventName — event emit shorthand
+          if (/[a-zA-Z_]/.test(this.peek())) {
+            const name = this.readIdent(this.advance());
+            this.tokens.push(new Token(TT.BANG_IDENT, name, line, col));
+          } else { this.error("Expected event name after '!'"); }
+          break;
+        }
+        case '@': {
+          if (/[a-zA-Z_]/.test(this.peek())) {
+            const name = this.readIdent(this.advance());
+            this.tokens.push(new Token(TT.AT_IDENT, name, line, col));
+          } else { this.error("Expected identifier after '@'"); }
+          break;
+        }
+        case '{': {
+          const name = this.readElement();
+          this.tokens.push(new Token(TT.ELEMENT, name, line, col));
+          break;
+        }
+        case "'": case '"': {
+          const val = this.readQuotedString(ch);
+          this.tokens.push(new Token(TT.STRING, val, line, col));
+          break;
+        }
+        default: {
+          if (/[a-zA-Z_]/.test(ch)) {
+            const val = this.readIdent(ch);
+            this.tokens.push(new Token(TT.IDENT, val, line, col));
+          } else if (/[0-9]/.test(ch)) {
+            const val = this.readNumber(ch);
+            this.tokens.push(new Token(TT.NUMBER, val, line, col));
+          } else {
+            this.error(`Unexpected character '${ch}'`);
+          }
+        }
+      }
+    }
+    return this.tokens;
+  }
+}
+
+module.exports = { Lexer, Token, TT };