rnxsim 0.1.520 → 0.1.522

package/src/vite-plugin-swift.ts

@@ -47,7 +47,8 @@ interface SwiftArtifact {
 interface SwiftProject {
   packagePath: string
   artifact: SwiftArtifact | null
-  building: Promise<SwiftArtifact> | null
+  // the build in flight and the sources it was started from
+  building: { stamp: string; promise: Promise<SwiftArtifact> } | null
 }
 
 // a project is its swiftpm package: the build, the artifact, and the dev
@@ -63,35 +64,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 {
@@ -120,6 +157,12 @@ function builtArtifact(packagePath: string): string {
   return path.join(binDir, artifacts[0])
 }
 
+function streamText(value: unknown): string {
+  if (typeof value === 'string') return value.trim()
+  if (Buffer.isBuffer(value)) return value.toString('utf8').trim()
+  return ''
+}
+
 async function compile(packagePath: string, stamp: string): Promise<SwiftArtifact> {
   const swift = path.join(TOOLCHAIN_BIN, 'swift')
   if (!fs.existsSync(swift)) {
@@ -144,9 +187,24 @@ async function compile(packagePath: string, stamp: string): Promise<SwiftArtifac
       { maxBuffer: 64 * 1024 * 1024 },
     )
   } catch (error) {
-    throw new Error(
-      `swift build failed for ${packagePath}\n${error instanceof Error ? error.message : String(error)}`,
-    )
+    // `swift build` prints the compiler's diagnostics on stdout and swiftpm's
+    // own on stderr; the failure's message holds only the command line, so
+    // both streams are what names the line that broke. stdout leads because
+    // compiler diagnostics are what the editor needs to show.
+    const streams =
+      error && typeof error === 'object'
+        ? [
+            streamText(Reflect.get(error, 'stdout')),
+            streamText(Reflect.get(error, 'stderr')),
+          ].filter(Boolean)
+        : []
+    const detail =
+      streams.length > 0
+        ? streams.join('\n')
+        : error instanceof Error
+          ? error.message
+          : String(error)
+    throw new Error(`swift build failed for ${packagePath}\n${detail}`)
   }
   const bytes = fs.readFileSync(builtArtifact(packagePath))
   return {
@@ -159,7 +217,17 @@ async function compile(packagePath: string, stamp: string): Promise<SwiftArtifac
 function artifactFor(project: SwiftProject): Promise<SwiftArtifact> {
   const stamp = sourceStamp(project.packagePath)
   if (project.artifact?.stamp === stamp) return Promise.resolve(project.artifact)
-  project.building ??= compile(project.packagePath, stamp).then(
+  if (project.building) {
+    // a second edit during a build: the build in flight was started from
+    // older sources, so its artifact is not the answer for these. wait it out
+    // and ask again, which starts the build these sources need; joining it
+    // would emit the older artifact and nothing would trigger another load.
+    const running = project.building
+    if (running.stamp === stamp) return running.promise
+    const again = () => artifactFor(project)
+    return running.promise.then(again, again)
+  }
+  const promise = compile(project.packagePath, stamp).then(
     (artifact) => {
       project.artifact = artifact
       project.building = null
@@ -170,18 +238,51 @@ function artifactFor(project: SwiftProject): Promise<SwiftArtifact> {
       throw error
     },
   )
-  return project.building
+  project.building = { stamp, promise }
+  return promise
+}
+
+// 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',
@@ -205,13 +306,25 @@ 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)
+      // the module is the whole package's artifact, so an import of a file
+      // that was deleted would keep answering with it. a deleted .tsx fails
+      // its importer; so does a deleted .swift.
+      if (!fs.existsSync(file)) throw new Error(`swift source ${file} no longer exists`)
+      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)
@@ -225,6 +338,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)} })`,
@@ -234,7 +359,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]
@@ -242,24 +366,26 @@ 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')
-              return
-            }
+        // 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. served from what is already built, never rebuilt here: the
+        // page only knows a hash that `load` emitted, and `load` under a compile
+        // error emits the last good hash, whose bytes are still the project's
+        // artifact. rebuilding would fail that fetch with the compile error and
+        // fail every other project's artifact with it.
+        for (const project of projects.values()) {
+          const artifact = project.artifact
+          if (artifact && 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)
-          },
-          (error: unknown) => {
-            res.statusCode = 500
-            res.end(error instanceof Error ? error.message : String(error))
-          },
-        )
+            return
+          }
+        }
+        res.statusCode = 404
+        res.end('swift artifact is stale')
       })
     },
   }