tova 0.9.13 → 0.9.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tova",
-  "version": "0.9.13",
+  "version": "0.9.15",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",

package/src/analyzer/type-registry.js

@@ -88,4 +88,168 @@ export class TypeRegistry {
     }
     return [];
   }
+
+  /**
+   * Extract the base type name from a composite type string.
+   * "[Int]" → "Array", "Result<Int, String>" → "Result", "Option<String>" → "Option", "String" → "String"
+   */
+  static extractBaseType(typeName) {
+    if (!typeName) return null;
+    if (typeName.startsWith('[') && typeName.endsWith(']')) return 'Array';
+    if (typeName.startsWith('Result<') || typeName === 'Result') return 'Result';
+    if (typeName.startsWith('Option<') || typeName === 'Option') return 'Option';
+    if (typeName.startsWith('Map<') || typeName === 'Map') return 'Map';
+    if (typeName.startsWith('Set<') || typeName === 'Set') return 'Set';
+    return typeName;
+  }
+
+  /**
+   * Get built-in members (fields + methods) for a built-in type.
+   * Returns { fields: Map, methods: [] } or null if not a built-in type.
+   */
+  getBuiltinMembers(typeName) {
+    const base = TypeRegistry.extractBaseType(typeName);
+    const descriptors = TypeRegistry.BUILTIN_MEMBERS[base];
+    if (!descriptors) return null;
+
+    const fields = new Map();
+    const methods = [];
+    for (const d of descriptors) {
+      if (d.kind === 'field') {
+        fields.set(d.name, d.returnType);
+      } else {
+        methods.push(d);
+      }
+    }
+    return { fields, methods };
+  }
+}
+
+// ─── Built-in type member descriptors ──────────────────────────
+
+function field(name, returnType, doc) {
+  return { kind: 'field', name, returnType, doc };
 }
+
+function method(name, params, returnType, doc) {
+  return { kind: 'method', name, params, returnType, doc };
+}
+
+TypeRegistry.BUILTIN_MEMBERS = {
+  String: [
+    field('length', 'Int', 'Number of characters'),
+    method('slice', ['start: Int', 'end?: Int'], 'String', 'Extract a section of the string'),
+    method('includes', ['search: String'], 'Bool', 'Check if string contains substring'),
+    method('indexOf', ['search: String'], 'Int', 'First index of substring, or -1'),
+    method('lastIndexOf', ['search: String'], 'Int', 'Last index of substring, or -1'),
+    method('startsWith', ['prefix: String'], 'Bool', 'Check if string starts with prefix'),
+    method('endsWith', ['suffix: String'], 'Bool', 'Check if string ends with suffix'),
+    method('trim', [], 'String', 'Remove whitespace from both ends'),
+    method('trimStart', [], 'String', 'Remove whitespace from start'),
+    method('trimEnd', [], 'String', 'Remove whitespace from end'),
+    method('toUpperCase', [], 'String', 'Convert to uppercase'),
+    method('toLowerCase', [], 'String', 'Convert to lowercase'),
+    method('split', ['separator: String'], '[String]', 'Split into array of substrings'),
+    method('replace', ['search: String', 'replacement: String'], 'String', 'Replace first occurrence'),
+    method('replaceAll', ['search: String', 'replacement: String'], 'String', 'Replace all occurrences'),
+    method('repeat', ['count: Int'], 'String', 'Repeat the string n times'),
+    method('charAt', ['index: Int'], 'String', 'Character at index'),
+    method('charCodeAt', ['index: Int'], 'Int', 'Character code at index'),
+    method('concat', ['other: String'], 'String', 'Concatenate strings'),
+    method('padStart', ['length: Int', 'fill?: String'], 'String', 'Pad from start to length'),
+    method('padEnd', ['length: Int', 'fill?: String'], 'String', 'Pad from end to length'),
+    method('match', ['pattern: String'], 'Option', 'Match against regex pattern'),
+    method('search', ['pattern: String'], 'Int', 'Search for regex pattern'),
+    method('toString', [], 'String', 'Convert to string'),
+    method('substring', ['start: Int', 'end?: Int'], 'String', 'Extract characters between indices'),
+    method('at', ['index: Int'], 'String', 'Character at index (supports negative)'),
+  ],
+  Array: [
+    field('length', 'Int', 'Number of elements'),
+    method('push', ['item: T'], 'Int', 'Add element to end, returns new length'),
+    method('pop', [], 'T', 'Remove and return last element'),
+    method('shift', [], 'T', 'Remove and return first element'),
+    method('unshift', ['item: T'], 'Int', 'Add element to start, returns new length'),
+    method('splice', ['start: Int', 'deleteCount?: Int'], '[T]', 'Remove/replace elements'),
+    method('slice', ['start?: Int', 'end?: Int'], '[T]', 'Extract a section of the array'),
+    method('concat', ['other: [T]'], '[T]', 'Merge arrays'),
+    method('join', ['separator?: String'], 'String', 'Join elements into string'),
+    method('reverse', [], '[T]', 'Reverse array in place'),
+    method('sort', ['compareFn?: fn(T, T) -> Int'], '[T]', 'Sort array in place'),
+    method('map', ['fn: fn(T) -> U'], '[U]', 'Transform each element'),
+    method('filter', ['fn: fn(T) -> Bool'], '[T]', 'Keep elements matching predicate'),
+    method('reduce', ['fn: fn(acc, T) -> U', 'initial: U'], 'U', 'Reduce to single value'),
+    method('find', ['fn: fn(T) -> Bool'], 'Option', 'Find first matching element'),
+    method('findIndex', ['fn: fn(T) -> Bool'], 'Int', 'Index of first match, or -1'),
+    method('some', ['fn: fn(T) -> Bool'], 'Bool', 'Check if any element matches'),
+    method('every', ['fn: fn(T) -> Bool'], 'Bool', 'Check if all elements match'),
+    method('includes', ['item: T'], 'Bool', 'Check if array contains element'),
+    method('indexOf', ['item: T'], 'Int', 'First index of element, or -1'),
+    method('flat', [], '[T]', 'Flatten one level of nesting'),
+    method('flatMap', ['fn: fn(T) -> [U]'], '[U]', 'Map then flatten'),
+    method('fill', ['value: T', 'start?: Int', 'end?: Int'], '[T]', 'Fill with value'),
+    method('forEach', ['fn: fn(T) -> Nil'], 'Nil', 'Execute function for each element'),
+    method('at', ['index: Int'], 'T', 'Element at index (supports negative)'),
+  ],
+  Result: [
+    method('map', ['fn: fn(T) -> U'], 'Result', 'Transform Ok value'),
+    method('flatMap', ['fn: fn(T) -> Result'], 'Result', 'Chain Result-returning function'),
+    method('andThen', ['fn: fn(T) -> Result'], 'Result', 'Alias for flatMap'),
+    method('unwrap', [], 'T', 'Get Ok value or throw on Err'),
+    method('unwrapOr', ['default: T'], 'T', 'Get Ok value or return default'),
+    method('expect', ['msg: String'], 'T', 'Get Ok value or throw with message'),
+    method('isOk', [], 'Bool', 'Check if Result is Ok'),
+    method('isErr', [], 'Bool', 'Check if Result is Err'),
+    method('mapErr', ['fn: fn(E) -> F'], 'Result', 'Transform Err value'),
+    method('unwrapErr', [], 'E', 'Get Err value or throw on Ok'),
+    method('or', ['other: Result'], 'Result', 'Return self if Ok, otherwise other'),
+    method('and', ['other: Result'], 'Result', 'Return other if Ok, otherwise self'),
+    method('context', ['msg: String'], 'Result', 'Add context to Err'),
+  ],
+  Option: [
+    method('map', ['fn: fn(T) -> U'], 'Option', 'Transform Some value'),
+    method('flatMap', ['fn: fn(T) -> Option'], 'Option', 'Chain Option-returning function'),
+    method('andThen', ['fn: fn(T) -> Option'], 'Option', 'Alias for flatMap'),
+    method('unwrap', [], 'T', 'Get Some value or throw on None'),
+    method('unwrapOr', ['default: T'], 'T', 'Get Some value or return default'),
+    method('expect', ['msg: String'], 'T', 'Get Some value or throw with message'),
+    method('isSome', [], 'Bool', 'Check if Option is Some'),
+    method('isNone', [], 'Bool', 'Check if Option is None'),
+    method('or', ['other: Option'], 'Option', 'Return self if Some, otherwise other'),
+    method('and', ['other: Option'], 'Option', 'Return other if Some, otherwise self'),
+    method('filter', ['fn: fn(T) -> Bool'], 'Option', 'Keep Some if predicate matches'),
+  ],
+  Map: [
+    field('size', 'Int', 'Number of key-value pairs'),
+    method('get', ['key: K'], 'V', 'Get value by key'),
+    method('set', ['key: K', 'value: V'], 'Map', 'Set key-value pair'),
+    method('has', ['key: K'], 'Bool', 'Check if key exists'),
+    method('delete', ['key: K'], 'Bool', 'Remove key-value pair'),
+    method('clear', [], 'Nil', 'Remove all entries'),
+    method('keys', [], '[K]', 'Get all keys'),
+    method('values', [], '[V]', 'Get all values'),
+    method('entries', [], '[(K, V)]', 'Get all key-value pairs'),
+    method('forEach', ['fn: fn(V, K) -> Nil'], 'Nil', 'Execute function for each entry'),
+  ],
+  Set: [
+    field('size', 'Int', 'Number of elements'),
+    method('add', ['value: T'], 'Set', 'Add element'),
+    method('has', ['value: T'], 'Bool', 'Check if element exists'),
+    method('delete', ['value: T'], 'Bool', 'Remove element'),
+    method('clear', [], 'Nil', 'Remove all elements'),
+    method('keys', [], '[T]', 'Get all values (alias)'),
+    method('values', [], '[T]', 'Get all values'),
+    method('entries', [], '[(T, T)]', 'Get all value-value pairs'),
+    method('forEach', ['fn: fn(T) -> Nil'], 'Nil', 'Execute function for each element'),
+  ],
+  Int: [
+    method('toString', [], 'String', 'Convert to string'),
+    method('toFixed', ['digits?: Int'], 'String', 'Format with fixed decimal places'),
+    method('toPrecision', ['precision?: Int'], 'String', 'Format to specified precision'),
+  ],
+  Float: [
+    method('toString', [], 'String', 'Convert to string'),
+    method('toFixed', ['digits?: Int'], 'String', 'Format with fixed decimal places'),
+    method('toPrecision', ['precision?: Int'], 'String', 'Format to specified precision'),
+  ],
+};

package/src/codegen/codegen.js

@@ -2,57 +2,26 @@
 // Supports named multi-blocks: server "api" { }, server "ws" { }
 // Blocks with the same name are merged; different names produce separate output files.
 
-import { createRequire } from 'module';
 import { SharedCodegen } from './shared-codegen.js';
 import { BUILTIN_NAMES } from '../stdlib/inline.js';
 import { BlockRegistry } from '../registry/register-all.js';
-
-// Lazy-load domain-specific codegens so pure scripts don't pay for them
-const _require = createRequire(import.meta.url);
-let _ServerCodegen, _BrowserCodegen, _SecurityCodegen, _CliCodegen, _EdgeCodegen;
-
-function getServerCodegen() {
-  if (!_ServerCodegen) _ServerCodegen = _require('./server-codegen.js').ServerCodegen;
-  return _ServerCodegen;
-}
-
-function getBrowserCodegen() {
-  if (!_BrowserCodegen) _BrowserCodegen = _require('./browser-codegen.js').BrowserCodegen;
-  return _BrowserCodegen;
-}
-
-function getSecurityCodegen() {
-  if (!_SecurityCodegen) _SecurityCodegen = _require('./security-codegen.js').SecurityCodegen;
-  return _SecurityCodegen;
-}
-
-function getCliCodegen() {
-  if (!_CliCodegen) _CliCodegen = _require('./cli-codegen.js').CliCodegen;
-  return _CliCodegen;
-}
-
-function getEdgeCodegen() {
-  if (!_EdgeCodegen) _EdgeCodegen = _require('./edge-codegen.js').EdgeCodegen;
-  return _EdgeCodegen;
-}
-
-let _DeployCodegen;
-function getDeployCodegen() {
-  if (!_DeployCodegen) _DeployCodegen = _require('./deploy-codegen.js').DeployCodegen;
-  return _DeployCodegen;
-}
-
-let _ThemeCodegen;
-function getThemeCodegen() {
-  if (!_ThemeCodegen) _ThemeCodegen = _require('./theme-codegen.js').ThemeCodegen;
-  return _ThemeCodegen;
-}
-
-let _AuthCodegen;
-function getAuthCodegen() {
-  if (!_AuthCodegen) _AuthCodegen = _require('./auth-codegen.js').AuthCodegen;
-  return _AuthCodegen;
-}
+import { ServerCodegen } from './server-codegen.js';
+import { BrowserCodegen } from './browser-codegen.js';
+import { SecurityCodegen } from './security-codegen.js';
+import { CliCodegen } from './cli-codegen.js';
+import { EdgeCodegen } from './edge-codegen.js';
+import { DeployCodegen } from './deploy-codegen.js';
+import { ThemeCodegen } from './theme-codegen.js';
+import { AuthCodegen } from './auth-codegen.js';
+
+function getServerCodegen() { return ServerCodegen; }
+function getBrowserCodegen() { return BrowserCodegen; }
+function getSecurityCodegen() { return SecurityCodegen; }
+function getCliCodegen() { return CliCodegen; }
+function getEdgeCodegen() { return EdgeCodegen; }
+function getDeployCodegen() { return DeployCodegen; }
+function getThemeCodegen() { return ThemeCodegen; }
+function getAuthCodegen() { return AuthCodegen; }
 
 export class CodeGenerator {
   constructor(ast, filename = '<stdin>', options = {}) {

package/src/codegen/edge-codegen.js

@@ -1,11 +1,8 @@
 // Edge/serverless code generator for the Tova language
 // Produces deployment-ready code for Cloudflare Workers, Deno Deploy, Vercel Edge, AWS Lambda, or Bun.
 
-import { createRequire } from 'module';
 import { BaseCodegen } from './base-codegen.js';
-
-const _require = createRequire(import.meta.url);
-let _SecurityCodegen;
+import { SecurityCodegen as _SecurityCodegen } from './security-codegen.js';
 
 const DEFAULT_TARGET = 'cloudflare';
 
@@ -295,7 +292,6 @@ export class EdgeCodegen extends BaseCodegen {
     const noSec = { hasAuth: false, hasProtect: false, hasAutoSanitize: false };
     if (!securityConfig) return noSec;
 
-    if (!_SecurityCodegen) _SecurityCodegen = _require('./security-codegen.js').SecurityCodegen;
     const secGen = new _SecurityCodegen();
     const fragments = secGen.generateServerSecurity(securityConfig);
 

package/src/lsp/server.js

@@ -629,6 +629,36 @@ class TovaLanguageServer {
             });
           }
         }
+
+        // Fall back to built-in type members if no user-defined members found
+        if (items.length === 0) {
+          const builtin = typeRegistry.getBuiltinMembers(typeName);
+          if (builtin) {
+            for (const [fieldName, fieldType] of builtin.fields) {
+              if (!partial || fieldName.startsWith(partial)) {
+                items.push({
+                  label: fieldName,
+                  kind: 5, // Field
+                  detail: fieldType || 'field',
+                  sortText: `0${fieldName}`,
+                });
+              }
+            }
+            for (const m of builtin.methods) {
+              if (!partial || m.name.startsWith(partial)) {
+                const paramStr = (m.params || []).join(', ');
+                const retStr = m.returnType ? ` -> ${m.returnType}` : '';
+                items.push({
+                  label: m.name,
+                  kind: 2, // Method
+                  detail: `fn(${paramStr})${retStr}`,
+                  documentation: m.doc,
+                  sortText: `1${m.name}`,
+                });
+              }
+            }
+          }
+        }
       }
     }
 

package/src/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-runtime.js — do not edit
-export const VERSION = "0.9.13";
+export const VERSION = "0.9.15";