novac 2.0.1 → 2.2.0

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

@@ -0,0 +1,508 @@
+'use strict';
+
+/**
+ * NVML Parser v2
+ *
+ * Grammar:
+ *
+ *   program        → topNode*
+ *
+ *   topNode        → at_block | element_node
+ *
+ *   at_block       → '@config'   '[' kv_list ']'
+ *                  | '@visual'   '[' block* ']'
+ *                  | '@ss'       '[' block* ']'
+ *                  | '@component' IDENT '[' block* ']'
+ *                  | '@state'    '[' kv_list ']'
+ *                  | '@computed' '[' named_fn_list ']'
+ *                  | '@effect'   '[' effect_list ']'
+ *                  | '@route'    STRING '[' block* ']'
+ *                  | '@slot'     IDENT? '[' block* ']'
+ *                  | '@use'      IDENT (',' IDENT)* 
+ *
+ *   element_node   → ELEMENT ('=' value)?  ('[' element_body ']')?
+ *
+ *   element_body   → (property | child | parent_ref)*
+ *
+ *   property       → IDENT '=' value
+ *                  | IDENT                           (boolean)
+ *                  | IDENT '->' IDENT                (one-way binding: prop -> signal)
+ *                  | IDENT '<->' IDENT               (two-way binding: prop <-> signal)
+ *                  | IDENT '~' IDENT                 (transition: prop ~ transitionName)
+ *                  | '[..]' '::' IDENT ('=' value | '[' sub_body ']' | ε)
+ *
+ *   child          → element_node | at_block | text_node | conditional_child
+ *
+ *   conditional_child → '?' IDENT element_node     (render element only if signal is truthy)
+ *
+ *   value          → STRING | NUMBER | IDENT | '#' IDENT | pipe_list
+ */
+
+const { Lexer, TT } = require('./lexer');
+
+class ParseError extends Error {
+  constructor(msg, token) {
+    super(`[NVML Parser ${token ? token.line + ':' + token.col : '?'}] ${msg}`);
+    this.name = 'ParseError';
+    this.token = token;
+  }
+}
+
+const N = {
+  program:       (body)                           => ({ kind: 'program',         body }),
+  atConfig:      (pairs)                          => ({ kind: 'at_config',       pairs }),
+  atBlock:       (name, arg, body)                => ({ kind: 'at_block',        name, arg, body }),
+  atState:       (pairs)                          => ({ kind: 'at_state',        pairs }),
+  atComputed:    (entries)                        => ({ kind: 'at_computed',     entries }),
+  atEffect:      (entries)                        => ({ kind: 'at_effect',       entries }),
+  atLang:        (name, pairs)                    => ({ kind: 'at_lang',        name, pairs }),
+  atRoute:       (path, body)                     => ({ kind: 'at_route',        path, body }),
+  atSlot:        (name, body)                     => ({ kind: 'at_slot',         name, body }),
+  atUse:         (names)                          => ({ kind: 'at_use',          names }),
+  element:       (tag, textValue, props, body,
+                  bindings, transitions, cond)    => ({ kind: 'element',         tag, textValue, props, body, bindings, transitions, cond }),
+  property:      (key, value)                     => ({ kind: 'property',        key, value }),
+  binding:       (prop, signal, twoWay)           => ({ kind: 'binding',         prop, signal, twoWay }),
+  transition:    (prop, name)                     => ({ kind: 'transition',       prop, name }),
+  parentProp:    (prop, value, subBody)           => ({ kind: 'parent_prop',     prop, value, subBody }),
+  signalRef:     (name)                           => ({ kind: 'signal_ref',      name }),
+  value:         (v)                              => ({ kind: 'value',           value: v }),
+  pipeList:      (items)                          => ({ kind: 'pipe_list',       items }),
+  textNode:      (value)                          => ({ kind: 'text_node',       value }),
+  conditional:   (signal, child)                  => ({ kind: 'conditional',     signal, child }),
+  cssDecl:       (key, value)                     => ({ kind: 'css_decl',        key, value }),
+  eachBlock:     (signal, itemVar, indexVar, body)=> ({ kind: 'each_block',      signal, itemVar, indexVar, body }),
+  slotOutlet:    (name)                           => ({ kind: 'slot_outlet',     name }),
+  componentUse:  (name, props, slots)             => ({ kind: 'component_use',   name, props, slots }),
+};
+
+class Parser {
+  constructor(source) {
+    this.tokens  = new Lexer(source).tokenize();
+    this.current = 0;
+  }
+
+  peek()     { return this.tokens[this.current]; }
+  previous() { return this.tokens[this.current - 1]; }
+  isAtEnd()  { return this.peek().type === TT.EOF; }
+
+  advance() { if (!this.isAtEnd()) this.current++; return this.previous(); }
+
+  check(type, value = null) {
+    if (this.isAtEnd()) return false;
+    const t = this.peek();
+    return t.type === type && (value === null || t.value === value);
+  }
+
+  match(...specs) {
+    for (const spec of specs) {
+      const [type, value = null] = Array.isArray(spec) ? spec : [spec];
+      if (this.check(type, value)) { this.advance(); return true; }
+    }
+    return false;
+  }
+
+  consume(type, value, msg) {
+    if (value !== null && value !== undefined && this.check(type, value)) return this.advance();
+    if ((value === null || value === undefined) && this.check(type)) return this.advance();
+    throw new ParseError(msg || `Expected ${type}${value ? ' ' + value : ''}`, this.peek());
+  }
+
+  error(msg) { throw new ParseError(msg, this.peek()); }
+
+  // ── entry ──────────────────────────────────────────────────────
+
+  parse() {
+    const body = [];
+    while (!this.isAtEnd()) body.push(this.parseTopNode());
+    return N.program(body);
+  }
+
+  parseTopNode() {
+    const t = this.peek();
+    if (t.type === TT.AT_IDENT) return this.parseAtBlock();
+    if (t.type === TT.ELEMENT)  return this.parseElement();
+    this.error(`Unexpected token '${t.value}' (${t.type}) at top level`);
+  }
+
+  // ── @blocks ────────────────────────────────────────────────────
+
+  parseAtBlock() {
+    const name = this.advance().value; // consume AT_IDENT
+
+    switch (name) {
+      case 'config':
+        this.consume(TT.LBRACKET, null, "Expected '[' after @config");
+        const configPairs = this.parseKVList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @config");
+        return N.atConfig(configPairs);
+
+      case 'state':
+        this.consume(TT.LBRACKET, null, "Expected '[' after @state");
+        const statePairs = this.parseKVList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @state");
+        return N.atState(statePairs);
+
+      case 'computed':
+        this.consume(TT.LBRACKET, null, "Expected '[' after @computed");
+        const computedEntries = this.parseNamedCodeList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @computed");
+        return N.atComputed(computedEntries);
+
+      case 'effect':
+        this.consume(TT.LBRACKET, null, "Expected '[' after @effect");
+        const effectEntries = this.parseEffectList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @effect");
+        return N.atEffect(effectEntries);
+
+      case 'component': {
+        const compName = this.consume(TT.IDENT, null, "Expected component name after @component").value;
+        this.consume(TT.LBRACKET, null, "Expected '[' after @component name");
+        const compBody = this.parseBlockList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @component");
+        return N.atComponent(compName, compBody);
+      }
+
+      case 'lang': {
+        // @lang {langName} [ runtime_language="nv", config="", src="PATH", code=(...) ]
+        const langName  = this.consume(TT.IDENT, null, 'Expected language name after @lang').value;
+        this.consume(TT.LBRACKET, null, "Expected '[' after @lang name");
+        const langPairs = this._parseLangKVList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @lang");
+        return N.atLang(langName, langPairs);
+      }
+
+      case 'route': {
+        const routePath = this.parseValue(); // STRING or IDENT
+        this.consume(TT.LBRACKET, null, "Expected '[' after @route path");
+        const routeBody = this.parseBlockList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @route");
+        return N.atRoute(routePath, routeBody);
+      }
+
+      case 'slot': {
+        let slotName = 'default';
+        if (this.check(TT.IDENT)) slotName = this.advance().value;
+        this.consume(TT.LBRACKET, null, "Expected '[' after @slot");
+        const slotBody = this.parseBlockList();
+        this.consume(TT.RBRACKET, null, "Expected ']' to close @slot");
+        return N.atSlot(slotName, slotBody);
+      }
+
+      case 'use': {
+        const useNames = [];
+        useNames.push(this.consume(TT.IDENT, null, "Expected component name after @use").value);
+        while (this.match(TT.COMMA)) {
+          useNames.push(this.consume(TT.IDENT, null, "Expected component name").value);
+        }
+        return N.atUse(useNames);
+      }
+
+      default: {
+        // @visual, @ss, or unknown custom at-block
+        this.consume(TT.LBRACKET, null, `Expected '[' after @${name}`);
+        const body = this.parseBlockList();
+        this.consume(TT.RBRACKET, null, `Expected ']' to close @${name}`);
+        return N.atBlock(name, null, body);
+      }
+    }
+  }
+
+  parseBlockList() {
+    const body = [];
+    while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+      if (this.check(TT.AT_IDENT)) { body.push(this.parseAtBlock()); continue; }
+      if (this.check(TT.ELEMENT))  { body.push(this.parseElement()); continue; }
+      if (this.check(TT.DOTDOT))   { body.push(this.parseParentPropInline()); continue; }
+      if (this.check(TT.STRING))   { body.push(N.textNode(this.advance().value)); continue; }
+      if (this.check(TT.COMMA))    { this.advance(); continue; }
+      break;
+    }
+    return body;
+  }
+
+  // ── kv list (flat key=value pairs) ────────────────────────────
+
+  parseKVList() {
+    const pairs = {};
+    while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+      if (this.match(TT.COMMA)) continue;
+      if (!this.check(TT.IDENT)) break;
+      const key = this.advance().value;
+      this.consume(TT.EQ, null, `Expected '=' after key '${key}'`);
+      pairs[key] = this.parseValue();
+      this.match(TT.COMMA);
+    }
+    return pairs;
+  }
+
+  // ── @lang kv list — like parseKVList but also accepts bare string values ──
+  // Handles: runtime_language="nv"  config=""  src="PATH"  code=(...)
+  _parseLangKVList() {
+    const pairs = {};
+    while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+      if (this.match(TT.COMMA)) continue;
+      if (!this.check(TT.IDENT)) break;
+      const key = this.advance().value;
+      if (this.match(TT.EQ)) {
+        pairs[key] = this.parseValue();
+      } else {
+        pairs[key] = N.value(true);
+      }
+      this.match(TT.COMMA);
+    }
+    return pairs;
+  }
+
+
+
+  parseNamedCodeList() {
+    const entries = [];
+    while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+      if (this.match(TT.COMMA)) continue;
+      if (!this.check(TT.IDENT)) break;
+      const name = this.advance().value;
+      this.consume(TT.EQ, null, `Expected '=' after computed name '${name}'`);
+      const code = this.parseValue();
+      entries.push({ name, code });
+      this.match(TT.COMMA);
+    }
+    return entries;
+  }
+
+  // ── @effect entries: deps -> (nova code) ──────────────────────
+
+  parseEffectList() {
+    const entries = [];
+    while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+      if (this.match(TT.COMMA)) continue;
+      // deps: [signalA, signalB] or * (always) — stored as array of names
+      const deps = [];
+      if (this.check(TT.LBRACKET)) {
+        this.advance();
+        while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+          if (this.check(TT.IDENT)) deps.push(this.advance().value);
+          this.match(TT.COMMA);
+        }
+        this.consume(TT.RBRACKET, null, "Expected ']' to close effect deps");
+      } else if (this.check(TT.IDENT, '*')) {
+        this.advance(); // wildcard — run on any signal change
+        deps.push('*');
+      } else if (this.check(TT.IDENT)) {
+        deps.push(this.advance().value);
+      }
+      this.consume(TT.ARROW, null, "Expected '->' after effect deps");
+      const code = this.parseValue();
+      entries.push({ deps, code });
+      this.match(TT.COMMA);
+    }
+    return entries;
+  }
+
+  // ── element ────────────────────────────────────────────────────
+
+  parseElement() {
+    const tag = this.advance().value;
+
+    let textValue = null;
+    if (this.match(TT.EQ)) textValue = this.parseValue();
+
+    let props      = {};
+    let body       = [];
+    let bindings   = [];
+    let transitions= [];
+    let cond       = null;
+
+    if (this.match(TT.LBRACKET)) {
+      const parsed = this.parseElementBody();
+      props       = parsed.props;
+      body        = parsed.body;
+      bindings    = parsed.bindings;
+      transitions = parsed.transitions;
+      this.consume(TT.RBRACKET, null, `Expected ']' to close element {${tag}}`);
+    }
+
+    return N.element(tag, textValue, props, body, bindings, transitions, cond);
+  }
+
+  parseElementBody() {
+    const props = {}, body = [], bindings = [], transitions = [];
+
+    while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+      const t = this.peek();
+
+      // [..] parent-ref
+      if (t.type === TT.DOTDOT) {
+        const pp = this.parseParentPropInline();
+        if (pp.subBody !== null) props[pp.prop] = { __subBody: pp.subBody };
+        else props[pp.prop] = pp.value;
+        continue;
+      }
+
+      // conditional child: ? signalName {element}
+      if (t.type === TT.QUESTION) {
+        this.advance();
+        const sigName = this.consume(TT.IDENT, null, "Expected signal name after '?'").value;
+        const child   = this.parseElement();
+        child.cond    = sigName;
+        body.push(child);
+        continue;
+      }
+
+      // each block: @each signalName as itemVar (index: indexVar) [ body ]
+      if (t.type === TT.AT_IDENT && t.value === 'each') {
+        body.push(this.parseEachBlock());
+        continue;
+      }
+
+      // slot outlet: @slot name
+      if (t.type === TT.AT_IDENT && t.value === 'slot') {
+        this.advance();
+        const slotName = this.check(TT.IDENT) ? this.advance().value : 'default';
+        body.push(N.slotOutlet(slotName));
+        continue;
+      }
+
+      // child element
+      if (t.type === TT.ELEMENT) { body.push(this.parseElement()); continue; }
+
+      // child @block
+      if (t.type === TT.AT_IDENT) { body.push(this.parseAtBlock()); continue; }
+
+      // bare text node
+      if (t.type === TT.STRING) { body.push(N.textNode(this.advance().value)); continue; }
+
+      // property
+      if (t.type === TT.IDENT) {
+        const key = this.advance().value;
+
+        // one-way binding: prop -> signalName
+        if (this.match(TT.ARROW)) {
+          const sig = this.consume(TT.IDENT, null, "Expected signal name after '->'").value;
+          bindings.push(N.binding(key, sig, false));
+          this.match(TT.COMMA);
+          continue;
+        }
+
+        // two-way binding: prop <-> signalName
+        if (this.match(TT.DARROW)) {
+          const sig = this.consume(TT.IDENT, null, "Expected signal name after '<->'").value;
+          bindings.push(N.binding(key, sig, true));
+          this.match(TT.COMMA);
+          continue;
+        }
+
+        // transition hint: prop ~ transitionName
+        if (this.match(TT.TILDE)) {
+          const tname = this.consume(TT.IDENT, null, "Expected transition name after '~'").value;
+          transitions.push(N.transition(key, tname));
+          this.match(TT.COMMA);
+          continue;
+        }
+
+        if (this.match(TT.EQ)) {
+          props[key] = this.parseValue();
+        } else {
+          props[key] = N.value(true); // boolean flag
+        }
+        this.match(TT.COMMA);
+        continue;
+      }
+
+      // signal ref as prop value: #signal  (shorthand for text binding)
+      if (t.type === TT.HASH) {
+        this.advance();
+        body.push(N.signalRef(t.value));
+        continue;
+      }
+
+      if (t.type === TT.NUMBER) { this.advance(); this.match(TT.COMMA); continue; }
+      if (t.type === TT.COMMA)  { this.advance(); continue; }
+
+      this.error(`Unexpected token '${t.value}' (${t.type}) inside element body`);
+    }
+
+    return { props, body, bindings, transitions };
+  }
+
+  // ── @each signalName as item (index: i) [ body ] ──────────────
+
+  parseEachBlock() {
+    this.advance(); // consume 'each' AT_IDENT
+    const signal  = this.consume(TT.IDENT, null, "Expected signal name after @each").value;
+    // 'as' keyword
+    if (this.check(TT.IDENT, 'as')) this.advance();
+    const itemVar = this.consume(TT.IDENT, null, "Expected item variable after 'as'").value;
+    let indexVar  = null;
+    // optional (index: i)
+    if (this.check(TT.STRING) || (this.check(TT.IDENT, 'index'))) {
+      this.advance(); // skip
+    }
+    // (index: varName)
+    if (this.check(TT.LBRACKET) || this.check(TT.LPAREN)) {
+      // simple: check for index keyword in next ident
+    }
+    this.consume(TT.LBRACKET, null, "Expected '[' after @each header");
+    const body = this.parseBlockList();
+    this.consume(TT.RBRACKET, null, "Expected ']' to close @each block");
+    return N.eachBlock(signal, itemVar, indexVar, body);
+  }
+
+  // ── [..] property ──────────────────────────────────────────────
+
+  parseParentPropInline() {
+    this.advance(); // consume DOTDOT
+    this.consume(TT.COLONCOLON, null, "Expected '::' after '[..]'");
+    const prop = this.consume(TT.IDENT, null, "Expected property name after '::'").value;
+
+    if (this.match(TT.LBRACKET)) {
+      const subBody = [];
+      while (!this.isAtEnd() && !this.check(TT.RBRACKET)) {
+        if (this.check(TT.ELEMENT) || this.check(TT.AT_IDENT) || this.check(TT.DOTDOT)) {
+          subBody.push(this.parseTopNode());
+        } else if (this.check(TT.IDENT)) {
+          const key = this.advance().value;
+          if (this.match(TT.EQ)) {
+            subBody.push(N.cssDecl(key, this.parseValue()));
+          } else {
+            subBody.push(N.cssDecl(key, N.value(true)));
+          }
+          this.match(TT.COMMA);
+        } else if (this.check(TT.COMMA)) {
+          this.advance();
+        } else { break; }
+      }
+      this.consume(TT.RBRACKET, null, `Expected ']' to close [..]::${prop} block`);
+      return N.parentProp(prop, null, subBody);
+    }
+
+    if (this.match(TT.EQ)) return N.parentProp(prop, this.parseValue(), null);
+    return N.parentProp(prop, N.value(true), null);
+  }
+
+  // ── value ──────────────────────────────────────────────────────
+
+  parseValue() {
+    const t = this.peek();
+    if (t.type === TT.PIPE)   return this.parsePipeList();
+    if (t.type === TT.HASH)   { this.advance(); return N.signalRef(t.value); }
+    if (t.type === TT.STRING) { this.advance(); return N.value(t.value); }
+    if (t.type === TT.NUMBER) { this.advance(); return N.value(t.value); }
+    if (t.type === TT.IDENT)  { this.advance(); return N.value(t.value); }
+    this.error(`Expected a value, got '${t.value}' (${t.type})`);
+  }
+
+  parsePipeList() {
+    this.consume(TT.PIPE, null, "Expected '|'");
+    const items = [];
+    while (!this.isAtEnd() && !this.check(TT.PIPE)) {
+      const t = this.peek();
+      if (t.type === TT.IDENT || t.type === TT.STRING) items.push(this.advance().value);
+      this.match(TT.COMMA);
+    }
+    this.consume(TT.PIPE, null, "Expected closing '|'");
+    return N.pipeList(items);
+  }
+}
+
+module.exports = { Parser, ParseError, N };