tjs-lang 0.6.38 → 0.6.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tjs-lang",
-  "version": "0.6.38",
+  "version": "0.6.39",
   "description": "Type-safe JavaScript dialect with runtime validation, sandboxed VM execution, and AI agent orchestration. Transpiles TypeScript to validated JS with fuel-metered execution for untrusted code.",
   "keywords": [
     "typescript",

package/src/cli/tjs.ts

@@ -20,7 +20,7 @@ import { emit } from './commands/emit'
 import { convert } from './commands/convert'
 import { test } from './commands/test'
 
-const VERSION = '0.6.38'
+const VERSION = '0.6.39'
 
 const HELP = `
 tjs - Typed JavaScript CLI

package/src/lang/parser-params.ts

@@ -343,10 +343,38 @@ export function transformParenExpressions(
     // Look for class method syntax: constructor(, methodName(, get name(, set name(
     // These appear inside class bodies and need param transformation
     // Only match if we're actually in a class body (proper context tracking)
+    // Must NOT match function calls in expressions (div(), span(), etc.)
     const methodMatch = source
       .slice(i)
       .match(/^(constructor|(?:get|set)\s+\w+|async\s+\w+|\w+)\s*\(/)
-    if (methodMatch && isInClassBody()) {
+    // Check that the preceding non-whitespace character indicates this is a
+    // declaration, not a function call in an expression.
+    // Method declarations follow: newline, {, ;, or start of file
+    // Function calls follow: = => , [ ( . operators etc.
+    const prevNonWs = (() => {
+      for (let k = result.length - 1; k >= 0; k--) {
+        if (!/\s/.test(result[k])) return result[k]
+      }
+      return '\n' // start of input
+    })()
+    // Method declarations can follow almost anything (property, }, ;, etc.)
+    // Function CALLS in expressions specifically follow: = => , [ (
+    const isMethodDecl =
+      prevNonWs !== '=' &&
+      prevNonWs !== ',' &&
+      prevNonWs !== '(' &&
+      prevNonWs !== '[' &&
+      prevNonWs !== '>' // catches =>
+    if (methodMatch && isInClassBody() && !isMethodDecl) {
+      // Not a method declaration (it's a function call in an expression).
+      // Skip past the identifier to prevent re-matching a suffix
+      // (e.g. 'div(' → skip 'div', don't let 'iv(' match next).
+      const skipLen = methodMatch[1].length
+      result += source.slice(i, i + skipLen)
+      i += skipLen
+      continue
+    }
+    if (methodMatch && isInClassBody() && isMethodDecl) {
       // We're actually in a class body - this is a method definition
       const methodPart = methodMatch[1]
       const matchLen = methodMatch[0].length

package/src/use-cases/tosijs-convert-issues.test.ts

@@ -202,11 +202,48 @@ class Foo {
     expect(tjsResult.code).toContain('static set label')
   })
 
-  test('shorthand property assignment in destructuring converts', () => {
-    // component.test.ts fails to convert with:
+  test('destructured arrow param in class property fails TJS parse', () => {
+    // In tosijs component.test.ts, a class property is an arrow function
+    // with a destructured parameter:
+    //
+    //   content = ({ div, span }: typeof elements) => [...]
+    //
+    // fromTS (TS→TJS) handles this fine, stripping the type annotation:
+    //   content = ({ div, span }) => [...]
+    //
+    // But the TJS parser then chokes on this with:
     //   "Shorthand property assignments are valid only in destructuring patterns"
     //
-    // Minimal pattern that triggers the error:
+    // The bug is in the TJS→JS step (tjs parser), not the TS→TJS step.
+
+    const source = `
+class TestComponent {
+  content = ({ div, span }: { div: Function, span: Function }) => [
+    div({ part: 'container' }, span({ part: 'label' }, 'Test')),
+  ]
+
+  render() {}
+}
+`
+    const tjsResult = fromTS(source, {
+      emitTJS: true,
+      filename: 'destructured-param.ts',
+    })
+
+    // TS→TJS works fine
+    expect(tjsResult.code).toContain('content')
+
+    // TJS→JS fails on the destructured arrow param in class property
+    expect(() => {
+      tjs(tjsResult.code, {
+        filename: 'destructured-param.ts',
+        runTests: false,
+      })
+    }).not.toThrow()
+  })
+
+  test('shorthand property assignment in destructuring converts', () => {
+    // Also from component.test.ts — default values in destructuring:
     //   const { mode = 'default' } = getConfig()
 
     const source = `