@exodus/stasis-plugins 1.0.0-beta.12 → 1.0.0-beta.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/stasis-plugins",
-  "version": "1.0.0-beta.12",
+  "version": "1.0.0-beta.13",
   "description": "Bundler plugins (webpack, esbuild, Rollup, Metro) for @exodus/stasis-core",
   "type": "module",
   "exports": {
@@ -36,6 +36,6 @@
   },
   "homepage": "https://github.com/PreventiveMeasures/stasis#readme",
   "dependencies": {
-    "@exodus/stasis-core": "1.0.0-beta.12"
+    "@exodus/stasis-core": "1.0.0-beta.13"
   }
 }

package/src/metro-babel-transformer.js

@@ -30,11 +30,21 @@ function isDependencyCall(callee) {
     callee.property.type === 'Identifier' && REQUIRE_MEMBERS.has(callee.property.name)
 }
 
-// The specifier a dependency node holds as a string literal: an import/export's source, a call's
-// first argument. A plugin rewriting it replaces the literal, never the node holding it.
+// The string `node` holds as a constant: a literal, a template with no substitutions, or a `+` of
+// such, which Metro's collectDependencies evaluates to the specifier as it does a literal.
+function constantString(node) {
+  if (node?.type === 'StringLiteral') return node.value
+  if (node?.type === 'TemplateLiteral' && node.expressions.length === 0) return node.quasis[0].value.cooked ?? undefined
+  if (node?.type !== 'BinaryExpression' || node.operator !== '+') return undefined
+  const left = constantString(node.left)
+  const right = left === undefined ? undefined : constantString(node.right)
+  return right === undefined ? undefined : left + right
+}
+
+// The specifier a dependency node holds as a constant: an import/export's source, a call's first
+// argument. A plugin rewriting it replaces the literal, never the node holding it.
 function specifierOf(node) {
-  const literal = node.type === 'CallExpression' ? node.arguments[0] : node.source
-  return literal?.type === 'StringLiteral' ? literal.value : undefined
+  return constantString(node.type === 'CallExpression' ? node.arguments[0] : node.source)
 }
 
 function asWrittenPlugin({ types: t }) {
@@ -42,10 +52,22 @@ function asWrittenPlugin({ types: t }) {
     name: 'stasis-as-written',
     pre(file) {
       const { slots } = transformContext.getStore()
+      let evaluate = false
       t.traverseFast(file.ast, (node) => {
         if (node.type === 'CallExpression' ? !isDependencyCall(node.callee) : !DECLARATIONS.has(node.type)) return
         const written = specifierOf(node)
         if (written !== undefined) slots.push({ node, written })
+        else if (node.type === 'CallExpression' && node.arguments.length > 0) evaluate = true
+      })
+      // Metro takes any argument Babel evaluates to a string with confidence, one bound to a constant
+      // too (`const name = './x'; require(name)`), which only a path, and its scope, can evaluate.
+      if (!evaluate) return
+      file.path.traverse({
+        CallExpression(path) {
+          if (!isDependencyCall(path.node.callee) || specifierOf(path.node) !== undefined || path.node.arguments.length === 0) return
+          const { confident, value } = path.get('arguments.0').evaluate()
+          if (confident && typeof value === 'string') slots.push({ node: path.node, written: value })
+        },
       })
     },
     visitor: {
@@ -73,7 +95,8 @@ export function transform(args) {
   const collect = (result) => {
     for (const { node, written } of slots) {
       if (DECLARATIONS.has(node.type) && !kept.has(node)) continue
-      const left = specifierOf(node)
+      // One evaluated through its scope stays as written: no plugin rewrites what isn't a literal.
+      const left = specifierOf(node) ?? (node.type === 'CallExpression' ? written : undefined)
       if (left === undefined) continue
       if (!context.asWritten.has(left)) context.asWritten.set(left, new Set())
       context.asWritten.get(left).add(written)

package/src/metro-transformer.js

@@ -88,14 +88,18 @@ function resolveBabelTransformer(base, path) {
   return isAbsolute(path) ? path : createRequire(base.file).resolve(path)
 }
 
-// Each dependency named by a specifier Babel rewrote, with the ones written in the source. One
-// Metro dependency can stand for several, written apart and rewritten alike (`#local/abc` and
-// `./src/abc`); a dependency written as Metro names it is left as is.
+// Each dependency as the source wrote it. One named by a specifier Babel rewrote carries the ones
+// written in the source: one Metro dependency can stand for several, written apart and rewritten
+// alike (`#local/abc` and `./src/abc`). One no specifier in the source names carries
+// `stasisInserted`: Babel added it (a helper from @babel/runtime, the JSX runtime), or Metro did (its
+// asyncRequire for an `import()`, an asset's registry). A dependency written as Metro names it is
+// left as is.
 function withAsWritten(result, asWritten) {
-  if (asWritten.size === 0 || !Array.isArray(result?.dependencies)) return result
+  if (!Array.isArray(result?.dependencies)) return result
   const dependencies = result.dependencies.map((dep) => {
     const written = asWritten.get(dep.name)
-    if (written === undefined || (written.size === 1 && written.has(dep.name))) return dep
+    if (written === undefined) return { ...dep, stasisInserted: true }
+    if (written.size === 1 && written.has(dep.name)) return dep
     return { ...dep, stasisAsWritten: [...written] }
   })
   return { ...result, dependencies }

package/src/metro.js

@@ -3,7 +3,7 @@ import { isUtf8 } from 'node:buffer'
 import { spawnSync } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { createRequire } from 'node:module'
-import { isAbsolute, join } from 'node:path'
+import { dirname, isAbsolute, join } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
 import { resolvePluginState } from './plugins.js'
@@ -40,6 +40,23 @@ const AUTO_INCLUDES = [
   '@react-native-community/cli/setup_env.sh',
 ]
 
+// Metro's own transform plugins, as its transform worker names them for its cache key: the file
+// `metro-transform-plugins` resolves to from the project, else through metro and its transform
+// worker, which depend on it (a pnpm install links it only beside them). -> [] where none resolves
+function metroTransformPluginFiles(projectDir) {
+  for (const chain of [['metro-transform-plugins'], ['metro', 'metro-transform-worker', 'metro-transform-plugins']]) {
+    let file
+    try {
+      for (const name of chain) file = require.resolve(name, { paths: [file === undefined ? projectDir : dirname(file)] })
+    } catch {
+      continue
+    }
+    const { getTransformPluginCacheKeyFiles } = require(file)
+    return typeof getTransformPluginCacheKeyFiles === 'function' ? getTransformPluginCacheKeyFiles() : []
+  }
+  return []
+}
+
 // The worker-side toolchain that only Metro's transform workers load, named in both the
 // --child-process assert and the transform-cache warning so the two can't describe different sets.
 const WORKER_TOOLCHAIN = 'babel.config.js, @babel/core, the RN preset + plugins'
@@ -252,17 +269,18 @@ export class StasisMetro {
     // AFTER the graph so #seen already holds graph modules -- an auto-include that landed in the
     // graph (asyncRequire, when the app uses dynamic import()) is deduped, not re-recorded.
     this.#captureAutoIncludes()
+    this.#captureTransformPlugins()
     // AFTER the graph + auto-includes (same dedupe reason): the native pass only adds the native
     // build-input surface (podspec/gradle/sources) that no module graph carries.
     this.#captureNativeModules()
   }
 
-  // Shared epilogue for the classify-driven capture paths: record under the given format/resource.
-  // `format` null/undefined lets addFile pick (loader format for JS unless `inferFormat` is false,
-  // byte-derived for a resource); addFile already asserts UTF-8 for a non-resource (code) source, so
-  // no guard is needed here.
-  #recordCapture(full, source, { format, resource, inferFormat = true }) {
-    this.#state.addFile(pathToFileURL(full).toString(), { source, format: format ?? undefined, resource, inferFormat, reason: 'metro' })
+  // Shared epilogue for the classify-driven capture paths: record under the given format/resource,
+  // attributed to `reason`. `format` null/undefined lets addFile pick (loader format for JS unless
+  // `inferFormat` is false, byte-derived for a resource); addFile already asserts UTF-8 for a
+  // non-resource (code) source, so no guard is needed here.
+  #recordCapture(full, source, { format, resource, inferFormat = true, reason = 'metro' }) {
+    this.#state.addFile(pathToFileURL(full).toString(), { source, format: format ?? undefined, resource, inferFormat, reason })
   }
 
   // Attest the AUTO_INCLUDES list. Per entry, skip: unresolvable, already-seen, or resolving
@@ -293,6 +311,31 @@ export class StasisMetro {
     }
   }
 
+  // Attest each of Metro's own transform plugins (metroTransformPluginFiles). Its transform worker
+  // hashes every one into its cache key, but loads one only as the build's options call for it
+  // (import-export-plugin under `experimentalImportSupport`, inline-requires-plugin under
+  // `inlineRequires`, constant-folding-plugin outside dev, normalizePseudoGlobals when minifying), so
+  // a capture loads them all, as Metro would: under `stasis run` the loader then records each with
+  // what it imports, so a bundle builds under any of those options. Each is recorded besides, as the
+  // Node module it is, where no loader records it, attributed to `run` as one Metro loads is: the
+  // build's toolchain, none of it the app's. One outside the project root is passed over.
+  #captureTransformPlugins() {
+    for (const file of metroTransformPluginFiles(this.#projectDir)) {
+      if (this.#seen.has(file)) continue
+      try {
+        this.#state.relative(file)
+      } catch {
+        continue
+      }
+      this.#seen.add(file)
+      try {
+        require(file)
+      } catch { /* one that can't load can't run under Metro either: its bytes are still recorded */ }
+      // Real reader: plugin bookkeeping, not a program fs read -- must not be re-recorded by --fs.
+      this.#recordCapture(file, realReadFileSync(file), { reason: 'run' })
+    }
+  }
+
   // Attest each native dependency's build-input surface. Discovery is `react-native config`; each
   // dep root is walked (isSkippedNativeWalkDir pruned) and its native sources are attested as code,
   // other assets as resources, plus each package.json. Node-runnable JS/TS is skipped (already in
@@ -386,9 +429,13 @@ export class StasisMetro {
   // (`dep.data.name`) by the specifier Babel left; where a plugin rewrote it, the stasis transformer
   // (./metro-transformer.js) carries the ones written in the source. Code and resource targets alike,
   // as `stasis bundle --metro` and the esbuild plugin record them: an asset is resolved as code is.
+  // One the source doesn't write (`stasisInserted`: a Babel helper, the JSX runtime, Metro's
+  // asyncRequire) is no edge, as `stasis bundle --metro` has none: its file is carried, as every
+  // module of the graph is, and under load Metro resolves it unasserted.
   #edges(module) {
     const edges = []
     for (const dep of module.dependencies?.values?.() ?? []) {
+      if (dep?.data?.stasisInserted === true) continue
       const target = dep?.absolutePath
       if (typeof target !== 'string' || !isAbsolute(target) || !existsSync(target)) continue
       if (classifyExtension(target, this.#resources) === 'unknown') continue