tjs-lang 0.6.28 → 0.6.31

package/bin/dev.ts

@@ -77,8 +77,8 @@ async function buildDemo() {
       naming: 'tjs-runtime.js',
     })
 
-    // Copy static files
-    await $`cp demo/index.html demo/static/favicon.svg demo/static/photo-*.jpg tjs-lang.svg .demo/`
+    // Copy static files (including TFS service worker — must not be bundled)
+    await $`cp demo/index.html demo/static/favicon.svg demo/static/photo-*.jpg tjs-lang.svg demo/src/tfs-worker.js .demo/`
     await $`cp -r demo/static/texts .demo/`
 
     console.log('Build complete!')
@@ -195,6 +195,111 @@ const server = Bun.serve({
       })
     }
 
+    // TFS proxy — resolve npm packages from jsdelivr CDN
+    // This is the server-side fallback when the service worker can't intercept
+    // (e.g. blob iframes, first load before SW is active)
+    if (pathname.startsWith('/tfs/')) {
+      const tfsPath = pathname.slice(5)
+      const CDN_BASE = 'https://cdn.jsdelivr.net/npm'
+
+      // Parse package@version/subpath
+      let name: string, version: string, subpath: string
+      if (tfsPath.startsWith('@')) {
+        const match = tfsPath.match(/^(@[^/]+\/[^/@]+)(?:@([^/]+))?(\/.*)?$/)
+        if (match) {
+          name = match[1]
+          version = match[2] || 'latest'
+          subpath = match[3] || ''
+        } else {
+          return new Response('invalid tfs path', { status: 400 })
+        }
+      } else {
+        const match = tfsPath.match(/^([^/@]+)(?:@([^/]+))?(\/.*)?$/)
+        if (match) {
+          name = match[1]
+          version = match[2] || 'latest'
+          subpath = match[3] || ''
+        } else {
+          return new Response('invalid tfs path', { status: 400 })
+        }
+      }
+
+      try {
+        // If no subpath, resolve ESM entry point from package.json
+        if (!subpath) {
+          const pkgRes = await fetch(
+            `${CDN_BASE}/${name}@${version}/package.json`
+          )
+          if (pkgRes.ok) {
+            const pkg = await pkgRes.json()
+            const exp = pkg.exports
+            let entryPath: string | null = null
+
+            if (exp) {
+              // exports can be { ".": { import: "..." } } or { import: "..." }
+              const dot = exp['.'] ?? exp
+              if (typeof dot === 'string') entryPath = dot
+              else if (dot?.import)
+                entryPath =
+                  typeof dot.import === 'string'
+                    ? dot.import
+                    : dot.import?.default
+              else if (dot?.default) entryPath = dot.default
+            }
+            if (!entryPath) entryPath = pkg.module || pkg.main || '/index.js'
+            subpath = entryPath!.startsWith('/')
+              ? entryPath!
+              : entryPath!.startsWith('./')
+              ? entryPath!.slice(1)
+              : `/${entryPath}`
+          }
+        }
+
+        const cdnUrl = `${CDN_BASE}/${name}@${version}${subpath}`
+        const cdnRes = await fetch(cdnUrl)
+        if (!cdnRes.ok) {
+          return new Response(`package not found: ${name}@${version}`, {
+            status: 404,
+          })
+        }
+
+        let body = await cdnRes.text()
+        const origin = new URL(req.url).origin
+        const pkgBase = `${CDN_BASE}/${name}@${version}`
+
+        // Rewrite imports in the fetched module:
+        // - Bare specifiers → /tfs/ (transitive deps)
+        // - Relative imports → absolute CDN URLs (sibling files)
+        body = body.replace(
+          /((?:import|export)\s+(?:[\w\s{},*]+\s+from\s+)?)(['"])([^'"]+)\2/g,
+          (match: string, prefix: string, quote: string, spec: string) => {
+            if (spec.startsWith('http://') || spec.startsWith('https://'))
+              return match
+            if (spec.startsWith('./') || spec.startsWith('../')) {
+              // Relative import → resolve against CDN package path
+              const dir = subpath ? subpath.replace(/\/[^/]*$/, '') : '/dist'
+              // Add .js extension if missing (CDN requires it)
+              const specWithExt = /\.\w+$/.test(spec) ? spec : `${spec}.js`
+              const resolved = new URL(specWithExt, `${pkgBase}${dir}/`).href
+              return `${prefix}${quote}${resolved}${quote}`
+            }
+            if (spec.startsWith('/')) return match
+            // Bare specifier → route through /tfs/
+            return `${prefix}${quote}${origin}/tfs/${spec}${quote}`
+          }
+        )
+
+        return new Response(body, {
+          headers: {
+            'Content-Type': 'application/javascript',
+            'Access-Control-Allow-Origin': '*',
+          },
+        })
+      } catch (err: any) {
+        return new Response(`tfs error: ${err.message}`, { status: 502 })
+      }
+    }
+
     // For SPA routing, serve index.html for unknown paths
     const indexFile = Bun.file(join(DOCS_DIR, 'index.html'))
     if (await indexFile.exists()) {

package/demo/src/imports.test.ts

@@ -1,206 +1,91 @@
 /**
- * Unit tests for import resolution infrastructure
- *
- * Tests the synchronous functions that don't require browser/network.
+ * Unit tests for TFS import resolution
  */
 
 import { describe, it, expect } from 'bun:test'
-import {
-  extractImports,
-  getCDNUrl,
-  generateImportMap,
-  generateImportMapScript,
-  wrapAsModule,
-  clearModuleCache,
-  getCacheStats,
-} from './imports'
+import { extractImports, rewriteImports } from './imports'
 
 describe('extractImports', () => {
   it('should extract named imports', () => {
-    const source = `import { foo, bar } from 'some-package'`
-    expect(extractImports(source)).toEqual(['some-package'])
+    expect(extractImports(`import { foo } from 'pkg'`)).toEqual(['pkg'])
   })
 
   it('should extract default imports', () => {
-    const source = `import React from 'react'`
-    expect(extractImports(source)).toEqual(['react'])
-  })
-
-  it('should extract namespace imports', () => {
-    const source = `import * as lodash from 'lodash'`
-    expect(extractImports(source)).toEqual(['lodash'])
-  })
-
-  it('should extract side-effect imports', () => {
-    const source = `import 'polyfill'`
-    expect(extractImports(source)).toEqual(['polyfill'])
-  })
-
-  it('should extract re-exports', () => {
-    const source = `export { foo } from 'some-package'`
-    expect(extractImports(source)).toEqual(['some-package'])
-  })
-
-  it('should handle multiple imports', () => {
-    const source = `
-      import { add } from 'lodash'
-      import { format } from 'date-fns'
-      import React from 'react'
-    `
-    expect(extractImports(source)).toEqual(['lodash', 'date-fns', 'react'])
-  })
-
-  it('should deduplicate imports', () => {
-    const source = `
-      import { add } from 'lodash'
-      import { subtract } from 'lodash'
-    `
-    expect(extractImports(source)).toEqual(['lodash'])
+    expect(extractImports(`import React from 'react'`)).toEqual(['react'])
   })
 
   it('should ignore relative imports', () => {
-    const source = `
-      import { foo } from './local'
-      import { bar } from '../parent'
-      import { baz } from '/absolute'
-      import { qux } from 'npm-package'
-    `
-    expect(extractImports(source)).toEqual(['npm-package'])
-  })
-
-  it('should handle subpath imports', () => {
-    const source = `import { debounce } from 'lodash/debounce'`
-    expect(extractImports(source)).toEqual(['lodash/debounce'])
-  })
-
-  it('should handle scoped packages', () => {
-    const source = `import { something } from '@scope/package'`
-    expect(extractImports(source)).toEqual(['@scope/package'])
+    expect(
+      extractImports(`import { a } from './local'\nimport { b } from 'pkg'`)
+    ).toEqual(['pkg'])
   })
 
-  it('should handle scoped packages with subpaths', () => {
-    const source = `import { util } from '@scope/package/utils'`
-    expect(extractImports(source)).toEqual(['@scope/package/utils'])
+  it('should handle versioned specifiers', () => {
+    expect(extractImports(`import { x } from 'tosijs@1.3.11'`)).toEqual([
+      'tosijs@1.3.11',
+    ])
   })
 
-  it('should handle double quotes', () => {
-    const source = `import { foo } from "some-package"`
-    expect(extractImports(source)).toEqual(['some-package'])
-  })
-
-  it('should return empty array for no imports', () => {
-    const source = `const x = 1; function foo() { return x }`
-    expect(extractImports(source)).toEqual([])
+  it('should deduplicate', () => {
+    expect(
+      extractImports(`import { a } from 'pkg'\nimport { b } from 'pkg'`)
+    ).toEqual(['pkg'])
   })
 })
 
-describe('getCDNUrl', () => {
-  it('should generate URL for simple package', () => {
-    expect(getCDNUrl('some-unknown-package')).toBe(
-      'https://cdn.jsdelivr.net/npm/some-unknown-package'
+describe('rewriteImports', () => {
+  it('should rewrite bare specifiers to /tfs/', () => {
+    expect(rewriteImports(`import { foo } from 'tosijs'`)).toBe(
+      `import { foo } from '/tfs/tosijs'`
     )
   })
 
-  it('should use pinned version and path for known packages', () => {
-    // tosijs has pinned version and path
-    expect(getCDNUrl('tosijs')).toBe(
-      'https://cdn.jsdelivr.net/npm/tosijs@1.2.0/dist/module.js'
-    )
-    // date-fns has pinned version but no path
-    expect(getCDNUrl('date-fns')).toBe(
-      'https://cdn.jsdelivr.net/npm/date-fns@3.6.0'
+  it('should handle versioned specifiers', () => {
+    expect(rewriteImports(`import { x } from 'tosijs@1.3.11'`)).toBe(
+      `import { x } from '/tfs/tosijs@1.3.11'`
     )
   })
 
-  it('should handle subpath imports with pinned version', () => {
-    expect(getCDNUrl('lodash-es/debounce')).toBe(
-      'https://cdn.jsdelivr.net/npm/lodash-es@4.17.21/debounce'
-    )
+  it('should handle subpath imports', () => {
+    expect(
+      rewriteImports(`import { debounce } from 'lodash-es/debounce'`)
+    ).toBe(`import { debounce } from '/tfs/lodash-es/debounce'`)
   })
 
   it('should handle scoped packages', () => {
-    expect(getCDNUrl('@scope/package')).toBe(
-      'https://cdn.jsdelivr.net/npm/@scope/package'
+    expect(rewriteImports(`import { x } from '@scope/pkg'`)).toBe(
+      `import { x } from '/tfs/@scope/pkg'`
     )
   })
 
-  it('should handle scoped packages with subpaths', () => {
-    expect(getCDNUrl('@scope/package/utils')).toBe(
-      'https://cdn.jsdelivr.net/npm/@scope/package/utils'
+  it('should not rewrite relative imports', () => {
+    expect(rewriteImports(`import { x } from './local'`)).toBe(
+      `import { x } from './local'`
     )
   })
 
-  it('should handle packages with pinned version but no path', () => {
-    // lodash-es is pinned but has no explicit path
-    expect(getCDNUrl('lodash-es')).toBe(
-      'https://cdn.jsdelivr.net/npm/lodash-es@4.17.21'
+  it('should not rewrite absolute imports', () => {
+    expect(rewriteImports(`import { x } from '/abs/path'`)).toBe(
+      `import { x } from '/abs/path'`
     )
   })
-})
-
-describe('generateImportMap', () => {
-  it('should generate import map for specifiers', () => {
-    const result = generateImportMap(['tosijs', 'date-fns'])
-    expect(result).toEqual({
-      imports: {
-        tosijs: 'https://cdn.jsdelivr.net/npm/tosijs@1.2.0/dist/module.js',
-        'date-fns': 'https://cdn.jsdelivr.net/npm/date-fns@3.6.0',
-      },
-    })
-  })
 
-  it('should handle empty array', () => {
-    expect(generateImportMap([])).toEqual({ imports: {} })
+  it('should not rewrite http imports', () => {
+    expect(
+      rewriteImports(`import { x } from 'https://cdn.example.com/pkg.js'`)
+    ).toBe(`import { x } from 'https://cdn.example.com/pkg.js'`)
   })
 
-  it('should handle subpath imports', () => {
-    const result = generateImportMap(['lodash-es/debounce'])
-    expect(result.imports['lodash-es/debounce']).toBe(
-      'https://cdn.jsdelivr.net/npm/lodash-es@4.17.21/debounce'
-    )
+  it('should handle multiple imports', () => {
+    const source = `import { a } from 'pkg-a'\nimport { b } from 'pkg-b'`
+    const result = rewriteImports(source)
+    expect(result).toContain("from '/tfs/pkg-a'")
+    expect(result).toContain("from '/tfs/pkg-b'")
   })
-})
-
-describe('generateImportMapScript', () => {
-  it('should generate script tag with import map', () => {
-    const importMap = {
-      imports: {
-        tosijs: 'https://cdn.jsdelivr.net/npm/tosijs@1.0.10/dist/module.js',
-      },
-    }
-    const script = generateImportMapScript(importMap)
 
-    expect(script).toContain('<script type="importmap">')
-    expect(script).toContain('</script>')
-    expect(script).toContain('"tosijs"')
-    expect(script).toContain(
-      'https://cdn.jsdelivr.net/npm/tosijs@1.0.10/dist/module.js'
+  it('should handle re-exports', () => {
+    expect(rewriteImports(`export { foo } from 'pkg'`)).toBe(
+      `export { foo } from '/tfs/pkg'`
     )
   })
 })
-
-describe('wrapAsModule', () => {
-  it('should wrap code in module script tag', () => {
-    const code = 'console.log("hello")'
-    const wrapped = wrapAsModule(code)
-
-    expect(wrapped).toContain('<script type="module">')
-    expect(wrapped).toContain('</script>')
-    expect(wrapped).toContain(code)
-  })
-})
-
-describe('module cache', () => {
-  it('should start empty', () => {
-    clearModuleCache()
-    const stats = getCacheStats()
-    expect(stats.size).toBe(0)
-    expect(stats.entries).toEqual([])
-  })
-
-  it('should clear cache', () => {
-    // Just verify it doesn't throw
-    clearModuleCache()
-    expect(getCacheStats().size).toBe(0)
-  })
-})