tova 0.7.0 → 0.9.4

package/src/parser/parser.js

@@ -131,13 +131,15 @@ export class Parser {
   _isContextualKeyword() {
     const t = this.current().type;
     return t === TokenType.ROUTE || t === TokenType.STATE || t === TokenType.COMPUTED ||
-           t === TokenType.EFFECT || t === TokenType.COMPONENT || t === TokenType.STORE;
+           t === TokenType.EFFECT || t === TokenType.COMPONENT || t === TokenType.STORE ||
+           t === TokenType.FORM || t === TokenType.FIELD || t === TokenType.GROUP || t === TokenType.STEPS;
   }
 
   _isContextualKeywordToken(token) {
     const t = token.type;
     return t === TokenType.ROUTE || t === TokenType.STATE || t === TokenType.COMPUTED ||
-           t === TokenType.EFFECT || t === TokenType.COMPONENT || t === TokenType.STORE;
+           t === TokenType.EFFECT || t === TokenType.COMPONENT || t === TokenType.STORE ||
+           t === TokenType.FORM || t === TokenType.FIELD || t === TokenType.GROUP || t === TokenType.STEPS;
   }
 
   _synchronizeBlock() {
@@ -210,6 +212,13 @@ export class Parser {
   // ─── Program ───────────────────────────────────────────────
 
   parse() {
+    // Eagerly install all block-plugin parser extensions so they work inside function bodies
+    for (const plugin of BlockRegistry.all()) {
+      const p = plugin.parser;
+      if (p.install && p.installedFlag && !Parser.prototype[p.installedFlag]) {
+        p.install(Parser);
+      }
+    }
     const body = [];
     const maxErrors = 50; // Stop after 50 errors to avoid cascading noise
     while (!this.isAtEnd()) {
@@ -590,6 +599,12 @@ export class Parser {
     if (this.check(TokenType.PUB)) {
       this.error("Duplicate 'pub' modifier");
     }
+    // Handle pub component at top level (parseComponent is installed by browser-parser plugin)
+    if (this.check(TokenType.COMPONENT) && typeof this.parseComponent === 'function') {
+      const comp = this.parseComponent();
+      comp.isPublic = true;
+      return comp;
+    }
     const stmt = this.parseStatement();
     if (stmt) stmt.isPublic = true;
     return stmt;
@@ -1218,7 +1233,12 @@ export class Parser {
     const elements = [];
 
     while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
-      if (this.check(TokenType.IDENTIFIER) && this.current().value === '_') {
+      if (this.check(TokenType.SPREAD)) {
+        this.advance(); // consume ...
+        const restName = this.expect(TokenType.IDENTIFIER, "Expected identifier after '...'").value;
+        elements.push('...' + restName);
+        break; // rest must be last
+      } else if (this.check(TokenType.IDENTIFIER) && this.current().value === '_') {
         elements.push(null); // skip placeholder
         this.advance();
       } else {
@@ -1476,7 +1496,14 @@ export class Parser {
       // Destructuring without let: {name, age} = user  or  [a, b] = list
       if (expr.type === 'ObjectLiteral') {
         const pattern = new AST.ObjectPattern(
-          expr.properties.map(p => ({ key: typeof p.key === 'string' ? p.key : p.key.name || p.key, value: typeof p.key === 'string' ? p.key : p.key.name || p.key })),
+          expr.properties.map(p => {
+            const key = typeof p.key === 'string' ? p.key : p.key.name || p.key;
+            // For shorthand {name}, key and value are the same
+            // For rename {name: alias}, value is the alias identifier
+            const val = p.shorthand ? key
+              : (p.value && p.value.type === 'Identifier' ? p.value.name : key);
+            return { key, value: val };
+          }),
           expr.loc
         );
         const value = this.parseExpression();
@@ -1484,7 +1511,13 @@ export class Parser {
       }
       if (expr.type === 'ArrayLiteral') {
         const pattern = new AST.ArrayPattern(
-          expr.elements.map(e => e.type === 'Identifier' ? e.name : '_'),
+          expr.elements.map(e => {
+            if (e.type === 'Identifier') return e.name;
+            if (e.type === 'SpreadExpression' && e.argument && e.argument.type === 'Identifier') {
+              return '...' + e.argument.name;
+            }
+            return '_';
+          }),
           expr.loc
         );
         const value = this.parseExpression();
@@ -2003,6 +2036,10 @@ export class Parser {
       case TokenType.BROWSER:
       case TokenType.SHARED:
       case TokenType.DERIVE:
+      case TokenType.FORM:
+      case TokenType.FIELD:
+      case TokenType.GROUP:
+      case TokenType.STEPS:
         return new AST.Identifier(this.advance().value, l);
 
       case TokenType.IDENTIFIER: {

package/src/parser/select-ast.js

@@ -0,0 +1,39 @@
+// Select-specific AST Node definitions for the Tova language
+// Extracted for lazy loading -- only loaded when select { } blocks are used.
+
+/**
+ * select {
+ *   msg from ch => { ... }
+ *   ch.send(val) => { ... }
+ *   timeout(5000) => { ... }
+ *   _ => { ... }
+ * }
+ */
+export class SelectStatement {
+  constructor(cases, loc) {
+    this.type = 'SelectStatement';
+    this.cases = cases;   // Array of SelectCase
+    this.loc = loc;
+  }
+}
+
+/**
+ * A single case arm inside a select block.
+ *
+ * kind: "receive" | "send" | "timeout" | "default"
+ * channel: Expression | null   (identifier for the channel; null for timeout/default)
+ * binding: string | null        (variable name bound on receive; null otherwise)
+ * value: Expression | null      (value to send, or timeout duration; null for receive/default)
+ * body: [Statement]             (statements executed when this case fires)
+ */
+export class SelectCase {
+  constructor(kind, channel, binding, value, body, loc) {
+    this.type = 'SelectCase';
+    this.kind = kind;        // "receive" | "send" | "timeout" | "default"
+    this.channel = channel;  // Expression | null
+    this.binding = binding;  // string | null
+    this.value = value;      // Expression | null
+    this.body = body;        // [Statement]
+    this.loc = loc;
+  }
+}

package/src/parser/theme-ast.js

@@ -0,0 +1,29 @@
+// Theme-specific AST Node definitions for the Tova language
+// Extracted for lazy loading — only loaded when theme { } blocks are used.
+
+export class ThemeBlock {
+  constructor(sections, darkOverrides, loc) {
+    this.type = 'ThemeBlock';
+    this.sections = sections;           // Array of ThemeSection
+    this.darkOverrides = darkOverrides; // Array of ThemeToken (flat dark mode overrides)
+    this.loc = loc;
+  }
+}
+
+export class ThemeSection {
+  constructor(name, tokens, loc) {
+    this.type = 'ThemeSection';
+    this.name = name;       // string — section name, e.g. "colors", "spacing", "font"
+    this.tokens = tokens;   // Array of ThemeToken
+    this.loc = loc;
+  }
+}
+
+export class ThemeToken {
+  constructor(name, value, loc) {
+    this.type = 'ThemeToken';
+    this.name = name;   // string — dot-separated name, e.g. "primary.hover"
+    this.value = value;  // string or number — token value
+    this.loc = loc;
+  }
+}

package/src/parser/theme-parser.js

@@ -0,0 +1,70 @@
+// Theme-specific parser methods for the Tova language
+// Extracted from parser.js for lazy loading — only loaded when theme { } blocks are encountered.
+
+import { TokenType } from '../lexer/tokens.js';
+import { ThemeBlock, ThemeSection, ThemeToken } from './theme-ast.js';
+
+export function installThemeParser(ParserClass) {
+  if (ParserClass.prototype._themeParserInstalled) return;
+  ParserClass.prototype._themeParserInstalled = true;
+
+  ParserClass.prototype.parseThemeBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'theme'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'theme'");
+
+    const sections = [];
+    const darkOverrides = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const sectionLoc = this.loc();
+      const sectionName = this.expect(TokenType.IDENTIFIER, "Expected section name inside theme block").value;
+      this.expect(TokenType.LBRACE, `Expected '{' after theme section '${sectionName}'`);
+
+      if (sectionName === 'dark') {
+        // dark section: flat overrides with dot-notation names
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+          darkOverrides.push(this._parseThemeToken());
+        }
+      } else {
+        // Regular section: parse tokens into a ThemeSection
+        const tokens = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+          tokens.push(this._parseThemeToken());
+        }
+        sections.push(new ThemeSection(sectionName, tokens, sectionLoc));
+      }
+
+      this.expect(TokenType.RBRACE, `Expected '}' to close theme section '${sectionName}'`);
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close theme block");
+    return new ThemeBlock(sections, darkOverrides, l);
+  };
+
+  ParserClass.prototype._parseThemeToken = function() {
+    const l = this.loc();
+
+    // Read dot-separated name: IDENTIFIER (DOT IDENTIFIER)*
+    let name = this.expect(TokenType.IDENTIFIER, "Expected token name").value;
+    while (this.check(TokenType.DOT)) {
+      this.advance(); // consume DOT
+      const part = this.expect(TokenType.IDENTIFIER, "Expected identifier after '.' in token name").value;
+      name += '.' + part;
+    }
+
+    this.expect(TokenType.COLON, `Expected ':' after token name '${name}'`);
+
+    // Read value: STRING or NUMBER
+    let value;
+    if (this.check(TokenType.STRING)) {
+      value = this.advance().value;
+    } else if (this.check(TokenType.NUMBER)) {
+      value = this.advance().value;
+    } else {
+      this.error(`Expected string or number value for token '${name}'`);
+    }
+
+    return new ThemeToken(name, value, l);
+  };
+}

package/src/registry/plugins/concurrency-plugin.js

@@ -0,0 +1,32 @@
+import { TokenType } from '../../lexer/tokens.js';
+import { installConcurrencyParser } from '../../parser/concurrency-parser.js';
+
+export const concurrencyPlugin = {
+  name: 'concurrency',
+  astNodeType: 'ConcurrentBlock',
+  detection: {
+    strategy: 'identifier',
+    identifierValue: 'concurrent',
+    lookahead: (parser) => {
+      const next = parser.peek(1);
+      // concurrent {} or concurrent mode {}
+      return next.type === TokenType.LBRACE ||
+             (next.type === TokenType.IDENTIFIER &&
+              ['cancel_on_error', 'first', 'timeout'].includes(next.value));
+    },
+  },
+  parser: {
+    install: installConcurrencyParser,
+    installedFlag: '_concurrencyParserInstalled',
+    method: 'parseConcurrentBlock',
+  },
+  analyzer: {
+    visit: (analyzer, node) => {
+      if (node.type === 'SelectStatement') return analyzer.visitSelectStatement(node);
+      return analyzer.visitConcurrentBlock(node);
+    },
+    childNodeTypes: ['SelectStatement'],
+    noopNodeTypes: ['SpawnExpression', 'SelectCase'],
+  },
+  codegen: {},
+};

package/src/registry/plugins/deploy-plugin.js

@@ -0,0 +1,33 @@
+import { installDeployParser } from '../../parser/deploy-parser.js';
+import { installDeployAnalyzer } from '../../analyzer/deploy-analyzer.js';
+import { TokenType } from '../../lexer/tokens.js';
+
+export const deployPlugin = {
+  name: 'deploy',
+  astNodeType: 'DeployBlock',
+  detection: {
+    strategy: 'identifier',
+    identifierValue: 'deploy',
+    lookahead: (parser) => {
+      const next = parser.peek(1);
+      // deploy "name" {} — name is required
+      return next.type === TokenType.STRING;
+    },
+  },
+  parser: {
+    install: installDeployParser,
+    installedFlag: '_deployParserInstalled',
+    method: 'parseDeployBlock',
+  },
+  analyzer: {
+    visit: (analyzer, node) => {
+      installDeployAnalyzer(analyzer.constructor);
+      analyzer.visitDeployBlock(node);
+    },
+    childNodeTypes: [],
+    noopNodeTypes: [
+      'DeployConfigField', 'DeployEnvBlock', 'DeployDbBlock',
+    ],
+  },
+  codegen: {},
+};

package/src/registry/plugins/theme-plugin.js

@@ -0,0 +1,20 @@
+import { installThemeParser } from '../../parser/theme-parser.js';
+
+export const themePlugin = {
+  name: 'theme',
+  astNodeType: 'ThemeBlock',
+  detection: {
+    strategy: 'identifier',
+    identifierValue: 'theme',
+  },
+  parser: {
+    install: installThemeParser,
+    installedFlag: '_themeParserInstalled',
+    method: 'parseThemeBlock',
+  },
+  analyzer: {
+    visit: (analyzer, node) => analyzer.visitThemeBlock(node),
+    noopNodeTypes: ['ThemeSection', 'ThemeToken'],
+  },
+  codegen: {},
+};

package/src/registry/register-all.js

@@ -11,7 +11,11 @@ import { dataPlugin } from './plugins/data-plugin.js';
 import { testPlugin } from './plugins/test-plugin.js';
 import { benchPlugin } from './plugins/bench-plugin.js';
 import { edgePlugin } from './plugins/edge-plugin.js';
+import { concurrencyPlugin } from './plugins/concurrency-plugin.js';
+import { deployPlugin } from './plugins/deploy-plugin.js';
+import { themePlugin } from './plugins/theme-plugin.js';
 
+BlockRegistry.register(themePlugin);
 BlockRegistry.register(serverPlugin);
 BlockRegistry.register(browserPlugin);
 BlockRegistry.register(sharedPlugin);
@@ -21,5 +25,7 @@ BlockRegistry.register(dataPlugin);
 BlockRegistry.register(testPlugin);
 BlockRegistry.register(benchPlugin);
 BlockRegistry.register(edgePlugin);
+BlockRegistry.register(concurrencyPlugin);
+BlockRegistry.register(deployPlugin);
 
 export { BlockRegistry };