tjs-lang 0.6.37 → 0.6.39

package/package.json

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

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

@@ -1712,6 +1712,10 @@ function transformClassToTJS(
     // Getters
     if (ts.isGetAccessorDeclaration(member) && member.name) {
       const propName = member.name.getText(sourceFile)
+      const isStatic = member.modifiers?.some(
+        (m) => m.kind === ts.SyntaxKind.StaticKeyword
+      )
+      const staticPrefix = isStatic ? 'static ' : ''
       const returnExample = member.type
         ? typeToExample(member.type, undefined, warnings, resolveCtx)
         : ''
@@ -1735,12 +1739,18 @@ function transformClassToTJS(
         body = replacePrivateRefs(transpiled.outputText.trim())
       }
 
-      members.push(`  get ${propName}()${returnAnnotation} ${body}`)
+      members.push(
+        `  ${staticPrefix}get ${propName}()${returnAnnotation} ${body}`
+      )
     }
 
     // Setters
     if (ts.isSetAccessorDeclaration(member) && member.name) {
       const propName = member.name.getText(sourceFile)
+      const isStatic = member.modifiers?.some(
+        (m) => m.kind === ts.SyntaxKind.StaticKeyword
+      )
+      const staticPrefix = isStatic ? 'static ' : ''
       const params = transformParams(member.parameters, sourceFile, warnings)
 
       let body = '{ }'
@@ -1755,7 +1765,9 @@ function transformClassToTJS(
         body = replacePrivateRefs(transpiled.outputText.trim())
       }
 
-      members.push(`  set ${propName}(${params.join(', ')}) ${body}`)
+      members.push(
+        `  ${staticPrefix}set ${propName}(${params.join(', ')}) ${body}`
+      )
     }
 
     // Properties with initializers (private fields, regular properties)

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

@@ -175,11 +175,75 @@ const tag = Component.getTag()
     }).not.toThrow()
   })
 
-  test('shorthand property assignment in destructuring converts', () => {
-    // component.test.ts fails to convert with:
+  test('static getter loses static keyword during conversion', () => {
+    // In tosijs component.ts:
+    //   class Component extends HTMLElement {
+    //     static _tagName: string | null = null
+    //     static get tagName() { return this._tagName }
+    //   }
+    //
+    // The converter emits `get tagName()` (instance getter) instead of
+    // `static get tagName()`. This overrides HTMLElement.tagName with a
+    // getter that returns null, crashing the constructor.
+
+    const source = `
+class Foo {
+  static _label: string = ''
+  static get label() { return this._label }
+  static set label(v: string) { this._label = v }
+}
+`
+    // The bug is in TS→TJS: static is dropped from getters/setters
+    const tjsResult = fromTS(source, {
+      emitTJS: true,
+      filename: 'static-getter.ts',
+    })
+    expect(tjsResult.code).toContain('static get label')
+    expect(tjsResult.code).toContain('static set label')
+  })
+
+  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 = `