tjs-lang 0.6.35 → 0.6.37

package/package.json

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

package/src/lang/codegen.test.ts

@@ -211,7 +211,7 @@ class User {
       expect(code).toContain("constructor(name: '')")
     })
 
-    it('converts private fields to # syntax', () => {
+    it('strips private keyword without converting to # syntax', () => {
       const ts = `
 class Counter {
   private count: number = 0
@@ -220,9 +220,10 @@ class Counter {
 `
       const { code } = fromTS(ts, { emitTJS: true })
 
-      expect(code).toContain('#count')
-      expect(code).toContain('this.#count')
+      // private keyword stripped, field name kept as-is
       expect(code).not.toContain('private')
+      expect(code).not.toContain('#count')
+      expect(code).toContain('this.count')
     })
 
     it('converts method return types', () => {

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

@@ -545,7 +545,14 @@ function typeToExample(
 
       if (nonNullTypes.length === 1 && (hasNull || hasUndefined)) {
         // Nullable type: T | null -> T | null
-        const baseExample = typeToExample(nonNullTypes[0], checker)
+        const baseExample = typeToExample(
+          nonNullTypes[0],
+          checker,
+          warnings,
+          ctx
+        )
+        // any | null/undefined is just any — don't emit 'any | null'
+        if (baseExample === 'any') return 'any'
         if (hasNull) return `${baseExample} | null`
         if (hasUndefined) return `${baseExample} | undefined`
       }
@@ -1573,7 +1580,8 @@ function transformClassToTJS(
   node: ts.ClassDeclaration,
   sourceFile: ts.SourceFile,
   warnings?: string[],
-  ctx?: TypeResolutionContext
+  ctx?: TypeResolutionContext,
+  convertPrivateToHash = false
 ): string {
   // Build type parameter map from class-level generics
   let resolveCtx = ctx
@@ -1598,16 +1606,19 @@ function transformClassToTJS(
   )?.types[0]
   const extendsClause = extendsType?.expression?.getText(sourceFile)
 
-  // First pass: collect private field mappings (TS private -> JS #)
+  // With TjsClass: convert TS private to JS # (true runtime privacy).
+  // Without TjsClass: strip the keyword, keep the name (TS private is compile-time only).
   const privateFieldMap = new Map<string, string>()
-  for (const member of node.members) {
-    if (ts.isPropertyDeclaration(member) && member.name) {
-      const propName = member.name.getText(sourceFile)
-      const isPrivate = member.modifiers?.some(
-        (m) => m.kind === ts.SyntaxKind.PrivateKeyword
-      )
-      if (isPrivate && !propName.startsWith('#')) {
-        privateFieldMap.set(propName, `#${propName}`)
+  if (convertPrivateToHash) {
+    for (const member of node.members) {
+      if (ts.isPropertyDeclaration(member) && member.name) {
+        const propName = member.name.getText(sourceFile)
+        const isPrivate = member.modifiers?.some(
+          (m) => m.kind === ts.SyntaxKind.PrivateKeyword
+        )
+        if (isPrivate && !propName.startsWith('#')) {
+          privateFieldMap.set(propName, `#${propName}`)
+        }
       }
     }
   }
@@ -2068,6 +2079,37 @@ interface TjsAnnotation {
   text?: string // raw text for predicate/example/declaration
 }
 
+/** Valid TJS mode directives */
+const VALID_TJS_MODES = new Set([
+  'TjsStrict',
+  'TjsEquals',
+  'TjsClass',
+  'TjsDate',
+  'TjsNoeval',
+  'TjsNoVar',
+  'TjsStandard',
+  'TjsSafeEval',
+])
+
+/**
+ * Extract TJS mode directives from /* @tjs ... * / comments.
+ * e.g. /* @tjs TjsClass TjsEquals * / → ['TjsClass', 'TjsEquals']
+ */
+function extractTjsModes(source: string): string[] {
+  const modes: string[] = []
+  const re = /\/\*\s*@tjs\s+((?:Tjs\w+\s*)+)\*\//g
+  let m
+  while ((m = re.exec(source)) !== null) {
+    const words = m[1].trim().split(/\s+/)
+    for (const word of words) {
+      if (VALID_TJS_MODES.has(word) && !modes.includes(word)) {
+        modes.push(word)
+      }
+    }
+  }
+  return modes
+}
+
 /**
  * Extract @tjs annotations from source comments.
  *
@@ -2234,6 +2276,11 @@ export function fromTS(
   // Extract @tjs annotations for enriching TJS output
   const tjsAnnotations = emitTJS ? extractTjsAnnotations(source) : []
 
+  // Extract TJS mode directives from /* @tjs TjsClass ... */ comments
+  const tjsModes = extractTjsModes(source)
+  const hasTjsClass =
+    tjsModes.includes('TjsClass') || tjsModes.includes('TjsStrict')
+
   // Parse TypeScript
   const sourceFile = ts.createSourceFile(
     filename,
@@ -2577,7 +2624,13 @@ export function fromTS(
       const className = statement.name.getText(sourceFile)
       handled = true
       if (emitTJS) {
-        const classDecl = transformClassToTJS(statement, sourceFile, warnings)
+        const classDecl = transformClassToTJS(
+          statement,
+          sourceFile,
+          warnings,
+          undefined,
+          hasTjsClass
+        )
         tjsFunctions.push(classDecl)
       } else {
         classMetadata[className] = extractClassMetadata(
@@ -2677,9 +2730,10 @@ export function fromTS(
     // Emit any remaining doc comments (after all statements)
     emitDocCommentsBefore(Infinity)
 
-    // Include source file annotation for error reporting
+    // Include source file annotation and TJS mode directives
     const sourceFileName = filename || 'unknown'
-    const header = `/* tjs <- ${sourceFileName} */\n\n`
+    const modesLine = tjsModes.length > 0 ? tjsModes.join('\n') + '\n\n' : ''
+    const header = `${modesLine}/* tjs <- ${sourceFileName} */\n\n`
 
     // Append embedded test comments (they were extracted from original source)
     const testsSection =

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

@@ -1463,7 +1463,9 @@ describe('fromTS — tosijs conversion edge cases', () => {
     expect(result.code).toContain('export class Foo')
   })
 
-  test('private fields replaced in all access patterns', () => {
+  test('private keyword stripped without converting to #', () => {
+    // TS private is compile-time only — converting to # changes semantics
+    // and breaks external access via (obj as any)._field
     const result = fromTS(
       `class Foo {
         private cache: any = null
@@ -1480,18 +1482,15 @@ describe('fromTS — tosijs conversion edge cases', () => {
       }`,
       { emitTJS: true }
     )
-    // this.cache -> this.#cache
-    expect(result.code).toContain('this.#cache')
-    // f.cache -> f.#cache (instance via variable)
-    expect(result.code).toContain('f.#cache')
-    // Foo.instances -> Foo.#instances (static via class name)
-    expect(result.code).toContain('Foo.#instances')
-    // No un-hashed private access left (dot followed by bare name)
-    expect(result.code).not.toContain('.cache')
-    expect(result.code).not.toContain('.instances')
-  })
-
-  test('private _backing field with public getter preserved correctly', () => {
+    // private keyword stripped
+    expect(result.code).not.toContain('private')
+    // field names kept as-is (no # conversion)
+    expect(result.code).not.toContain('#cache')
+    expect(result.code).not.toContain('#instances')
+    expect(result.code).toContain('this.cache')
+  })
+
+  test('private _backing field kept as-is with getter/setter', () => {
     const result = fromTS(
       `class User {
         private _name: string = ''
@@ -1500,15 +1499,15 @@ describe('fromTS — tosijs conversion edge cases', () => {
       }`,
       { emitTJS: true }
     )
-    // Backing field renamed
-    expect(result.code).toContain('#_name')
-    expect(result.code).toContain('this.#_name')
-    // Public getter NOT renamed
+    // Backing field kept as _name (not #_name)
+    expect(result.code).not.toContain('#_name')
+    expect(result.code).toContain('this._name')
+    // Public getter/setter preserved
     expect(result.code).toContain('get name()')
     expect(result.code).toContain('set name(')
   })
 
-  test('private field name not confused with object literal key', () => {
+  test('private field name unchanged in object literals', () => {
     const result = fromTS(
       `class Store {
         private value: any = null
@@ -1518,10 +1517,9 @@ describe('fromTS — tosijs conversion edge cases', () => {
       }`,
       { emitTJS: true }
     )
-    // this.value → this.#value
-    expect(result.code).toContain('this.#value')
-    // object key { value: ... } stays as 'value' (not '#value')
-    expect(result.code).toContain('{ value:')
+    // this.value stays as-is (not this.#value)
+    expect(result.code).toContain('this.value')
+    expect(result.code).not.toContain('#value')
   })
 
   test('symbol type produces Symbol example', () => {

package/src/use-cases/tosijs-convert-issues.test.ts

@@ -92,6 +92,89 @@ console.log(result)
     expect(result).toBe('') // [].join(', ') === ''
   })
 
+  test('literal "any" emitted as runtime value in interface/type', () => {
+    // In tosijs form-validation.ts, an interface has a property typed as `any`:
+    //   interface FormValidation { validity: any; ... }
+    //
+    // The TS→TJS→JS pipeline emits a Type() call with the literal `any`
+    // as a JS value: Type('FormValidation', undefined, { validity: any | undefined })
+    // which throws: ReferenceError: any is not defined
+    //
+    // The converter should emit null or skip the field for `any` types.
+
+    const source = `
+export interface FormValidation {
+  internals: any
+  validity: any | undefined
+  validationMessage: string
+  willValidate: boolean
+}
+`
+    const tjsResult = fromTS(source, { emitTJS: true, filename: 'any-type.ts' })
+    const jsResult = tjs(tjsResult.code, {
+      filename: 'any-type.ts',
+      runTests: false,
+    })
+
+    // Should not contain bare `any` as a runtime identifier
+    const safeCode = jsResult.code.replace(/^export /gm, '')
+    expect(() => {
+      new Function(safeCode)()
+    }).not.toThrow()
+  })
+
+  test('TS private keyword should not convert to # (changes semantics)', () => {
+    // In tosijs component.ts:
+    //   class Component { private static _tagName: string = '' }
+    //   function elementCreator(componentClass: typeof Component) {
+    //     componentClass._tagName = 'my-tag'  // valid TS — private is compile-time only
+    //   }
+    //
+    // The converter rewrites `private _tagName` to `#_tagName`, which makes
+    // the field a true JS private field. External access then fails:
+    //   TypeError: Cannot access invalid private field
+    //
+    // TS `private` is compile-time access control, not JS `#` runtime privacy.
+    // The converter should leave `private` fields as regular fields (strip the keyword).
+
+    const source = `
+class Component {
+  private static _tagName: string = ''
+
+  static getTag() {
+    return this._tagName
+  }
+}
+
+function setup(cls: typeof Component) {
+  (cls as any)._tagName = 'my-tag'
+}
+
+setup(Component)
+const tag = Component.getTag()
+`
+    const tjsResult = fromTS(source, {
+      emitTJS: true,
+      filename: 'private-kw.ts',
+    })
+    const jsResult = tjs(tjsResult.code, {
+      filename: 'private-kw.ts',
+      runTests: false,
+    })
+
+    // Should not convert `private` to `#`
+    expect(jsResult.code).not.toContain('#_tagName')
+
+    // The code should execute without error
+    const safeCode = jsResult.code.replace(/^export /gm, '')
+    expect(() => {
+      const fn = new Function(safeCode + '\n return tag;')
+      const result = fn()
+      if (result !== 'my-tag')
+        throw new Error(`Expected 'my-tag', got '${result}'`)
+    }).not.toThrow()
+  })
+
   test('shorthand property assignment in destructuring converts', () => {
     // component.test.ts fails to convert with:
     //   "Shorthand property assignments are valid only in destructuring patterns"