tjs-lang 0.6.39 → 0.6.42

package/package.json

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

package/src/lang/emitters/dts.ts

@@ -453,6 +453,14 @@ function detectTypeDeclarations(source: string): Map<string, string> {
     result.set(m[1], m[2].trim())
   }
 
+  // Empty block: Type Name {} (no example — degraded type, emit as any)
+  const emptyBlockRe = /^[ \t]*(?:export\s+)?Type\s+(\w+)\s*\{\s*\}/gm
+  while ((m = emptyBlockRe.exec(source)) !== null) {
+    if (!result.has(m[1])) {
+      result.set(m[1], '') // empty string signals "any"
+    }
+  }
+
   return result
 }
 
@@ -505,6 +513,57 @@ function detectGenerics(source: string): Map<string, GenericInfo> {
   return result
 }
 
+/** Info about a const/let/var declaration */
+interface VarDeclInfo {
+  name: string
+  value: string
+  kind: 'const' | 'let' | 'var'
+}
+
+/** Detect exported const/let/var declarations and their initializer values */
+function detectVarDeclarations(source: string): VarDeclInfo[] {
+  const result: VarDeclInfo[] = []
+  const re =
+    /^[ \t]*export\s+(?:default\s+)?(const|let|var)\s+(\w+)\s*(?::\s*\w+\s*)?=\s*(.+)/gm
+  let m
+  while ((m = re.exec(source)) !== null) {
+    // Get the value — may span multiple lines for objects/arrays
+    let value = m[3].trim()
+    // Strip trailing semicolons
+    if (value.endsWith(';')) value = value.slice(0, -1).trim()
+    result.push({ name: m[2], value, kind: m[1] as 'const' | 'let' | 'var' })
+  }
+  return result
+}
+
+/** Infer a TS type from a const initializer value */
+function inferConstType(value: string): string {
+  // String literal
+  if (/^['"]/.test(value)) return 'string'
+  // Template literal
+  if (value.startsWith('`')) return 'string'
+  // Boolean
+  if (value === 'true' || value === 'false') return 'boolean'
+  // Number
+  if (/^[+-]?\d+(\.\d+)?$/.test(value)) return 'number'
+  // Symbol
+  if (value.startsWith('Symbol(') || value.startsWith('Symbol.'))
+    return 'symbol'
+  // Array
+  if (value.startsWith('[')) return 'any[]'
+  // new Map/Set/WeakMap etc.
+  if (value.startsWith('new WeakMap')) return 'WeakMap<any, any>'
+  if (value.startsWith('new Map')) return 'Map<any, any>'
+  if (value.startsWith('new Set')) return 'Set<any>'
+  if (value.startsWith('new ')) return 'any'
+  // Object/Record
+  if (value.startsWith('{')) return 'Record<string, any>'
+  // null/undefined
+  if (value === 'null') return 'null'
+  if (value === 'undefined') return 'undefined'
+  return 'any'
+}
+
 /**
  * Generate a .d.ts string from TJS transpilation output.
  *
@@ -594,14 +653,19 @@ export function generateDTS(
     const isExported = hasAnyExport ? !!exportInfo?.exported : true
     if (!isExported) continue
 
-    const tsType = inferTSTypeFromExample(exampleStr)
-    lines.push(
-      `export declare const ${name}: {` +
-        ` check(value: any): boolean;` +
-        ` default: ${tsType};` +
-        ` (value: any): boolean;` +
-        ` };`
-    )
+    if (exampleStr === '') {
+      // Empty Type {} — degraded from TS type alias, emit as type = any
+      lines.push(`export type ${name} = any;`)
+    } else {
+      const tsType = inferTSTypeFromExample(exampleStr)
+      lines.push(
+        `export declare const ${name}: {` +
+          ` check(value: any): boolean;` +
+          ` default: ${tsType};` +
+          ` (value: any): boolean;` +
+          ` };`
+      )
+    }
     emitted.add(name)
   }
 
@@ -619,14 +683,23 @@ export function generateDTS(
       info.typeParams.length > 0 ? `<${info.typeParams.join(', ')}>` : ''
 
     if (info.declaration) {
-      // Emit a proper TypeScript interface from the declaration block
-      const declLines = info.declaration
-        .split('\n')
-        .map((l) => l.trim())
-        .filter((l) => l.length > 0)
-        .map((l) => `  ${l}`)
-        .join('\n')
-      lines.push(`export interface ${name}${typeParamStr} {\n${declLines}\n}`)
+      const declContent = info.declaration.trim()
+
+      // Check if this is a verbatim TS type (conditional, mapped, etc.)
+      // These start with "// TS:" and should be emitted as `export type`
+      const tsMatch = declContent.match(/^\/\/\s*TS:\s*(.+)$/s)
+      if (tsMatch) {
+        lines.push(`export type ${name}${typeParamStr} = ${tsMatch[1].trim()};`)
+      } else {
+        // Structured declaration — emit as interface
+        const declLines = declContent
+          .split('\n')
+          .map((l) => l.trim())
+          .filter((l) => l.length > 0)
+          .map((l) => `  ${l}`)
+          .join('\n')
+        lines.push(`export interface ${name}${typeParamStr} {\n${declLines}\n}`)
+      }
     } else {
       // No declaration block — emit any-based factory stub
       lines.push(
@@ -659,15 +732,31 @@ export function generateDTS(
 
     const tsParams = fpInfo.params
       .map((p) => {
-        const tsType = tpNames.has(p.example)
-          ? p.example
-          : inferTSTypeFromExample(p.example)
+        // Array example [X] → rest param ...name: X[]
+        if (p.example.startsWith('[') && p.example.endsWith(']')) {
+          const inner = p.example.slice(1, -1).trim()
+          const innerType = inner
+            ? tpNames.has(inner)
+              ? inner
+              : inferTSTypeFromExample(inner)
+            : 'any'
+          return `...${p.name}: ${innerType}[]`
+        }
+        // In FunctionPredicate params, null means "any" (not literal null)
+        const tsType =
+          p.example === 'null'
+            ? 'any'
+            : tpNames.has(p.example)
+            ? p.example
+            : inferTSTypeFromExample(p.example)
         return `${p.name}: ${tsType}`
       })
       .join(', ')
     const tsReturn =
       fpInfo.returns !== undefined
-        ? tpNames.has(fpInfo.returns)
+        ? fpInfo.returns === 'null'
+          ? 'any'
+          : tpNames.has(fpInfo.returns)
           ? fpInfo.returns
           : inferTSTypeFromExample(fpInfo.returns)
         : 'void'
@@ -677,6 +766,20 @@ export function generateDTS(
     emitted.add(name)
   }
 
+  // Emit exported const/let/var declarations
+  const varDecls = detectVarDeclarations(source)
+  for (const decl of varDecls) {
+    if (emitted.has(decl.name)) continue
+
+    const exportInfo = exports.get(decl.name)
+    const isExported = hasAnyExport ? !!exportInfo?.exported : true
+    if (!isExported) continue
+
+    const tsType = inferConstType(decl.value)
+    lines.push(`export declare const ${decl.name}: ${tsType};`)
+    emitted.add(decl.name)
+  }
+
   if (options.moduleName) {
     const indented = lines.map((l) => `  ${l}`).join('\n')
     return `declare module '${options.moduleName}' {\n${indented}\n}\n`

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(