tjs-lang 0.6.12 → 0.6.13

package/package.json

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

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

@@ -157,6 +157,12 @@ function typeToExample(
       return 'any'
     case ts.SyntaxKind.NeverKeyword:
       return 'null'
+    case ts.SyntaxKind.SymbolKeyword:
+      return "Symbol('example')"
+    case ts.SyntaxKind.BigIntKeyword:
+      return '0n'
+    case ts.SyntaxKind.ObjectKeyword:
+      return '{}'
 
     case ts.SyntaxKind.ArrayType: {
       const arrayType = type as ts.ArrayTypeNode
@@ -202,11 +208,58 @@ function typeToExample(
       if (typeName === 'Record') {
         return '{}'
       }
-      if (typeName === 'Map') {
-        return 'new Map()'
+
+      // Built-in constructible types — valid JS expressions as examples
+      const builtinExamples: Record<string, string> = {
+        // Collections
+        Map: 'new Map()',
+        Set: 'new Set()',
+        WeakMap: 'new WeakMap()',
+        WeakSet: 'new WeakSet()',
+        WeakRef: 'new WeakRef({})',
+        // Errors
+        Error: "new Error('example')",
+        TypeError: "new TypeError('example')",
+        RangeError: "new RangeError('example')",
+        // Date/Regex
+        Date: 'new Date()',
+        RegExp: '/example/',
+        // Binary / WASM
+        ArrayBuffer: 'new ArrayBuffer(0)',
+        SharedArrayBuffer: 'new SharedArrayBuffer(0)',
+        DataView: 'new DataView(new ArrayBuffer(0))',
+        Float32Array: 'new Float32Array(0)',
+        Float64Array: 'new Float64Array(0)',
+        Int8Array: 'new Int8Array(0)',
+        Int16Array: 'new Int16Array(0)',
+        Int32Array: 'new Int32Array(0)',
+        Uint8Array: 'new Uint8Array(0)',
+        Uint16Array: 'new Uint16Array(0)',
+        Uint32Array: 'new Uint32Array(0)',
+        Uint8ClampedArray: 'new Uint8ClampedArray(0)',
+        BigInt64Array: 'new BigInt64Array(0)',
+        BigUint64Array: 'new BigUint64Array(0)',
+        // Web/DOM
+        URL: "new URL('https://example.com')",
+        URLSearchParams: 'new URLSearchParams()',
+        Headers: 'new Headers()',
+        FormData: 'new FormData()',
+        Blob: 'new Blob()',
+        File: "new File([], 'example')",
+        Response: 'new Response()',
+        Request: "new Request('https://example.com')",
+        AbortController: 'new AbortController()',
+        // Streams
+        ReadableStream: 'new ReadableStream()',
+        WritableStream: 'new WritableStream()',
+        TransformStream: 'new TransformStream()',
+        // Structured data
+        TextEncoder: 'new TextEncoder()',
+        TextDecoder: 'new TextDecoder()',
       }
-      if (typeName === 'Set') {
-        return 'new Set()'
+
+      if (typeName in builtinExamples) {
+        return builtinExamples[typeName]
       }
 
       // Resolve type aliases
@@ -320,6 +373,12 @@ function typeToExample(
       const hasNull = unionType.types.some(isNullType)
       const hasUndefined = unionType.types.some(isUndefinedType)
 
+      // All null/undefined — just return the simplest form
+      if (nonNullTypes.length === 0) {
+        if (hasNull) return 'null'
+        return 'undefined'
+      }
+
       if (nonNullTypes.length === 1 && (hasNull || hasUndefined)) {
         // Nullable type: T | null -> T | null
         const baseExample = typeToExample(nonNullTypes[0], checker)
@@ -327,10 +386,12 @@ function typeToExample(
         if (hasUndefined) return `${baseExample} | undefined`
       }
 
-      // General union: use first type as example
-      if (unionType.types.length > 0) {
-        return typeToExample(unionType.types[0], checker)
-      }
+      // General union: deduplicate and use first non-any type
+      const examples = unionType.types
+        .map((t) => typeToExample(t, checker))
+        .filter((e, i, arr) => arr.indexOf(e) === i) // deduplicate
+      if (examples.length === 1) return examples[0]
+      if (examples.length > 0) return examples[0]
       return 'undefined'
     }
 
@@ -366,10 +427,11 @@ function typeToExample(
     case ts.SyntaxKind.TupleType: {
       const tupleType = type as ts.TupleTypeNode
       const elements = tupleType.elements.map((e) => {
-        if (ts.isNamedTupleMember(e)) {
-          return typeToExample(e.type, checker)
-        }
-        return typeToExample(e as ts.TypeNode, checker)
+        const example = ts.isNamedTupleMember(e)
+          ? typeToExample(e.type, checker)
+          : typeToExample(e as ts.TypeNode, checker)
+        // 'any' is not a valid literal value
+        return example === 'any' ? 'null' : example
       })
       return `[${elements.join(', ')}]`
     }
@@ -746,13 +808,26 @@ function transformGenericInterfaceToGeneric(
   for (const member of node.members) {
     if (ts.isPropertySignature(member) && member.name) {
       const propName = member.name.getText(sourceFile)
-      checks.push(`'${propName}' in x`)
+
+      // Computed property names: [SYMBOL] → use bracket access
+      const isComputed = propName.startsWith('[') && propName.endsWith(']')
+      const symbolName = isComputed ? propName.slice(1, -1) : null
+
+      if (isComputed) {
+        checks.push(`${symbolName} in x`)
+      } else {
+        checks.push(`'${propName}' in x`)
+      }
 
       // If property type is a type parameter, add check
       if (member.type && ts.isTypeReferenceNode(member.type)) {
         const refName = member.type.typeName.getText(sourceFile)
         if (typeParamNames.includes(refName)) {
-          checks.push(`${refName}(x.${propName})`)
+          if (isComputed) {
+            checks.push(`${refName}(x[${symbolName}])`)
+          } else {
+            checks.push(`${refName}(x.${propName})`)
+          }
         }
       }
     }
@@ -905,6 +980,11 @@ function transformTypeAliasToType(
 
   const example = typeToExample(node.type, undefined, warnings)
 
+  // 'any' and 'undefined' — skip declaration (undeclared = any in TJS)
+  if (example === 'any' || example === 'undefined') {
+    return `Type ${typeName} {}`
+  }
+
   // For simple primitive types, use short form
   if (
     example === "''" ||
@@ -947,8 +1027,13 @@ function transformGenericTypeAliasToGeneric(
   )
   const predicateParams = ['x', ...typeParamNames].join(', ')
 
-  // Simple fallback - more sophisticated analysis could be added
-  return `Generic ${typeName}<${typeParams.join(', ')}> {
+  // Include original TS source as a block comment for manual enhancement
+  // Use /* */ to avoid confusing the Generic block preprocessor
+  const originalSource = node.getText(sourceFile).trim()
+  const comment = `/* Original TS:\n${originalSource}\n*/`
+
+  return `${comment}
+Generic ${typeName}<${typeParams.join(', ')}> {
   description: '${typeName}'
   predicate(${predicateParams}) { return true }
 }`
@@ -1966,7 +2051,10 @@ export function fromTS(
             warnings
           )
           if (typeDecl) {
-            tjsFunctions.push(typeDecl)
+            const isExported = statement.modifiers?.some(
+              (m) => m.kind === ts.SyntaxKind.ExportKeyword
+            )
+            tjsFunctions.push(isExported ? `export ${typeDecl}` : typeDecl)
           }
         }
       }
@@ -1985,7 +2073,10 @@ export function fromTS(
             warnings
           )
           if (typeDecl) {
-            tjsFunctions.push(typeDecl)
+            const isExported = statement.modifiers?.some(
+              (m) => m.kind === ts.SyntaxKind.ExportKeyword
+            )
+            tjsFunctions.push(isExported ? `export ${typeDecl}` : typeDecl)
           }
         }
       }

package/src/lang/parser-transforms.ts

@@ -1024,7 +1024,9 @@ export function transformTypeDeclarations(source: string): string {
 
   while (i < source.length) {
     // Look for 'Type' keyword followed by identifier
-    const typeMatch = source.slice(i).match(/^\bType\s+([A-Z][a-zA-Z0-9_]*)\s*/)
+    const typeMatch = source
+      .slice(i)
+      .match(/^\bType\s+([A-Z_][a-zA-Z0-9_]*)\s*/)
     if (typeMatch) {
       const typeName = typeMatch[1]
       let j = i + typeMatch[0].length
@@ -1239,7 +1241,10 @@ export function transformGenericDeclarations(source: string): string {
           .split('=')
           .map((s) => s.trim())
         if (parts.length === 2) {
-          return `['${parts[0]}', ${parts[1]}]`
+          // 'any' and 'undefined' aren't valid JS values — use null
+          const defaultVal =
+            parts[1] === 'any' || parts[1] === 'undefined' ? 'null' : parts[1]
+          return `['${parts[0]}', ${defaultVal}]`
         }
         return `'${parts[0]}'`
       })

package/src/lang/typescript-syntax.test.ts

@@ -1524,6 +1524,53 @@ describe('fromTS — tosijs conversion edge cases', () => {
     expect(result.code).toContain('{ value:')
   })
 
+  test('symbol type produces Symbol example', () => {
+    const result = fromTS(`function f(x: symbol): void {}`, { emitTJS: true })
+    expect(result.code).toContain("Symbol('example')")
+  })
+
+  test('bigint type produces 0n example', () => {
+    const result = fromTS(`function f(x: bigint): void {}`, { emitTJS: true })
+    expect(result.code).toContain('0n')
+  })
+
+  test('built-in reference types produce valid JS examples', () => {
+    const cases: [string, string][] = [
+      ['RegExp', '/example/'],
+      ['Date', 'new Date()'],
+      ['Map<string, number>', 'new Map()'],
+      ['Set<number>', 'new Set()'],
+      ['WeakMap<object, number>', 'new WeakMap()'],
+      ['Float32Array', 'new Float32Array(0)'],
+      ['Uint8Array', 'new Uint8Array(0)'],
+      ['ArrayBuffer', 'new ArrayBuffer(0)'],
+      ['URL', "new URL('https://example.com')"],
+      ['AbortController', 'new AbortController()'],
+      ['ReadableStream', 'new ReadableStream()'],
+      ['TextEncoder', 'new TextEncoder()'],
+      ['Error', "new Error('example')"],
+    ]
+    for (const [tsType, expected] of cases) {
+      const result = fromTS(`function f(x: ${tsType}): void {}`, {
+        emitTJS: true,
+      })
+      expect(result.code).toContain(expected)
+    }
+  })
+
+  test('export keyword preserved on Type declarations', () => {
+    const result = fromTS(
+      `export interface User { name: string; age: number }`,
+      { emitTJS: true }
+    )
+    expect(result.code).toContain('export Type User')
+  })
+
+  test('export keyword preserved on type alias declarations', () => {
+    const result = fromTS(`export type Name = string`, { emitTJS: true })
+    expect(result.code).toContain('export Type Name')
+  })
+
   test('non-exported functions have no export keyword', () => {
     const result = fromTS(`function internal(x: number): number { return x }`, {
       emitTJS: true,