rnxsim 0.1.519 → 0.1.521

package/src/vite-plugin-swift.ts

@@ -16,18 +16,20 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { promisify } from 'node:util'
+import toolchain from '../../sootsim-swift/toolchain.json'
 import type { Plugin, ViteDevServer } from 'vite'
 
 const run = promisify(execFile)
 
-// the toolchain layout scripts/build.sh pins. xcode's swift has no wasm
-// backend, so the swift.org toolchain and its matching wasm sdk are the only
-// ones that can build this target.
+// the swift.org release scripts/build.sh builds with, from the one place it is
+// named: the toolchain is <release>.xctoolchain and its matching wasm sdk is
+// <release>_wasm. xcode's swift has no wasm backend, so this toolchain is the
+// only one that can build the target.
 const TOOLCHAIN_BIN = path.join(
   os.homedir(),
-  'Library/Developer/Toolchains/swift-6.2-RELEASE.xctoolchain/usr/bin',
+  `Library/Developer/Toolchains/${toolchain.release}.xctoolchain/usr/bin`,
 )
-const WASM_SDK = 'swift-6.2-RELEASE_wasm'
+const WASM_SDK = `${toolchain.release}_wasm`
 const WASM_TRIPLE = 'wasm32-unknown-wasip1'
 
 const ARTIFACT_PATH = '/__rnx/swift/'
@@ -61,35 +63,71 @@ function projectFor(packagePath: string): SwiftProject {
   return created
 }
 
-function rootFor(file: string): string {
-  return devServer?.config.root ?? path.dirname(file)
-}
-
 // the compile unit is the whole package: `swift build` compiles every source
-// in it, so one file's edit can change the artifact for all of them.
-function sourceFiles(packagePath: string): string[] {
+// in it, so one file's edit can change the artifact for all of them. also
+// used for a linked module below, whose own nested packages are separate
+// units by the same rule.
+function sourceFiles(root: string): string[] {
   const found: string[] = []
   const walk = (dir: string): void => {
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith('.') || entry.name === 'node_modules') continue
       const full = path.join(dir, entry.name)
-      if (entry.isDirectory()) walk(full)
-      else if (entry.name.endsWith('.swift')) found.push(full)
+      // a nested Package.swift is a separate package with its own compile:
+      // its sources belong to that unit's stamp, not this one's
+      if (entry.isDirectory()) {
+        if (full !== root && fs.existsSync(path.join(full, 'Package.swift'))) continue
+        walk(full)
+      } else if (entry.name.endsWith('.swift')) found.push(full)
     }
   }
-  walk(packagePath)
+  walk(root)
   return found
 }
 
-function sourceStamp(packagePath: string): string {
+// the SwiftUI module the project links: its manifest names it as a path
+// dependency, and `swift build` compiles it with the project, so an edit
+// there changes the artifact without moving any of the project's own mtimes.
+export function linkedModuleRoots(packagePath: string): string[] {
+  let manifest: string
+  try {
+    manifest = fs.readFileSync(path.join(packagePath, 'Package.swift'), 'utf8')
+  } catch {
+    return []
+  }
+  const roots = new Set<string>()
+  const dependency = /\.package\(\s*path:\s*"([^"]+)"\s*\)/g
+  for (const match of manifest.replace(/^\s*\/\/.*$/gm, '').matchAll(dependency)) {
+    const root = path.resolve(packagePath, match[1])
+    if (fs.existsSync(path.join(root, 'Package.swift'))) roots.add(root)
+  }
+  return [...roots].sort()
+}
+
+// the stamp covers the project plus the modules it links: a running dev
+// server rebuilds only when this moves, so leaving the linked sources out
+// would keep serving the artifact built before a SwiftUI module edit for as
+// long as the project's own sources stayed the same. mirrors the compile
+// service's artifact hash, which names the same closure.
+export function sourceStamp(packagePath: string): string {
   const hash = createHash('sha256')
-  for (const file of sourceFiles(packagePath).sort()) {
-    hash.update(path.relative(packagePath, file))
-    hash.update(String(fs.statSync(file).mtimeMs))
+  for (const root of [packagePath, ...linkedModuleRoots(packagePath)]) {
+    hash.update(root)
+    for (const file of sourceFiles(root).sort()) {
+      hash.update(path.relative(root, file))
+      hash.update(String(fs.statSync(file).mtimeMs))
+    }
   }
   return hash.digest('hex').slice(0, 16)
 }
 
+// the registry slot for a view: the owning package plus the source within
+// it. two packages in one app can hold the same filename, and a bare
+// relative path would share one slot, one instance, and its state.
+export function viewRootId(packagePath: string, file: string): string {
+  return path.join(packagePath, path.relative(packagePath, file))
+}
+
 // the app fetches the artifact from a worker whose origin is the shell, so the
 // url has to name this dev server rather than resolve relative to the shell.
 function artifactUrl(project: SwiftProject, artifact: SwiftArtifact): string {
@@ -171,20 +209,62 @@ function artifactFor(project: SwiftProject): Promise<SwiftArtifact> {
   return project.building
 }
 
+// the swiftpm package that owns an imported file: the nearest directory at
+// or above the file that holds a Package.swift, stopping at the vite root
+// once the dev server has named it. a swift-only project keeps its sources at
+// the root so that is its package; a React Native app keeps its in a
+// subdirectory (a `native/` package beside the js), and each such package
+// compiles on its own.
+function packageFor(file: string): string {
+  let dir = path.dirname(file)
+  const stop = devServer?.config.root
+  for (;;) {
+    if (fs.existsSync(path.join(dir, 'Package.swift'))) return dir
+    if ((stop !== undefined && dir === stop) || path.dirname(dir) === dir) break
+    dir = path.dirname(dir)
+  }
+  throw new Error(
+    `no Package.swift above ${file}${stop === undefined ? '' : ` (searched up to ${stop})`}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`,
+  )
+}
+
+// whether the package mounts as a view: its @main type conforms to
+// RNXPackage instead of to App. the symbol graph is the exact read once the
+// transform emits one; until then the conformance on the @main declaration is
+// unambiguous, comments aside.
+function isViewPackage(packagePath: string): boolean {
+  const main =
+    /@main\s+(?:\w+\s+)*(?:struct|class|enum|actor)\s+\w+[^{]*:\s*[^{]*\bRNXPackage\b/
+  for (const file of sourceFiles(packagePath)) {
+    const text = fs.readFileSync(file, 'utf8').replace(/^\s*\/\/.*$/gm, '')
+    if (main.test(text)) return true
+  }
+  return false
+}
+
 export interface SwiftPluginOptions {
   // swiftpm package that owns the project's .swift sources. defaults to the
-  // vite root, which is the layout a swift-only project uses.
+  // nearest Package.swift above each imported file, which is the vite root
+  // for the layout a swift-only project uses.
   packagePath?: string
 }
 
 export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
-  const packagePathFor = (file: string): string => options.packagePath ?? rootFor(file)
-
   return {
     name: 'rnx-swift',
     enforce: 'pre',
 
     async resolveId(source, importer) {
+      if (source.startsWith(VIRTUAL_PREFIX)) return source
+      // import-analysis re-resolves the served URL form of the id
+      // (/@id/__x00__..., with the null byte encoded) while transforming the
+      // importer. it still names this module, so answer the decoded id; any
+      // other /@id/ url is already resolved and must not fall through to the
+      // filesystem resolve below, which would throw for it.
+      if (source.startsWith('/@id/')) {
+        const decoded = source.slice('/@id/'.length).replace(/^__x00__/, '\0')
+        return decoded.startsWith(VIRTUAL_PREFIX) ? decoded : null
+      }
       if (!source.endsWith('.swift')) return null
       const resolved = await this.resolve(source, importer, { skipSelf: true })
       if (!resolved) throw new Error(`cannot resolve swift source ${source}`)
@@ -193,13 +273,21 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
 
     async load(id) {
       if (!id.startsWith(VIRTUAL_PREFIX)) return null
-      const packagePath = packagePathFor(id.slice(VIRTUAL_PREFIX.length))
+      const file = id.slice(VIRTUAL_PREFIX.length)
+      const packagePath = options.packagePath ?? packageFor(file)
       const project = projectFor(packagePath)
       // every source in the package is a dependency of this module, so a
       // bundler watching this module learns about a `.swift` edit and re-runs
       // load. that is the whole hot reload: the new hash in the emitted module
       // is what tells the mount it is looking at a different app.
       for (const source of sourceFiles(packagePath)) this.addWatchFile(source)
+      // an edit to the linked SwiftUI module rebuilds the artifact without
+      // touching the project's own sources, so those files gate the reload
+      // too: the new hash in the emitted module is what tells the mount it
+      // is looking at a different app.
+      for (const root of linkedModuleRoots(packagePath)) {
+        for (const source of sourceFiles(root)) this.addWatchFile(source)
+      }
       let artifact: SwiftArtifact
       try {
         artifact = await artifactFor(project)
@@ -213,6 +301,18 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
         this.warn(error instanceof Error ? error.message : String(error))
         artifact = project.artifact
       }
+      // a view package mounts into its importer: the default export is the
+      // view component, rooted by its package and source path so a hot reload
+      // finds the same instance. an app package keeps the root component it
+      // always had.
+      if (isViewPackage(packagePath)) {
+        const rootId = viewRootId(packagePath, file)
+        return [
+          `import { createSwiftView } from 'rnxsim/swift'`,
+          `export default createSwiftView({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)}, rootId: ${JSON.stringify(rootId)} })`,
+          '',
+        ].join('\n')
+      }
       return [
         `import { createSwiftModule } from 'rnxsim/swift'`,
         `export default createSwiftModule({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)} })`,
@@ -222,7 +322,6 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
 
     configureServer(server) {
       devServer = server
-      const packagePath = packagePathFor('')
 
       server.middlewares.use((req, res, next) => {
         const url = (req.url ?? '').split('?')[0]
@@ -230,24 +329,27 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
           next()
           return
         }
-        const project = projectFor(packagePath)
-        void artifactFor(project).then(
-          (artifact) => {
-            if (url !== `${ARTIFACT_PATH}${artifact.hash}.wasm`) {
-              res.statusCode = 404
-              res.end('swift artifact is stale')
+        // the url names a content hash, not a package: the request is answered
+        // by whichever known project built it, so a React Native app whose
+        // swift package sits below its root serves the same path its imports
+        // compiled.
+        void (async () => {
+          for (const project of projects.values()) {
+            const artifact = await artifactFor(project)
+            if (url === `${ARTIFACT_PATH}${artifact.hash}.wasm`) {
+              // the tenant worker's origin is the shell, never this dev server
+              res.setHeader('access-control-allow-origin', '*')
+              res.setHeader('content-type', 'application/wasm')
+              res.end(artifact.bytes)
               return
             }
-            // the tenant worker's origin is the shell, never this dev server
-            res.setHeader('access-control-allow-origin', '*')
-            res.setHeader('content-type', 'application/wasm')
-            res.end(artifact.bytes)
-          },
-          (error: unknown) => {
-            res.statusCode = 500
-            res.end(error instanceof Error ? error.message : String(error))
-          },
-        )
+          }
+          res.statusCode = 404
+          res.end('swift artifact is stale')
+        })().catch((error: unknown) => {
+          res.statusCode = 500
+          res.end(error instanceof Error ? error.message : String(error))
+        })
       })
     },
   }