tjs-lang 0.2.0

package/demo/src/examples.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Tests that all TJS examples in demo-nav transpile without errors
+ *
+ * Note: We inline the examples here rather than importing from demo-nav.ts
+ * because demo-nav.ts imports browser-only dependencies (tosijs, tosijs-ui).
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { tjs } from '../../src/lang'
+
+// Extract just the example code strings from demo-nav.ts
+// This avoids importing browser-only dependencies
+const tjsExamples = [
+  {
+    name: 'TJS Grammar',
+    code: `/*
+TJS Grammar demonstrates the type syntax.
+Types are specified by example values.
+*/
+function greet(name: 'World') -> '' {
+  return \`Hello, \${name}!\`
+}
+
+// Call it
+greet('TJS')
+
+test('greet returns a greeting') {
+  expect(greet('Alice')).toBe('Hello, Alice!')
+}
+`,
+  },
+  {
+    name: 'Date Formatting (with import)',
+    code: `import { format, parseISO, addDays } from 'date-fns'
+
+function formatDate(isoDate: '2024-01-15', pattern: 'PPP') -> '' {
+  const date = parseISO(isoDate)
+  return format(date, pattern)
+}
+
+function addBusinessDays(isoDate: '2024-01-15', days: 5) -> '' {
+  const date = parseISO(isoDate)
+  const result = addDays(date, days)
+  return format(result, 'yyyy-MM-dd')
+}
+
+formatDate('2024-03-15', 'MMMM do, yyyy')
+`,
+  },
+  {
+    name: 'Lodash Utilities (with import)',
+    code: `import { groupBy, sortBy, uniqBy, chunk } from 'lodash-es'
+
+function groupUsers(users: [{ name: '', dept: '' }], key: 'dept')
+  -> { [key: '']: [{ name: '', dept: '' }] } {
+  return groupBy(users, key)
+}
+
+function sortByAge(users: [{ name: '', age: 0 }]) -> [{ name: '', age: 0 }] {
+  return sortBy(users, ['age'])
+}
+
+function uniqueByEmail(users: [{ email: '', name: '' }]) -> [{ email: '', name: '' }] {
+  return uniqBy(users, 'email')
+}
+
+// Note: nested array types like [['']] aren't supported yet, so we omit return type
+function paginate(items: [''], pageSize: 10) {
+  return chunk(items, pageSize)
+}
+
+test('groupUsers groups by department') {
+  const users = [
+    { name: 'Alice', dept: 'eng' },
+    { name: 'Bob', dept: 'sales' },
+    { name: 'Carol', dept: 'eng' }
+  ]
+  const grouped = groupUsers(users, 'dept')
+  expect(grouped.eng.length).toBe(2)
+  expect(grouped.sales.length).toBe(1)
+}
+`,
+  },
+  {
+    name: 'Full-Stack Demo: User Service',
+    code: `function createUser(user: { name: '', email: '' }) -> { id: 0, name: '', email: '', created: '' } {
+  return {
+    id: Math.floor(Math.random() * 10000),
+    name: user.name,
+    email: user.email,
+    created: new Date().toISOString()
+  }
+}
+
+// Note: union types like "Type | null" in return position aren't supported yet
+function getUser(id: 0) -> { id: 0, name: '', email: '' } {
+  return { id, name: 'Test User', email: 'test@example.com' }
+}
+
+test('createUser returns user with id') {
+  const user = createUser({ name: 'Alice', email: 'alice@test.com' })
+  expect(typeof user.id).toBe('number')
+  expect(user.name).toBe('Alice')
+}
+`,
+  },
+  {
+    name: 'The Universal Endpoint',
+    code: `function endpoint(request: { path: '', method: 'GET' }) -> { status: 200, body: '' } {
+  if (request.method === 'GET') {
+    return { status: 200, body: 'Hello from TJS!' }
+  }
+  return { status: 405, body: 'Method not allowed' }
+}
+
+test('GET returns 200') {
+  const res = endpoint({ path: '/', method: 'GET' })
+  expect(res.status).toBe(200)
+}
+`,
+  },
+  {
+    name: 'Inline Tests: Test Private Functions',
+    code: `// Private helper - not exported
+function validateEmail(email: '') -> true {
+  return email.includes('@') && email.includes('.')
+}
+
+// Public API
+function processUser(user: { email: '' }) -> { valid: true } {
+  return { valid: validateEmail(user.email) }
+}
+
+// We can test private functions directly!
+test('validateEmail checks for @ and .') {
+  expect(validateEmail('test@example.com')).toBe(true)
+  expect(validateEmail('invalid')).toBe(false)
+}
+`,
+  },
+]
+
+describe('TJS Examples', () => {
+  for (const example of tjsExamples) {
+    test(`"${example.name}" transpiles without error`, () => {
+      // Skip examples that are intentionally broken (if any)
+      if (
+        example.name.toLowerCase().includes('error') ||
+        example.name.toLowerCase().includes('broken')
+      ) {
+        return
+      }
+
+      expect(() => {
+        // Skip test execution - these examples have test blocks that require
+        // imports which can't run in transpile-time evaluation context
+        tjs(example.code, { runTests: false })
+      }).not.toThrow()
+    })
+  }
+})

package/demo/src/examples.ts

@@ -0,0 +1,476 @@
+/*
+ * examples.ts - Example AsyncJS snippets for the playground
+ */
+
+export interface Example {
+  name: string
+  description: string
+  code: string
+  requiresApi?: boolean // Needs LLM API key
+  group?: 'featured' | 'basics' | 'api' | 'llm' | 'advanced' // Navigation group
+}
+
+export const examples: Example[] = [
+  {
+    name: 'Hello World',
+    description: 'Simple greeting with template',
+    group: 'basics',
+    code: `function greet({ name = 'World' }) {
+  let message = template({ tmpl: 'Hello, {{name}}!', vars: { name } })
+  return { message }
+}`,
+  },
+  {
+    name: 'Math Operations',
+    description: 'Basic arithmetic and Math built-ins',
+    group: 'basics',
+    code: `function calculate({ a = 10, b = 5 }) {
+  let sum = a + b
+  let product = a * b
+  let power = a ** b
+  let sqrt = Math.sqrt(a)
+  let max = Math.max(a, b)
+  let rounded = Math.floor(a / b)
+  return { sum, product, power, sqrt, max, rounded }
+}`,
+  },
+  {
+    name: 'Conditional Logic',
+    description: 'If/else branching',
+    group: 'basics',
+    code: `function checkAge({ age = 25 }) {
+  if (age >= 18) {
+    let status = 'adult'
+    return { status, canVote: true }
+  } else {
+    let status = 'minor'
+    return { status, canVote: false }
+  }
+}`,
+  },
+  {
+    name: 'Loop & Filter',
+    description: 'Process arrays with array methods',
+    group: 'basics',
+    code: `function processNumbers({ numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] }) {
+  let evens = numbers.filter(x => x % 2 == 0)
+  let doubled = evens.map(x => x * 2)
+  let total = doubled.reduce((acc, x) => acc + x, 0)
+  return { evens, doubled, total }
+}`,
+  },
+  {
+    name: 'String Processing',
+    description: 'Work with text',
+    group: 'basics',
+    code: `function processText({ text = 'Hello World' }) {
+  let upper = text.toUpperCase()
+  let lower = text.toLowerCase()
+  let words = text.split(' ')
+  let wordCount = words.length
+  return { upper, lower, words, wordCount }
+}`,
+  },
+  {
+    name: 'JSON Processing',
+    description: 'Parse and stringify JSON',
+    group: 'basics',
+    code: `function jsonRoundTrip({ data = { name: 'Alice', age: 30 } }) {
+  let jsonStr = JSON.stringify(data)
+  let parsed = JSON.parse(jsonStr)
+  let name = parsed.name
+  return { jsonStr, parsed, name }
+}`,
+  },
+  {
+    name: 'Error Handling',
+    description: 'Try/catch with Error()',
+    group: 'basics',
+    code: `function safeDivide({ a = 10, b = 0 }) {
+  try {
+    if (b == 0) {
+      Error('Division by zero!')
+    }
+    let result = a / b
+    return { result }
+  } catch (err) {
+    return { error: err }
+  }
+}`,
+  },
+  {
+    name: 'Weather API',
+    description: 'Fetch weather data (no API key needed)',
+    group: 'api',
+    code: `function getWeather({ lat = 37.7749, lon = -122.4194 }) {
+  let url = \`https://api.open-meteo.com/v1/forecast?latitude=\${lat}&longitude=\${lon}&current_weather=true\`
+  let response = httpFetch({ url, cache: 1800 })
+  let weather = response.current_weather
+  return { weather }
+}`,
+  },
+  {
+    name: 'iTunes Search',
+    description: 'Search Apple iTunes catalog',
+    group: 'api',
+    code: `function searchMusic({ query = 'Beatles', limit = 5 }) {
+  let url = \`https://itunes.apple.com/search?term=\${query}&limit=\${limit}&media=music\`
+  let response = httpFetch({ url, cache: 3600 })
+  let tracks = response.results.map(x => ({
+    artist: x.artistName,
+    track: x.trackName,
+    album: x.collectionName
+  }))
+  return { tracks }
+}`,
+  },
+  {
+    name: 'GitHub Repos',
+    description: 'Search GitHub repositories',
+    group: 'api',
+    code: `function searchRepos({ query = 'tosijs', perPage = 5 }) {
+  let url = \`https://api.github.com/search/repositories?q=\${query}&per_page=\${perPage}&sort=stars\`
+  let response = httpFetch({ url, cache: 300 })
+  let repos = response.items.map(x => ({
+    name: x.full_name,
+    stars: x.stargazers_count,
+    description: x.description
+  }))
+  return { repos }
+}`,
+  },
+  {
+    name: 'LLM Chat',
+    description: 'Chat with AI (requires llm capability)',
+    group: 'llm',
+    requiresApi: true,
+    code: `function chat({ message = 'What is the capital of France?' }) {
+  // Requires llm.predict capability to be configured
+  let response = llmPredict({ prompt: message })
+  return { response }
+}`,
+  },
+  {
+    name: 'LLM Summarizer',
+    description: 'Fetch and summarize text (requires llm capability)',
+    group: 'llm',
+    requiresApi: true,
+    code: `function summarize({ source = 'coffee-origins' }) {
+  // Fetch text from our sample documents
+  // Options: 'coffee-origins', 'ai-history', 'renewable-energy'
+  let url = \`/texts/\${source}.txt\`
+  let text = httpFetch({ url })
+
+  let prompt = \`Summarize the following text in 2-3 sentences:\n\n\${text}\`
+  let summary = llmPredict({ prompt })
+  return { source, summary }
+}`,
+  },
+  {
+    name: 'LLM Structured Output',
+    description: 'Get structured JSON from LLM (requires llm capability)',
+    group: 'llm',
+    requiresApi: true,
+    code: `function extractInfo({ text = 'John Smith is a 35-year-old software engineer from San Francisco who loves hiking and photography.' }) {
+  // Schema.response builds responseFormat from an example
+  let schema = Schema.response('person_info', {
+    name: '',
+    age: 0,
+    occupation: '',
+    location: '',
+    hobbies: ['']
+  })
+
+  let prompt = \`Extract person info from this text: \${text}\`
+  let response = llmPredict({ prompt, options: { responseFormat: schema } })
+  let person = JSON.parse(response)
+  return { person }
+}`,
+  },
+  {
+    name: 'LLM + API Data',
+    description: 'LLM analyzes API data (requires llm capability)',
+    group: 'featured',
+    requiresApi: true,
+    code: `function findCovers({ song = 'Yesterday', artist = 'Beatles' }) {
+  // Search iTunes for the song
+  let query = song + ' ' + artist
+  let url = \`https://itunes.apple.com/search?term=\${query}&limit=25&media=music\`
+  let response = httpFetch({ url, cache: 3600 })
+
+  // Format results for LLM analysis
+  let results = response.results || []
+  let tracks = results.map(x => \`"\${x.trackName}" by \${x.artistName} (\${x.collectionName})\`)
+  let trackList = tracks.join('\\n')
+
+  // Schema.response from example - much cleaner!
+  let schema = Schema.response('cover_versions', {
+    covers: [{ track: '', artist: '', album: '' }]
+  })
+
+  let prompt = \`Search results for "\${song}" by \${artist}:
+
+\${trackList}
+
+List cover versions (tracks NOT by \${artist}).\`
+
+  let llmResponse = llmPredict({ prompt, options: { responseFormat: schema } })
+  let parsed = JSON.parse(llmResponse)
+  return { originalArtist: artist, song, covers: parsed.covers }
+}`,
+  },
+  {
+    name: 'LLM with Tool',
+    description: 'LLM uses a calculator tool (requires llm capability)',
+    group: 'advanced',
+    requiresApi: true,
+    code: `function mathAssistant({ question = 'What is 23 * 47 + 156?' }) {
+  // First, ask LLM to extract the calculation
+  let extractPrompt = \`Extract the math expression from this question. Return ONLY the expression, nothing else.
+Question: \${question}\`
+  let expression = llmPredict({ prompt: extractPrompt })
+
+  // Evaluate the expression (simple eval simulation)
+  let calcPrompt = \`Calculate: \${expression}
+Return ONLY the numeric result.\`
+  let calcResult = llmPredict({ prompt: calcPrompt })
+
+  // Format the answer
+  let answerPrompt = \`The user asked: "\${question}"
+The calculated result is: \${calcResult}
+Write a brief, friendly response with the answer.\`
+  let answer = llmPredict({ prompt: answerPrompt })
+
+  return { question, expression: expression.trim(), result: calcResult.trim(), answer }
+}`,
+  },
+  {
+    name: 'Multi-Agent Pipeline',
+    description: 'Two agents collaborate on a task (requires llm capability)',
+    group: 'advanced',
+    requiresApi: true,
+    code: `function collaborativeWriting({ topic = 'the future of renewable energy' }) {
+  // Agent 1: Research Agent - generates key points
+  let researchPrompt = \`You are a research agent. Generate 3 key facts or points about: \${topic}
+Format as a numbered list. Be concise.\`
+  let research = llmPredict({ prompt: researchPrompt })
+
+  // Agent 2: Writer Agent - creates content from research
+  let writerPrompt = \`You are a writer agent. Using these research points:
+
+\${research}
+
+Write a short, engaging paragraph (2-3 sentences) about \${topic}.
+Make it informative and accessible.\`
+  let article = llmPredict({ prompt: writerPrompt })
+
+  // Agent 3: Editor Agent - reviews and improves
+  let editorPrompt = \`You are an editor agent. Review this draft:
+
+"\${article}"
+
+Suggest one specific improvement. Then provide the improved version.
+Format: "Suggestion: [your suggestion]\\n\\nImproved: [improved text]"\`
+  let edited = llmPredict({ prompt: editorPrompt })
+
+  return {
+    topic,
+    researchPoints: research,
+    firstDraft: article,
+    editedVersion: edited
+  }
+}`,
+  },
+  {
+    name: 'Fuel Limits',
+    description: 'Demonstrates safe termination - try different fuel amounts!',
+    group: 'featured',
+    code: `function infiniteLoop({ limit = 1000000 }) {
+  // This will run out of fuel before completing
+  let counter = 0
+  let i = 0
+  while (i < limit) {
+    counter = counter + 1
+    i = i + 1
+  }
+  return { counter }
+}`,
+  },
+  {
+    name: 'Vision: OCR',
+    description: 'Extract text from an image (requires vision model)',
+    group: 'advanced',
+    requiresApi: true,
+    code: `function extractText({ imageUrl = '/photo-2.jpg' }) {
+  // Fetch image as data URL for vision model
+  let image = httpFetch({ url: imageUrl, responseType: 'dataUrl' })
+
+  // Use Schema.response for structured output
+  let schema = Schema.response('ocr_result', {
+    text: '',
+    items: [{ description: '', amount: '' }]
+  })
+
+  let result = llmVision({
+    prompt: 'Extract all text from this image. If it is a receipt, list the items and amounts.',
+    images: [image],
+    responseFormat: schema
+  })
+
+  let parsed = JSON.parse(result.content)
+  return { imageUrl, extracted: parsed }
+}`,
+  },
+  {
+    name: 'Vision: Classification',
+    description: 'Classify and describe an image (requires vision model)',
+    group: 'advanced',
+    requiresApi: true,
+    code: `function classifyImage({ imageUrl = '/photo-1.jpg' }) {
+  // Fetch image as data URL
+  let image = httpFetch({ url: imageUrl, responseType: 'dataUrl' })
+
+  // Schema for classification result
+  let schema = Schema.response('image_classification', {
+    category: '',
+    subject: '',
+    description: '',
+    tags: [''],
+    confidence: ''
+  })
+
+  let result = llmVision({
+    prompt: 'Classify this image. Identify the main subject, provide a brief description, and list relevant tags.',
+    images: [image],
+    responseFormat: schema
+  })
+
+  let parsed = JSON.parse(result.content)
+  return { imageUrl, classification: parsed }
+}`,
+  },
+  {
+    name: 'LLM Code Solver',
+    description:
+      'LLM writes and runs code to solve a problem (requires llm capability)',
+    group: 'advanced',
+    requiresApi: true,
+    code: `function solveWithCode({ problem = 'Calculate the 10th Fibonacci number' }) {
+  // System prompt with AsyncJS rules and example
+  let systemContext = \`You write AsyncJS code. AsyncJS is a JavaScript subset.
+
+RULES:
+- NO: async, await, new, class, this, var, for loops
+- Use let for variables, while for loops
+- Return an object: return { result }
+
+EXAMPLE (factorial):
+function solve() {
+  let result = 1
+  let i = 5
+  while (i > 1) {
+    result = result * i
+    i = i - 1
+  }
+  return { result }
+}
+
+Return ONLY the function code, nothing else.\`
+
+  let prompt = \`\${systemContext}
+
+Write a function called "solve" that: \${problem}\`
+
+  let response = llmPredict({ prompt })
+
+  // Clean up code - remove markdown fences, fix escapes, extract function
+  let code = response
+  code = code.replace(/\`\`\`(?:javascript|js|asyncjs)?\\n?/g, '')
+  code = code.replace(/\\n?\`\`\`/g, '')
+  code = code.replace(/\\\\n/g, '\\n')
+  code = code.replace(/\\\\t/g, '\\t')
+  code = code.replace(/\\\\"/g, '"')
+  code = code.trim()
+
+  // Try to extract just the function if there's extra text
+  let funcMatch = code.match(/function\\s+solve\\s*\\([^)]*\\)\\s*\\{[\\s\\S]*\\}/)
+  if (funcMatch) {
+    code = funcMatch[0]
+  }
+
+  // Validate it looks like a function before running
+  if (!code.startsWith('function')) {
+    return {
+      problem,
+      error: 'LLM did not generate valid code',
+      rawResponse: response
+    }
+  }
+
+  // Execute the generated code
+  let output = runCode({ code, args: {} })
+
+  return {
+    problem,
+    generatedCode: code,
+    result: output.result
+  }
+}`,
+  },
+  {
+    name: 'LLM Code Generator',
+    description:
+      'LLM writes AsyncJS code from a description (requires llm capability)',
+    group: 'advanced',
+    requiresApi: true,
+    code: `function generateCode({ task = 'Calculate the factorial of n' }) {
+  // System prompt with AsyncJS rules and complete example
+  let systemContext = \`You write AsyncJS code. AsyncJS is a subset of JavaScript.
+
+RULES:
+- Types by example: fn(n: 5) means required number param with example value 5
+- NO: async, await, new, class, this, var, for, generator functions (function*)
+- Use let for variables, while for loops
+- Return an object: return { result }
+
+EXAMPLE - calculating sum of 1 to n:
+function sumTo(n: 10) {
+  let sum = 0
+  let i = 1
+  while (i <= n) {
+    sum = sum + i
+    i = i + 1
+  }
+  return { result: sum }
+}\`
+
+  let schema = Schema.response('generated_code', {
+    code: '',
+    description: ''
+  })
+
+  let prompt = \`\${systemContext}
+
+Write an AsyncJS function for: \${task}
+
+Return ONLY valid AsyncJS code in the code field. Must start with "function" and use while loops (not for loops).\`
+
+  let response = llmPredict({ prompt, options: { responseFormat: schema } })
+  let result = JSON.parse(response)
+
+  // Clean up any markdown fences and fix escaped newlines
+  let code = result.code
+  code = code.replace(/\`\`\`(?:javascript|js)?\\n?/g, '')
+  code = code.replace(/\\n?\`\`\`/g, '')
+  code = code.replace(/\\\\n/g, '\\n')
+  code = code.replace(/\\\\t/g, '\\t')
+  code = code.trim()
+
+  return {
+    task,
+    code,
+    description: result.description
+  }
+}`,
+  },
+]