tjs-lang 0.8.5 → 0.8.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tjs-lang",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "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/lang/emitters/from-ts.ts

@@ -1095,19 +1095,33 @@ function transformGenericInterfaceToGeneric(
   if (declarationAnnotation?.text) {
     parts.push(`declaration ${declarationAnnotation.text}`)
   } else {
-    // Auto-generate declaration block from interface members
+    // Auto-generate declaration block from interface members. Each member's
+    // type is converted to a TJS example via `typeToExample` (the same converter
+    // the non-generic interface path uses) rather than emitted as raw TS — so
+    // `path: string` → `path: ''`, `touch: () => void` → a FunctionPredicate
+    // example, and un-representable shapes (call-signature objects, etc.) degrade
+    // to a safe placeholder instead of producing TJS that won't re-parse.
+    // (The `@tjs declaration { … }` annotation path above is verbatim and
+    // unaffected — authors can still hand-write precise type signatures.)
     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}`)
+        const example = member.type
+          ? typeToExample(member.type, undefined, warnings)
+          : 'null'
+        declMembers.push(`${propName}${optional}: ${example}`)
       } 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(/;$/, ''))
+        // Method → a function example built from its return type (params are
+        // descriptive; the predicate above does the actual runtime check).
+        const propName = member.name.getText(sourceFile)
+        const ret = member.type
+          ? typeToExample(member.type, undefined, warnings)
+          : 'null'
+        declMembers.push(
+          `${propName}: FunctionPredicate('function', { returns: ${ret} })`
+        )
       }
     }
     if (declMembers.length > 0) {
@@ -1288,10 +1302,17 @@ function transformTypeAliasToType(
 
   const example = typeToExample(node.type, undefined, warnings)
 
-  // 'any' and 'undefined' — preserve original TS body for DTS round-tripping
+  // 'any' and 'undefined' — un-representable in TJS (intersections with
+  // `typeof`/index signatures, etc.). Degrade to an empty Type (validates as
+  // anything) and preserve the original TS body as a SINGLE-LINE comment so the
+  // DTS emitter can recover it. The collapse is essential: a multi-line type
+  // body would leave lines 2+ uncommented = raw TS leaking into the block =
+  // unparseable. (Representable shapes never reach here — they convert above.)
   if (example === 'any' || example === 'undefined') {
-    const originalType = node.type.getText(sourceFile).trim()
-    // Include the TS type body so the DTS emitter can recover it
+    const originalType = node.type
+      .getText(sourceFile)
+      .trim()
+      .replace(/\s+/g, ' ')
     return `Type ${typeName} {\n  // TS: ${originalType}\n}`
   }
 
@@ -1423,25 +1444,35 @@ function transformGenericTypeAliasToGeneric(
     const typeBody = node.type
 
     if (typeBody && ts.isTypeLiteralNode(typeBody)) {
-      // Object type literal: { item: T; count: number }
+      // Object type literal: { item: T; count: number }. Convert each member's
+      // type to a TJS example (degrades gracefully) rather than emitting raw TS.
       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}`)
+          const example = member.type
+            ? typeToExample(member.type, undefined, warnings)
+            : 'null'
+          declMembers.push(`${propName}${optional}: ${example}`)
         } else if (ts.isMethodSignature(member) && member.name) {
-          declMembers.push(member.getText(sourceFile).trim().replace(/;$/, ''))
+          const propName = member.name.getText(sourceFile)
+          const ret = member.type
+            ? typeToExample(member.type, undefined, warnings)
+            : 'null'
+          declMembers.push(
+            `${propName}: FunctionPredicate('function', { returns: ${ret} })`
+          )
         }
       }
       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()
+      // Complex type (conditional, mapped, intersection, …) — un-representable.
+      // Keep the TS body as a SINGLE-LINE comment (collapse newlines, else lines
+      // 2+ leak as raw TS and won't re-parse).
+      const typeText = typeBody.getText(sourceFile).trim().replace(/\s+/g, ' ')
       parts.push(`declaration {\n    // TS: ${typeText}\n  }`)
     }
   }

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

@@ -312,3 +312,51 @@ describe('@tjs annotations', () => {
     })
   })
 })
+
+// Regression: TS→TJS must never emit TJS that won't re-parse. These real-world
+// shapes (from tosijs) used to leak raw TS into Type/Generic blocks — generic
+// interfaces emitted raw member types in `declaration {}`, and intersections /
+// complex types emitted MULTI-LINE `// TS:` comments whose lines 2+ leaked as
+// raw TS. fromTS now converts members via typeToExample and collapses
+// un-representable bodies to a single-line comment (graceful degradation).
+describe('TS→TJS round-trips (no raw-TS leak into TJS blocks)', () => {
+  const { tjs } = require('./index') as { tjs: (s: string) => { code: string } }
+  const roundTrips = (ts: string) => {
+    const emitted = fromTS(ts, { emitTJS: true }).code
+    expect(() => tjs(emitted)).not.toThrow() // emitted TJS must re-parse
+    return emitted
+  }
+
+  it('generic interface with complex members (arrow, generic arrow, call-sig)', () => {
+    const out = roundTrips(`export interface Acc<T = any> {
+      value: T
+      path: string
+      touch: () => void
+      bind: <E extends Element = Element>(el: E, b: any) => void
+      find: { (selector: (item: any) => any, value: any): any }
+    }`)
+    // members converted to examples, not raw TS
+    expect(out).toContain("path: ''")
+    expect(out).toContain('touch: FunctionPredicate')
+    expect(out).not.toMatch(/path: string\b/) // no raw type leak
+  })
+
+  it('intersection type alias (typeof / index signature) degrades, single-line', () => {
+    const out = roundTrips(`export type ProxyObj = Props<object> & {
+      [key: string]: ProxyObj | string | null
+    }`)
+    // un-representable → comment-only Type, collapsed to one line (no leak)
+    expect(out).toMatch(/\/\/ TS:.*&/)
+    expect(out).not.toMatch(/\n\s*\[key: string\]:/) // the body didn't leak raw
+  })
+
+  it('generic type alias with object body + arrow member', () => {
+    roundTrips(`export type Wrap<T> = { value: T; build: (x: T) => T }`)
+  })
+
+  it('plain type alias with arrow + union return still works', () => {
+    roundTrips(
+      `export type AnyFunction = (...args: any[]) => any | Promise<any>`
+    )
+  })
+})