novac 2.2.0 → 2.2.2

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

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

@@ -1,263 +0,0 @@
-'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 };