tova 0.11.20 → 0.11.22

package/package.json

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

package/src/analyzer/analyzer.js

@@ -168,9 +168,11 @@ export class Analyzer {
       // Async
       'sleep',
       // String functions
-      'upper', 'lower', 'contains', 'starts_with', 'ends_with',
-      'chars', 'words', 'lines', 'capitalize', 'title_case',
-      'snake_case', 'camel_case',
+      'upper', 'lower', 'contains', 'startsWith', 'endsWith',
+      'starts_with', 'ends_with',
+      'chars', 'words', 'lines', 'capitalize', 'titleCase',
+      'snakeCase', 'camelCase',
+      'title_case', 'snake_case', 'camel_case',
       // Math extras
       'min', 'max',
       // Table operations

package/src/cli/run.js

@@ -1,11 +1,54 @@
 import { resolve, dirname, join } from 'path';
 import { readFileSync, existsSync } from 'fs';
 import { createRequire as _createRequire } from 'module';
+import { pathToFileURL } from 'url';
 import { compileTova } from './compile.js';
 import { getRunStdlib } from './utils.js';
 import { resolveConfig } from '../config/resolve.js';
 import { richError } from '../diagnostics/formatter.js';
 
+ function findLocalTovaImports(source, fromFile) {
+  const importDetectRegex = /import\s+(?:\{[^}]*\}|[\w$]+|\*\s+as\s+[\w$]+)\s+from\s+['"]([^'"]+)['"]/gm;
+  let importMatch;
+  const tovaImportPaths = [];
+  while ((importMatch = importDetectRegex.exec(source)) !== null) {
+    const importSource = importMatch[1];
+    if (!importSource.startsWith('.') && !importSource.startsWith('/')) continue;
+    let depPath = resolve(dirname(fromFile), importSource);
+    if (!depPath.endsWith('.tova') && existsSync(depPath + '.tova')) {
+      depPath = depPath + '.tova';
+    }
+    if (depPath.endsWith('.tova') && existsSync(depPath)) {
+      tovaImportPaths.push({ source: importSource, resolved: depPath });
+    }
+  }
+  return tovaImportPaths;
+ }
+
+ function stripInlinedImports(code, importSources) {
+  let stripped = code;
+  for (const importSource of importSources) {
+    const escaped = importSource.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    stripped = stripped.replace(new RegExp('^import\\s+(?:\\{[^}]*\\}|[\\w$]+|\\*\\s+as\\s+[\\w$]+)\\s+from\\s+[\'\"]' + escaped + '[\'\"];?\\s*$', 'gm'), '');
+  }
+  return stripped;
+ }
+
+ function rewriteImportsForRuntime(code, baseFileUrl) {
+  return code.replace(/^import\s+(\{[^}]*\}|[\w$]+|\*\s+as\s+[\w$]+)\s+from\s+['"]([^'"]+)['"];?\s*$/gm, (match, clause, source) => {
+    const importExpr = source.startsWith('.') || source.startsWith('/')
+      ? `await import(new URL(${JSON.stringify(source)}, ${JSON.stringify(baseFileUrl)}).href)`
+      : `await import(${JSON.stringify(source)})`;
+    if (clause.startsWith('{')) {
+      return `const ${clause.replace(/\bas\b/g, ':')} = ${importExpr};`;
+    }
+    if (clause.startsWith('*')) {
+      return `const ${clause.replace(/^\*\s+as\s+/, '').trim()} = ${importExpr};`;
+    }
+    return `const { default: ${clause.trim()} } = ${importExpr};`;
+  });
+ }
+
 export async function runFile(filePath, options = {}) {
   if (!filePath) {
     // If tova.toml exists, try to find a main file in the entry directory
@@ -34,26 +77,13 @@ export async function runFile(filePath, options = {}) {
   }
 
   const source = readFileSync(resolved, 'utf-8');
+  const fileUrl = pathToFileURL(resolved).href;
 
   try {
-    // Detect local .tova imports (with or without .tova extension)
-    const importDetectRegex = /import\s+(?:\{[^}]*\}|[\w$]+|\*\s+as\s+[\w$]+)\s+from\s+['"]([^'"]+)['"]/gm;
-    let importMatch;
-    const tovaImportPaths = [];
-    while ((importMatch = importDetectRegex.exec(source)) !== null) {
-      const importSource = importMatch[1];
-      if (!importSource.startsWith('.') && !importSource.startsWith('/')) continue;
-      let depPath = resolve(dirname(resolved), importSource);
-      if (!depPath.endsWith('.tova') && existsSync(depPath + '.tova')) {
-        depPath = depPath + '.tova';
-      }
-      if (depPath.endsWith('.tova') && existsSync(depPath)) {
-        tovaImportPaths.push({ source: importSource, resolved: depPath });
-      }
-    }
+    const tovaImportPaths = findLocalTovaImports(source, resolved);
     const hasTovaImports = tovaImportPaths.length > 0;
 
-    const output = compileTova(source, filePath, { strict: options.strict, strictSecurity: options.strictSecurity });
+    const output = compileTova(source, resolved, { strict: options.strict, strictSecurity: options.strictSecurity });
 
     // Execute the generated JavaScript (with stdlib)
     const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
@@ -81,26 +111,18 @@ export async function runFile(filePath, options = {}) {
         compiled.add(filePath);
 
         const depSource = readFileSync(filePath, 'utf-8');
+        const depImportPaths = findLocalTovaImports(depSource, filePath);
 
-        // Scan for transitive .tova imports
-        const transitiveRegex = /import\s+(?:\{[^}]*\}|[\w$]+|\*\s+as\s+[\w$]+)\s+from\s+['"]([^'"]+)['"]/g;
-        let transitiveMatch;
-        while ((transitiveMatch = transitiveRegex.exec(depSource)) !== null) {
-          const importSource = transitiveMatch[1];
-          if (!importSource.startsWith('.') && !importSource.startsWith('/')) continue;
-          let transitivePath = resolve(dirname(filePath), importSource);
-          if (!transitivePath.endsWith('.tova') && existsSync(transitivePath + '.tova')) {
-            transitivePath = transitivePath + '.tova';
-          }
-          if (transitivePath.endsWith('.tova') && existsSync(transitivePath)) {
-            resolveTovaImportsRecursive(transitivePath);
-          }
+        for (const depImport of depImportPaths) {
+          resolveTovaImportsRecursive(depImport.resolved);
         }
 
         // Compile this dependency
         const dep = compileTova(depSource, filePath, { strict: options.strict });
         let depShared = dep.shared || '';
         depShared = depShared.replace(/^export /gm, '');
+        depShared = stripInlinedImports(depShared, depImportPaths.map(imp => imp.source));
+        depShared = rewriteImportsForRuntime(depShared, pathToFileURL(filePath).href);
         depCode += depShared + '\n';
       };
 
@@ -112,14 +134,8 @@ export async function runFile(filePath, options = {}) {
     let code = stdlib + '\n' + depCode + (output.shared || '') + '\n' + (output.server || output.browser || '');
     // Strip 'export ' keywords — not valid inside AsyncFunction (used in tova build only)
     code = code.replace(/^export /gm, '');
-    // Strip import lines for local modules (already inlined above)
-    code = code.replace(/^import\s+(?:\{[^}]*\}|[\w$]+|\*\s+as\s+[\w$]+)\s+from\s+['"][^'"]*\.(?:tova|(?:shared\.)?js)['"];?\s*$/gm, '');
-    if (hasTovaImports) {
-      for (const imp of tovaImportPaths) {
-        const escaped = imp.source.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        code = code.replace(new RegExp('^import\\s+(?:\\{[^}]*\\}|[\\w$]+|\\*\\s+as\\s+[\\w$]+)\\s+from\\s+[\'"]' + escaped + '[\'"];?\\s*$', 'gm'), '');
-      }
-    }
+    code = stripInlinedImports(code, tovaImportPaths.map(imp => imp.source));
+    code = rewriteImportsForRuntime(code, fileUrl);
     // Auto-call main() if the compiled code defines a main function
     const scriptArgs = options.scriptArgs || [];
     if (/\bfunction\s+main\s*\(/.test(code)) {

package/src/lsp/server.js

@@ -872,18 +872,26 @@ class TovaLanguageServer {
       'upper': '`fn upper(s) -> String` — Convert to uppercase',
       'lower': '`fn lower(s) -> String` — Convert to lowercase',
       'contains': '`fn contains(s, sub) -> Bool` — Check if string contains substring',
-      'starts_with': '`fn starts_with(s, prefix) -> Bool` — Check if string starts with prefix',
-      'ends_with': '`fn ends_with(s, suffix) -> Bool` — Check if string ends with suffix',
+      'startsWith': '`fn startsWith(s, prefix) -> Bool` — Check if string starts with prefix',
+      'starts_with': '`fn startsWith(s, prefix) -> Bool` — Check if string starts with prefix',
+      'endsWith': '`fn endsWith(s, suffix) -> Bool` — Check if string ends with suffix',
+      'ends_with': '`fn endsWith(s, suffix) -> Bool` — Check if string ends with suffix',
       'chars': '`fn chars(s) -> [String]` — Split string into individual characters',
       'words': '`fn words(s) -> [String]` — Split by whitespace',
       'lines': '`fn lines(s) -> [String]` — Split by newlines',
       'capitalize': '`fn capitalize(s) -> String` — Capitalize first letter',
-      'title_case': '`fn title_case(s) -> String` — Capitalize each word',
-      'snake_case': '`fn snake_case(s) -> String` — Convert to snake_case',
-      'camel_case': '`fn camel_case(s) -> String` — Convert to camelCase',
-      'kebab_case': '`fn kebab_case(s) -> String` — Convert to kebab-case',
-      'pad_start': '`fn pad_start(s, n, fill?) -> String` — Pad start to length n',
-      'pad_end': '`fn pad_end(s, n, fill?) -> String` — Pad end to length n',
+      'titleCase': '`fn titleCase(s) -> String` — Capitalize each word',
+      'title_case': '`fn titleCase(s) -> String` — Capitalize each word',
+      'snakeCase': '`fn snakeCase(s) -> String` — Convert to snake_case',
+      'snake_case': '`fn snakeCase(s) -> String` — Convert to snake_case',
+      'camelCase': '`fn camelCase(s) -> String` — Convert to camelCase',
+      'camel_case': '`fn camelCase(s) -> String` — Convert to camelCase',
+      'kebabCase': '`fn kebabCase(s) -> String` — Convert to kebab-case',
+      'kebab_case': '`fn kebabCase(s) -> String` — Convert to kebab-case',
+      'padStart': '`fn padStart(s, n, fill?) -> String` — Pad start to length n',
+      'pad_start': '`fn padStart(s, n, fill?) -> String` — Pad start to length n',
+      'padEnd': '`fn padEnd(s, n, fill?) -> String` — Pad end to length n',
+      'pad_end': '`fn padEnd(s, n, fill?) -> String` — Pad end to length n',
       'char_at': '`fn char_at(s, i) -> String?` — Character at index (nil if out of bounds)',
       'index_of': '`fn index_of(s, sub) -> Int?` — Index of first occurrence (nil if not found)',
       'last_index_of': '`fn last_index_of(s, sub) -> Int?` — Index of last occurrence',

package/src/runtime/string-proto.js

@@ -11,8 +11,11 @@ const methods = {
   words()       { return this.split(/\s+/).filter(Boolean); },
   lines()       { return this.split('\n'); },
   capitalize()  { return this.length ? this.charAt(0).toUpperCase() + this.slice(1) : this; },
+  titleCase()   { return this.replace(/\b\w/g, c => c.toUpperCase()); },
   title_case()  { return this.replace(/\b\w/g, c => c.toUpperCase()); },
+  snakeCase()   { return this.replace(/[-\s]+/g, '_').replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase().replace(/^_/, ''); },
   snake_case()  { return this.replace(/[-\s]+/g, '_').replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase().replace(/^_/, ''); },
+  camelCase()   { return this.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : '').replace(/^[A-Z]/, c => c.toLowerCase()); },
   camel_case()  { return this.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : '').replace(/^[A-Z]/, c => c.toLowerCase()); },
 };
 

package/src/version.js

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