tjs-lang 0.6.38 → 0.6.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tjs-lang",
-  "version": "0.6.38",
+  "version": "0.6.40",
   "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.40'
 
 const HELP = `
 tjs - Typed JavaScript CLI

package/src/lang/emitters/from-ts.ts

@@ -1065,8 +1065,28 @@ function transformGenericInterfaceToGeneric(
   }
 
   const parts = [`description: '${typeName}'`, predicateLine]
+
   if (declarationAnnotation?.text) {
     parts.push(`declaration ${declarationAnnotation.text}`)
+  } else {
+    // Auto-generate declaration block from interface members
+    const declMembers: string[] = []
+    for (const member of node.members) {
+      if (ts.isPropertySignature(member) && member.name) {
+        const propName = member.name.getText(sourceFile)
+        const optional = member.questionToken ? '?' : ''
+        const typeText = member.type ? member.type.getText(sourceFile) : 'any'
+        declMembers.push(`${propName}${optional}: ${typeText}`)
+      } else if (ts.isMethodSignature(member) && member.name) {
+        // Method: name(params): returnType
+        const methodText = member.getText(sourceFile).trim()
+        // Remove trailing semicolon if present
+        declMembers.push(methodText.replace(/;$/, ''))
+      }
+    }
+    if (declMembers.length > 0) {
+      parts.push(`declaration {\n    ${declMembers.join('\n    ')}\n  }`)
+    }
   }
 
   return `Generic ${typeName}<${typeParams.join(', ')}> {\n  ${parts.join(
@@ -1366,18 +1386,41 @@ function transformGenericTypeAliasToGeneric(
     predicateLine = `predicate(${predicateParams}) { return true }`
   }
 
-  // Include original TS source as a block comment for manual enhancement
-  const originalSource = node.getText(sourceFile).trim()
-  const comment = `/* Original TS:\n${originalSource}\n*/`
-
   const parts = [`description: '${typeName}'`, predicateLine]
+
   if (declarationAnnotation?.text) {
     parts.push(`declaration ${declarationAnnotation.text}`)
+  } else {
+    // Auto-generate declaration block from the type body
+    const typeBody = node.type
+
+    if (typeBody && ts.isTypeLiteralNode(typeBody)) {
+      // Object type literal: { item: T; count: number }
+      const declMembers: string[] = []
+      for (const member of typeBody.members) {
+        if (ts.isPropertySignature(member) && member.name) {
+          const propName = member.name.getText(sourceFile)
+          const optional = member.questionToken ? '?' : ''
+          const typeText = member.type ? member.type.getText(sourceFile) : 'any'
+          declMembers.push(`${propName}${optional}: ${typeText}`)
+        } else if (ts.isMethodSignature(member) && member.name) {
+          declMembers.push(member.getText(sourceFile).trim().replace(/;$/, ''))
+        }
+      }
+      if (declMembers.length > 0) {
+        parts.push(`declaration {\n    ${declMembers.join('\n    ')}\n  }`)
+      }
+    } else if (typeBody) {
+      // Complex type (conditional, mapped, intersection, etc.)
+      // Pass through the TS type body verbatim
+      const typeText = typeBody.getText(sourceFile).trim()
+      parts.push(`declaration {\n    // TS: ${typeText}\n  }`)
+    }
   }
 
-  return `${comment}\nGeneric ${typeName}<${typeParams.join(
-    ', '
-  )}> {\n  ${parts.join('\n  ')}\n}`
+  return `Generic ${typeName}<${typeParams.join(', ')}> {\n  ${parts.join(
+    '\n  '
+  )}\n}`
 }
 
 function transformFunctionToTJS(

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 = `