peachsim 0.1.1481 → 0.1.1619

package/cli/app-stubs.ts

@@ -0,0 +1,433 @@
+// native stubs keyed by the package they answer (specs/peach-app-stubs.md):
+// the app's peach.config.ts `packages`, installed `peach-stub-<package>`
+// packages, and a library's own `peach` field, lowered into the engine's
+// nativeModules / nativeViews wire slots.
+
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs'
+import { dirname, join, relative, resolve } from 'node:path'
+import { resolveCompatVersionRange } from '@peach/compat/version-range'
+import { parseSync, type Expression } from 'oxc-parser'
+import { transform } from 'sucrase'
+import {
+  isPackageStubs,
+  type NativeModuleResolution,
+  type NativeStub,
+  type NativeViewResolution,
+  type NativeViewSource,
+  type PackageStubs,
+  type PeachConfig,
+} from '../src/config'
+import { isRecord } from '../src/is-record'
+import { visitParsedProgram } from '../src/visit-parsed-program'
+import { readProjectManifest, scanRepository } from './commands/detect'
+
+// who answers a package, in rising precedence
+export type StubOrigin = 'library' | 'stub-package' | 'config'
+
+export interface AppliedStubs {
+  target: string
+  origin: StubOrigin
+  // the package declaring the stubs; null for peach.config.ts
+  provider: string | null
+  providerVersion: string | null
+  modules: string[]
+  views: string[]
+  viewSources?: Record<string, NativeViewSource>
+}
+
+// a published stub whose `versions` range excludes the installed target
+export interface SkippedStubs {
+  target: string
+  provider: string
+  providerVersion: string | null
+  versions: string
+  installed: string
+}
+
+export interface AppStubs {
+  applied: AppliedStubs[]
+  skipped: SkippedStubs[]
+}
+
+interface StubSource {
+  target: string
+  origin: StubOrigin
+  provider: string | null
+  providerVersion: string | null
+  stubs: PackageStubs
+  // where relative stub paths resolve from
+  baseDir: string
+}
+
+// `peach-stub-<package>` or `@scope/peach-stub-<package>`; a scoped target uses
+// the DefinitelyTyped encoding, `@acme/scanner` as `peach-stub-acme__scanner`.
+export function stubPackageTarget(name: string): string | null {
+  const match = /^(?:@[^/]+\/)?peach-stub-(.+)$/.exec(name)
+  if (!match?.[1]) return null
+  const split = match[1].indexOf('__')
+  return split > 0
+    ? `@${match[1].slice(0, split)}/${match[1].slice(split + 2)}`
+    : match[1]
+}
+
+export function resolveAppStubs(
+  appDir: string,
+  config: PeachConfig | undefined,
+  configDir: string,
+): { config: PeachConfig | undefined; stubs: AppStubs } {
+  const sources: StubSource[] = []
+  const skipped: SkippedStubs[] = []
+  const manifest = readProjectManifest(appDir)
+  for (const name of Object.keys({
+    ...manifest?.devDependencies,
+    ...manifest?.dependencies,
+  })) {
+    const dir = installedPackageDir(appDir, name)
+    const installed = dir ? readPackageJson(dir) : null
+    if (!dir || !installed || installed.peach === undefined) continue
+    const stubTarget = stubPackageTarget(name)
+    const target = stubTarget ?? name
+    const field = installed.peach
+    const versions = isRecord(field) ? field.versions : undefined
+    const stubs = isRecord(field) ? { modules: field.modules, views: field.views } : field
+    if (
+      !isPackageStubs(stubs) ||
+      (versions !== undefined && typeof versions !== 'string')
+    )
+      throw new Error(
+        `${name}'s package.json "peach" field must be "noop" or { versions?, modules?, views? } whose values are "noop" or file paths`,
+      )
+    const providerVersion =
+      typeof installed.version === 'string' ? installed.version : null
+    const targetDir = stubTarget ? installedPackageDir(appDir, target) : dir
+    const targetVersion = targetDir ? readPackageJson(targetDir)?.version : undefined
+    // a stub for a package the app does not install answers nothing
+    if (typeof targetVersion !== 'string') continue
+    if (
+      versions !== undefined &&
+      resolveCompatVersionRange([versions], targetVersion).status !== 'matched'
+    ) {
+      skipped.push({
+        target,
+        provider: name,
+        providerVersion,
+        versions,
+        installed: targetVersion,
+      })
+      continue
+    }
+    sources.push({
+      target,
+      origin: stubTarget ? 'stub-package' : 'library',
+      provider: name,
+      providerVersion,
+      stubs,
+      baseDir: dir,
+    })
+  }
+  for (const [target, stubs] of Object.entries(config?.packages ?? {})) {
+    sources.push({
+      target,
+      origin: 'config',
+      provider: null,
+      providerVersion: null,
+      stubs,
+      baseDir: configDir,
+    })
+  }
+
+  const ORDER: Record<StubOrigin, number> = { library: 0, 'stub-package': 1, config: 2 }
+  sources.sort((a, b) => ORDER[a.origin] - ORDER[b.origin])
+  const nativeModules: Record<string, NativeModuleResolution> = {}
+  const nativeViews: Record<string, NativeViewResolution> = {}
+  const applied: AppliedStubs[] = []
+  for (const source of sources) {
+    const { modules, views } = expandStubs(appDir, source)
+    for (const [name, stub] of Object.entries(modules))
+      nativeModules[name] = lowerStub(stub, source.baseDir)
+    for (const [name, stub] of Object.entries(views))
+      nativeViews[name] =
+        typeof stub === 'string' ? lowerStub(stub, source.baseDir) : stub
+    applied.push({
+      target: source.target,
+      origin: source.origin,
+      provider: source.provider,
+      providerVersion: source.providerVersion,
+      modules: Object.keys(modules),
+      views: Object.keys(views),
+      ...(Object.values(views).some((value) => typeof value !== 'string')
+        ? {
+            viewSources: Object.fromEntries(
+              Object.entries(views).filter(
+                (entry): entry is [string, NativeViewSource] =>
+                  typeof entry[1] !== 'string',
+              ),
+            ),
+          }
+        : {}),
+    })
+  }
+  const stubs = { applied, skipped }
+  if (!config && applied.length === 0) return { config, stubs }
+  const lowered: PeachConfig = { ...config, nativeModules, nativeViews }
+  delete lowered.packages
+  return { config: lowered, stubs }
+}
+
+// a whole-package 'noop' answers every native name the installed package asks for
+function expandStubs(
+  appDir: string,
+  source: StubSource,
+): {
+  modules: Record<string, NativeStub>
+  views: Record<string, NativeStub | NativeViewSource>
+} {
+  if (source.stubs !== 'noop')
+    return { modules: source.stubs.modules ?? {}, views: source.stubs.views ?? {} }
+  const dir = installedPackageDir(appDir, source.target)
+  if (!dir)
+    throw new Error(
+      `packages['${source.target}']: 'noop' answers the names an installed package asks for, and ${source.target} is not installed`,
+    )
+  const modules: Record<string, NativeStub> = {}
+  const views: Record<string, NativeStub> = {}
+  for (const request of packageNativeRequests(dir)) {
+    if (request.kind === 'module') modules[request.name] = 'noop'
+    else views[request.name] = 'noop'
+  }
+  return { modules, views }
+}
+
+function lowerStub(stub: NativeStub, baseDir: string): 'noop' | { file: string } {
+  return stub === 'noop' ? stub : { file: resolve(baseDir, stub) }
+}
+
+function readPackageJson(dir: string): Record<string, unknown> | null {
+  const text = readSmallFile(join(dir, 'package.json'))
+  if (!text) return null
+  try {
+    const parsed: unknown = JSON.parse(text)
+    return isRecord(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+// the installed copy of a dependency, found the way node resolves it
+export function installedPackageDir(appDir: string, name: string): string | null {
+  let current = appDir
+  while (true) {
+    const dir = join(current, 'node_modules', name)
+    if (existsSync(join(dir, 'package.json'))) return realpathSync(dir)
+    const parent = dirname(current)
+    if (parent === current) return null
+    current = parent
+  }
+}
+
+export interface NativeRequest {
+  kind: 'module' | 'view'
+  name: string
+}
+
+export const SOURCE_FILE = /\.[cm]?[jt]sx?$/
+const NATIVE_LOOKUP =
+  /requireNative|requireOptionalNative|TurboModuleRegistry|codegenNativeComponent|NativeModules/
+
+function nativeLookupName(node: Expression): string | null {
+  if (node.type === 'Identifier') return node.name
+  if (
+    node.type === 'MemberExpression' &&
+    !node.computed &&
+    node.property.type === 'Identifier'
+  )
+    return node.property.name
+  return null
+}
+
+// sucrase removes flow and typescript types while retaining source lines. oxc
+// then visits executable syntax, including expressions inside template literals,
+// without interpreting comments, fixture strings or type queries as requests.
+export function sourceNativeRequests(
+  file: string,
+  text: string,
+  includeLegacy = false,
+): (NativeRequest & { line: number })[] {
+  if (!NATIVE_LOOKUP.test(text)) return []
+  let code: string
+  try {
+    code = transform(text, {
+      transforms: [/\.[cm]?tsx?$/.test(file) ? 'typescript' : 'flow', 'jsx'],
+      disableESTransforms: true,
+    }).code
+  } catch {
+    return []
+  }
+  const { program, errors } = parseSync(file, code, { lang: 'jsx' })
+  if (errors.length) return []
+  const found: (NativeRequest & { line: number })[] = []
+  const add = (kind: NativeRequest['kind'], name: string, at: number) => {
+    found.push({ kind, name, line: code.slice(0, at).split('\n').length })
+  }
+  visitParsedProgram(program, {
+    CallExpression(node) {
+      const first = node.arguments[0]
+      if (first?.type !== 'Literal' || typeof first.value !== 'string') return
+      const callee = node.callee
+      const lookup = nativeLookupName(callee)
+      if (
+        callee.type === 'MemberExpression' &&
+        !callee.computed &&
+        nativeLookupName(callee.object) === 'TurboModuleRegistry' &&
+        (lookup === 'get' || lookup === 'getEnforcing')
+      ) {
+        add('module', first.value, node.start)
+      } else if (lookup) {
+        if (['requireNativeModule', 'requireOptionalNativeModule'].includes(lookup))
+          add('module', first.value, node.start)
+        else if (['requireNativeComponent', 'codegenNativeComponent'].includes(lookup))
+          add('view', first.value, node.start)
+        else if (['requireNativeView', 'requireNativeViewManager'].includes(lookup)) {
+          const second = node.arguments[1]
+          // expo registers a named view under the module_view key.
+          const name =
+            second?.type === 'Literal' && typeof second.value === 'string'
+              ? `${first.value}_${second.value}`
+              : first.value
+          add('view', name, node.start)
+        }
+      }
+    },
+    MemberExpression(node) {
+      if (
+        includeLegacy &&
+        !node.computed &&
+        nativeLookupName(node.object) === 'NativeModules' &&
+        node.property.type === 'Identifier'
+      )
+        add('module', node.property.name, node.start)
+    },
+  })
+  return found
+}
+
+// the native names a package's own JavaScript asks for, outside its native
+// sources (top-level ios and android; src/ios is JavaScript), tests and examples
+const NATIVE_SOURCE_DIRS = new Set(['ios', 'android'])
+const PACKAGE_SKIP_DIRS = new Set([
+  'example',
+  'examples',
+  '__tests__',
+  '__mocks__',
+  'docs',
+])
+
+export function packageNativeRequests(dir: string): NativeRequest[] {
+  const found = new Map<string, NativeRequest>()
+  const directories = scanRepository(dir).directories.filter((sub) => {
+    const segments = relative(dir, sub).split('/')
+    return (
+      !NATIVE_SOURCE_DIRS.has(segments[0]) &&
+      !segments.some((segment) => PACKAGE_SKIP_DIRS.has(segment))
+    )
+  })
+  let files = 0
+  for (const sub of directories) {
+    for (const name of listDir(sub)) {
+      if (!SOURCE_FILE.test(name) || name.endsWith('.d.ts') || files >= 2_000) continue
+      files++
+      const file = join(sub, name)
+      const text = readSmallFile(file)
+      if (!text) continue
+      for (const { kind, name } of sourceNativeRequests(file, text, true))
+        found.set(`${kind}:${name}`, { kind, name })
+    }
+  }
+  return [...found.values()].sort(
+    (a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name),
+  )
+}
+
+// the `packages` block that replaces a config's old top-level wire slots: each
+// name keyed by the direct dependency whose JavaScript asks for it. `packages`
+// takes only 'noop' or a file path, so any other old value is named for a hand
+// move instead of guessed.
+export function wireSlotMigration(
+  appDir: string,
+  wire: { modules: Record<string, unknown>; views: Record<string, unknown> },
+): string {
+  const owners = new Map<string, string>()
+  const manifest = readProjectManifest(appDir)
+  for (const name of Object.keys({
+    ...manifest?.devDependencies,
+    ...manifest?.dependencies,
+  })) {
+    const dir = installedPackageDir(appDir, name)
+    if (!dir) continue
+    for (const request of packageNativeRequests(dir))
+      if (!owners.has(`${request.kind}:${request.name}`))
+        owners.set(`${request.kind}:${request.name}`, name)
+  }
+  // the app's own native code answers under its package name
+  if (typeof manifest?.name === 'string')
+    for (const request of packageNativeRequests(appDir))
+      if (!owners.has(`${request.kind}:${request.name}`))
+        owners.set(`${request.kind}:${request.name}`, manifest.name)
+  const unknownOwner = '<package that asks for it>'
+  const blocks = new Map<string, { modules: string[]; views: string[] }>()
+  const manual: string[] = []
+  for (const [kind, entries] of [
+    ['module', wire.modules],
+    ['view', wire.views],
+  ] as const) {
+    for (const [name, value] of Object.entries(entries)) {
+      const stub =
+        value === 'noop'
+          ? JSON.stringify(value)
+          : isRecord(value) &&
+              typeof value.file === 'string' &&
+              Object.keys(value).length === 1
+            ? JSON.stringify(value.file)
+            : null
+      if (!stub) {
+        manual.push(
+          `${name}: packages takes 'noop' or a file path; move this ${kind} into a file that default-exports it and name that file`,
+        )
+        continue
+      }
+      const owner = owners.get(`${kind}:${name}`) ?? unknownOwner
+      const block = blocks.get(owner) ?? { modules: [], views: [] }
+      block[kind === 'module' ? 'modules' : 'views'].push(
+        `[${JSON.stringify(name)}]: ${stub}`,
+      )
+      blocks.set(owner, block)
+    }
+  }
+  const lines = [...blocks].map(([owner, { modules, views }]) => {
+    const parts = [
+      modules.length ? `modules: { ${modules.join(', ')} }` : '',
+      views.length ? `views: { ${views.join(', ')} }` : '',
+    ].filter(Boolean)
+    return `    [${JSON.stringify(owner)}]: { ${parts.join(', ')} },`
+  })
+  return [
+    ...(lines.length ? ['  packages: {', ...lines, '  },'] : []),
+    ...manual.map((line) => `  // ${line}`),
+  ].join('\n')
+}
+
+export function listDir(dir: string): string[] {
+  try {
+    return readdirSync(dir)
+  } catch {
+    return []
+  }
+}
+
+export function readSmallFile(file: string): string | null {
+  try {
+    return statSync(file).size <= 1024 * 1024 ? readFileSync(file, 'utf8') : null
+  } catch {
+    return null
+  }
+}

package/cli/bin.ts

@@ -13,6 +13,15 @@
 import { exitWithFlushedOutput } from '../src/process-output'
 import { RNX_FORKED_SCRIPT_ENV, RNX_INTERNAL_COMMAND } from './internal-child'
 
+// a consumer such as head may close its pipe before the command finishes.
+// exit directly: reporting this through stderr can fail on the same pipe.
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on('error', (error: NodeJS.ErrnoException) => {
+    if (error.code === 'EPIPE') process.exit(1)
+    throw error
+  })
+}
+
 if (process.argv[2] === '__shell-init') {
   const { renderRnxShellInit } = await import('./shell-init')
   try {
@@ -53,9 +62,13 @@ if (process.argv[2] === '__cloud-confirm') {
 // work does. so this is the branch that must skip the CLI rather than the CLI
 // that must skip it.
 const forkedScript = process.argv[2]
-if (process.env[RNX_FORKED_SCRIPT_ENV] === '1' && forkedScript?.endsWith('.js')) {
+if (
+  process.env[RNX_FORKED_SCRIPT_ENV] === '1' &&
+  forkedScript &&
+  /\.(?:c|m)?js$/.test(forkedScript)
+) {
   const { runScript } = await import('./internal-child')
-  runScript(forkedScript, process.argv.slice(3))
+  await runScript(forkedScript, process.argv.slice(3))
 } else if (process.argv[2] === RNX_INTERNAL_COMMAND) {
   const { runInternalChild } = await import('./internal-child')
   await runInternalChild(process.argv.slice(3))