peachsim 0.1.1644 → 0.1.1653

package/src/stub-pattern-matcher.ts

@@ -0,0 +1,550 @@
+export function extractPackageFromPath(modulePath: string): string | null {
+  let nodeModulesIndex = modulePath.lastIndexOf('/node_modules/')
+  let prefixLength = '/node_modules/'.length
+  if (nodeModulesIndex === -1) {
+    if (!modulePath.startsWith('node_modules/')) return null
+    nodeModulesIndex = 0
+    prefixLength = 'node_modules/'.length
+  }
+
+  return packageNameAt(modulePath, nodeModulesIndex + prefixLength) || null
+}
+
+export function getPackageName(modulePath: string): string | null {
+  if (modulePath.startsWith('.') || modulePath.startsWith('/')) return null
+  return packageNameAt(modulePath, 0)
+}
+
+// the package name that starts at `start`: one segment, or two for a scope.
+// every module of a bundle passes through here at boot, so it slices once
+// instead of splitting the whole path.
+function packageNameAt(modulePath: string, start: number): string | null {
+  const firstSlash = modulePath.indexOf('/', start)
+  if (modulePath.startsWith('@', start)) {
+    if (firstSlash === -1) return null
+    const secondSlash = modulePath.indexOf('/', firstSlash + 1)
+    return modulePath.slice(start, secondSlash === -1 ? undefined : secondSlash)
+  }
+  return modulePath.slice(start, firstSlash === -1 ? undefined : firstSlash)
+}
+
+// asset files are modules too: metro names an app's svg or image import by
+// its path, so these extensions mark an app file just like source extensions
+const moduleFileExtension =
+  /\.(?:[cm]?jsx?|tsx?|json|svg|png|jpe?g|gif|webp|bmp|ttf|otf|woff2?|mp[34]|wav|m4a|aac|pdf)$/
+
+// metro names each module file by its path from the project root, so a file
+// name outside node_modules that is neither relative nor absolute is one of
+// the app's own files. bare specifiers stay bare: host-owned modules are
+// named by specifier and carry no file extension. marking the file relative
+// keeps an app directory that shares a dependency's name, such as an app's
+// own `react/` tree, from matching that package's stubs.
+export function metroModuleStubPath(name: string): string {
+  if (
+    name.startsWith('.') ||
+    name.startsWith('/') ||
+    name.startsWith('node_modules/') ||
+    name.includes('/node_modules/') ||
+    !moduleFileExtension.test(name)
+  ) {
+    return name
+  }
+  return `./${name}`
+}
+
+function isPackageRootPattern(pattern: string): boolean {
+  return getPackageName(pattern) === pattern
+}
+
+export function matchesModuleEntry(modulePath: string, pattern: string): boolean {
+  if (!modulePath || !pattern) return false
+  if (modulePath === pattern) return true
+  // the path is `node_modules/<pattern>` with an optional entry extension,
+  // at the start or after a slash. checked in place: this runs for every
+  // module against every candidate pattern, so it builds no strings.
+  if (!modulePath.includes(pattern)) return false
+  for (const extension of moduleEntryExtensions) {
+    const end = modulePath.length - extension.length
+    const start = end - pattern.length
+    const root = start - nodeModulesPrefix.length
+    if (
+      root >= 0 &&
+      modulePath.endsWith(extension) &&
+      modulePath.startsWith(pattern, start) &&
+      modulePath.startsWith(nodeModulesPrefix, root) &&
+      (root === 0 || modulePath[root - 1] === '/')
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+const nodeModulesPrefix = 'node_modules/'
+const moduleEntryExtensions = ['', '.js', '.ts', '.tsx']
+
+// what may follow `node_modules/<pattern>` at the end of a package's main
+// entry path. `build/` and `dist/` also accept the package's own name file,
+// checked below.
+const packageMainEntryTails = new Set([
+  '/index.js',
+  '/index.ts',
+  '/index.tsx',
+  '/index.native.js',
+  '/lib/index.js',
+  '/lib/index.ts',
+  '/lib/index.tsx',
+  '/src/index.js',
+  '/src/index.ts',
+  '/src/index.tsx',
+  '/src/index.native.js',
+  '/src/index.native.ts',
+  '/lib/module/index.js',
+  '/lib/commonjs/index.js',
+  '/build/index.js',
+  '/dist/index.js',
+  '/dist/module/index.js',
+  '/dist/commonjs/index.js',
+  '.js',
+  '.ts',
+  '.tsx',
+])
+
+export function matchesPackageMainEntry(modulePath: string, pattern: string): boolean {
+  if (!modulePath.includes(pattern)) return false
+  if (matchesModuleEntry(modulePath, pattern)) return true
+  // no tail contains `node_modules/`, so only the last occurrence can end the path
+  const entryRoot = `node_modules/${pattern}`
+  const at = modulePath.lastIndexOf(entryRoot)
+  if (at < 0 || (at > 0 && modulePath[at - 1] !== '/')) return false
+  const tail = modulePath.slice(at + entryRoot.length)
+  if (packageMainEntryTails.has(tail)) return true
+  const namedFile = /^\/(?:build|dist)\/([^/]+)\.js$/.exec(tail)?.[1]
+  if (!namedFile) return false
+  const packageBase = pattern.split('/').at(-1) ?? pattern
+  const capitalizedBase = packageBase
+    .replace(/^(expo-|react-native-)/, '')
+    .replace(/(^|-)(\w)/g, (_, _delimiter, character: string) => character.toUpperCase())
+  const camelBase = capitalizedBase.charAt(0).toLowerCase() + capitalizedBase.slice(1)
+  return namedFile === capitalizedBase || namedFile === camelBase
+}
+
+function matchesPackageDeepPath(modulePath: string, pattern: string): boolean {
+  if (getPackageName(modulePath) === pattern) return true
+  return extractPackageFromPath(modulePath) === pattern
+}
+
+function packageSubpathFromModulePath(
+  modulePath: string,
+  packageName: string,
+): string | null {
+  const packageSegment = `node_modules/${packageName}/`
+  const index = modulePath.lastIndexOf(packageSegment)
+  if (index !== -1) return modulePath.slice(index + packageSegment.length)
+  if (modulePath.startsWith(`${packageName}/`)) {
+    return modulePath.slice(packageName.length + 1)
+  }
+  return null
+}
+
+function normalizePackageDeepSubpath(modulePath: string, packageName: string): string {
+  let subpath = packageSubpathFromModulePath(modulePath, packageName)
+  if (!subpath) return ''
+  subpath = subpath
+    .replace(/\.(native|ios|android|web)\.(tsx?|jsx?|mjs|cjs)$/, '')
+    .replace(/\.(tsx?|jsx?|mjs|cjs)$/, '')
+  for (const prefix of [
+    'src/',
+    'lib/module/',
+    'lib/commonjs/',
+    'lib/',
+    'build/',
+    'dist/module/',
+    'dist/commonjs/',
+    'dist/',
+  ]) {
+    if (subpath.startsWith(prefix)) {
+      subpath = subpath.slice(prefix.length)
+      break
+    }
+  }
+  return subpath.replace(/\/index$/, '')
+}
+
+export function isExpoUiSwiftUiModifiersModule(modulePath: string): boolean {
+  const subpath = normalizePackageDeepSubpath(modulePath, '@expo/ui')
+  return subpath === 'swift-ui/modifiers' || subpath.startsWith('swift-ui/modifiers/')
+}
+
+function isRnghReanimatedSwipeablePureModule(modulePath: string): boolean {
+  const packageName = 'react-native-gesture-handler'
+  const extracted = extractPackageFromPath(modulePath) ?? getPackageName(modulePath)
+  if (extracted !== packageName) return false
+
+  const subpath = normalizePackageDeepSubpath(modulePath, packageName)
+  return (
+    subpath === 'ReanimatedSwipeable' ||
+    subpath.startsWith('ReanimatedSwipeable/') ||
+    subpath === 'components/ReanimatedSwipeable' ||
+    subpath.startsWith('components/ReanimatedSwipeable/') ||
+    subpath === 'components/utils'
+  )
+}
+
+// upstream `react-native-screens/experimental` runs from the bundle over native
+// seams (Split, SafeAreaView). these are the modules its entry reaches; the
+// package-root stub would otherwise answer each with the classic surface, where
+// SafeAreaView and Split are undefined.
+const rnsExperimentalSubpaths = [
+  'experimental',
+  'components/gamma/',
+  'components/safe-area',
+  'components/shared',
+  'fabric/gamma/',
+  'fabric/safe-area/',
+  'private',
+  'flags',
+]
+
+function isRnsExperimentalModule(modulePath: string): boolean {
+  const packageName = 'react-native-screens'
+  const extracted = extractPackageFromPath(modulePath) ?? getPackageName(modulePath)
+  if (extracted !== packageName) return false
+  const subpath = normalizePackageDeepSubpath(modulePath, packageName)
+  return rnsExperimentalSubpaths.some((entry) =>
+    entry.endsWith('/')
+      ? subpath.startsWith(entry)
+      : subpath === entry || subpath.startsWith(`${entry}/`),
+  )
+}
+
+export function isReactNativeWorkletsGeneratedWorkletModule(modulePath: string): boolean {
+  const subpath = packageSubpathFromModulePath(modulePath, 'react-native-worklets')
+  return subpath?.startsWith('.worklets/') === true
+}
+
+function isReactNativeWorkletsBundleModeShim(modulePath: string): boolean {
+  const subpath = packageSubpathFromModulePath(modulePath, 'react-native-worklets')
+  return subpath?.startsWith('bundleMode/shims/') === true
+}
+
+function deriveDeepImportCandidates(modulePath: string, packageName: string): string[] {
+  const subpath = packageSubpathFromModulePath(modulePath, packageName)
+  if (!subpath) return []
+  const segments = subpath.split('/').filter(Boolean)
+  if (segments.length === 0) return []
+
+  const stripExtension = (segment: string) =>
+    segment
+      .replace(/\.(native|ios|android|web)\.(tsx?|jsx?|mjs|cjs)$/, '')
+      .replace(/\.(tsx?|jsx?|mjs|cjs)$/, '')
+  const pascalize = (segment: string) =>
+    segment.length > 0 ? segment[0].toUpperCase() + segment.slice(1) : segment
+  const candidates: string[] = []
+  const addCandidate = (name: string | undefined) => {
+    if (!name) return
+    if (!candidates.includes(name)) candidates.push(name)
+    const pascalName = pascalize(name)
+    if (pascalName !== name && !candidates.includes(pascalName)) {
+      candidates.push(pascalName)
+    }
+  }
+
+  const last = stripExtension(segments[segments.length - 1])
+  const parent = segments.length >= 2 ? segments[segments.length - 2] : ''
+  const grandparent = segments.length >= 3 ? segments[segments.length - 3] : ''
+  if (last === 'index') {
+    addCandidate(parent)
+    addCandidate(grandparent)
+  } else {
+    addCandidate(last)
+    addCandidate(parent)
+  }
+  return candidates
+}
+
+// what a package's subpath patterns compare against one of its module paths.
+// it depends only on the module, so a bundle scan reads it once per module
+// rather than once per pattern: the per-pattern form made the scan
+// modules × patterns regex work on the boot path.
+interface DeepPathFacts {
+  // the package's main entry answers only to the package root pattern
+  mainEntry: boolean
+  normalized: string
+  candidates: string[]
+}
+
+// a match loop asks for one module's facts once per candidate pattern in a
+// row, so the last answer is kept for the next question about the same module
+let lastDeepPath: {
+  modulePath: string
+  packageName: string
+  facts: DeepPathFacts
+} | null = null
+
+function readDeepPathFacts(modulePath: string, packageName: string): DeepPathFacts {
+  if (
+    lastDeepPath?.modulePath === modulePath &&
+    lastDeepPath.packageName === packageName
+  ) {
+    return lastDeepPath.facts
+  }
+  const facts = {
+    mainEntry: matchesPackageMainEntry(modulePath, packageName),
+    normalized: normalizePackageDeepSubpath(modulePath, packageName),
+    candidates: deriveDeepImportCandidates(modulePath, packageName),
+  }
+  lastDeepPath = { modulePath, packageName, facts }
+  return facts
+}
+
+function deepPathMatchesTail(facts: DeepPathFacts, patternTail: string): boolean {
+  if (facts.mainEntry || !patternTail) return false
+  return (
+    facts.normalized === patternTail ||
+    facts.normalized.endsWith(`/${patternTail}`) ||
+    facts.candidates.includes(patternTail)
+  )
+}
+
+function matchesSubpathPatternViaDeepPath(modulePath: string, pattern: string): boolean {
+  const packageName = getPackageName(pattern)
+  if (!packageName) return false
+  const extracted = extractPackageFromPath(modulePath) ?? getPackageName(modulePath)
+  if (extracted !== packageName) return false
+  return deepPathMatchesTail(
+    readDeepPathFacts(modulePath, packageName),
+    pattern.slice(packageName.length + 1),
+  )
+}
+
+function excludesPackageRootStub(modulePath: string, pattern: string): boolean {
+  // manifests carry the guest dependency's version and exports, never native code.
+  if (modulePath.endsWith('/package.json')) return true
+  if (pattern === '@expo/ui' && !matchesPackageMainEntry(modulePath, pattern)) {
+    return true
+  }
+  if (pattern === '@expo/ui/swift-ui' && isExpoUiSwiftUiModifiersModule(modulePath)) {
+    return true
+  }
+  if (
+    pattern === 'react-native-gesture-handler' &&
+    isRnghReanimatedSwipeablePureModule(modulePath)
+  ) {
+    return true
+  }
+  if (pattern === 'react-native-screens' && isRnsExperimentalModule(modulePath)) {
+    return true
+  }
+  if (
+    pattern === 'react-native-worklets' &&
+    (isReactNativeWorkletsGeneratedWorkletModule(modulePath) ||
+      isReactNativeWorkletsBundleModeShim(modulePath))
+  ) {
+    return true
+  }
+  return false
+}
+
+export function matchesStubPattern(modulePath: string, pattern: string): boolean {
+  if (excludesPackageRootStub(modulePath, pattern)) return false
+  if (isPackageRootPattern(pattern)) {
+    return (
+      matchesPackageDeepPath(modulePath, pattern) ||
+      matchesModuleEntry(modulePath, pattern)
+    )
+  }
+  if (matchesModuleEntry(modulePath, pattern)) return true
+  return matchesSubpathPatternViaDeepPath(modulePath, pattern)
+}
+
+export interface StubPatternMatcher {
+  patternsByPackage: ReadonlyMap<string, ReadonlyArray<string>>
+  fallbackPatterns: ReadonlyArray<string>
+  patternRank: ReadonlyMap<string, number>
+  sourcePackageIdentitiesByBasename: ReadonlyMap<
+    string,
+    ReadonlyArray<SourcePackageIdentity>
+  >
+}
+
+interface SourcePackageIdentity {
+  pathSuffix: string
+  packageName: string
+}
+
+const sourceDirectoryPattern = /\/(src|lib|build|dist)\//g
+
+function sourceIdentityPath(packageName: string): string {
+  return packageName.startsWith('@') ? packageName.slice(1) : packageName
+}
+
+function hasDistinctivePackageBasename(packageBasename: string): boolean {
+  return /[-._]/.test(packageBasename)
+}
+
+export function createStubPatternMatcher(
+  stubPatterns: ReadonlyArray<string>,
+  sourcePackagePatterns: ReadonlyArray<string> = [],
+): StubPatternMatcher {
+  const sorted = [...stubPatterns].sort((a, b) => b.length - a.length)
+  const patternsByPackage = new Map<string, string[]>()
+  const fallbackPatterns: string[] = []
+  const sourcePackagesByIdentity = new Map<string, string>()
+  const ambiguousSourceIdentities = new Set<string>()
+
+  for (const pattern of sorted) {
+    const packageName = getPackageName(pattern)
+    if (!packageName) {
+      fallbackPatterns.push(pattern)
+      continue
+    }
+    const packagePatterns = patternsByPackage.get(packageName)
+    if (packagePatterns) packagePatterns.push(pattern)
+    else patternsByPackage.set(packageName, [pattern])
+  }
+
+  for (const pattern of sourcePackagePatterns) {
+    const packageName = getPackageName(pattern)
+    if (!packageName || packageName !== pattern) continue
+    const fullIdentity = sourceIdentityPath(packageName)
+    const basename = fullIdentity.split('/').at(-1)
+    const identities = [fullIdentity]
+    if (
+      basename &&
+      basename !== fullIdentity &&
+      hasDistinctivePackageBasename(basename)
+    ) {
+      identities.push(basename)
+    }
+    for (const identity of identities) {
+      if (ambiguousSourceIdentities.has(identity)) continue
+      const existing = sourcePackagesByIdentity.get(identity)
+      if (existing && existing !== packageName) {
+        sourcePackagesByIdentity.delete(identity)
+        ambiguousSourceIdentities.add(identity)
+      } else {
+        sourcePackagesByIdentity.set(identity, packageName)
+      }
+    }
+  }
+
+  const sourcePackageIdentitiesByBasename = new Map<string, SourcePackageIdentity[]>()
+  for (const [pathSuffix, packageName] of sourcePackagesByIdentity) {
+    const basename = pathSuffix.split('/').at(-1)
+    if (!basename) continue
+    const identities = sourcePackageIdentitiesByBasename.get(basename)
+    const identity = { pathSuffix, packageName }
+    if (identities) identities.push(identity)
+    else sourcePackageIdentitiesByBasename.set(basename, [identity])
+  }
+  for (const identities of sourcePackageIdentitiesByBasename.values()) {
+    identities.sort((a, b) => b.pathSuffix.length - a.pathSuffix.length)
+  }
+
+  return {
+    patternsByPackage,
+    fallbackPatterns,
+    patternRank: new Map(sorted.map((pattern, rank) => [pattern, rank])),
+    sourcePackageIdentitiesByBasename,
+  }
+}
+
+const noStubPatterns: ReadonlyArray<string> = []
+
+// every pattern matchesStubPattern could accept for this module, longest first
+// in the matcher's order. a pattern is only reachable through its own package:
+// the module's installed package, that name without a module-entry extension
+// (`node_modules/pkg.js` is an entry of `pkg`), or its bare specifier package.
+export function candidateStubPatterns(
+  modulePath: string,
+  matcher: StubPatternMatcher,
+): ReadonlyArray<string> {
+  const lists: ReadonlyArray<string>[] = []
+  if (matcher.fallbackPatterns.length > 0) lists.push(matcher.fallbackPatterns)
+  const installedPackage = extractPackageFromPath(modulePath)
+  for (const packageName of [
+    installedPackage,
+    installedPackage?.replace(/\.(js|tsx?)$/, ''),
+    getPackageName(modulePath),
+  ]) {
+    const patterns = packageName ? matcher.patternsByPackage.get(packageName) : undefined
+    if (patterns && !lists.includes(patterns)) lists.push(patterns)
+  }
+  if (lists.length === 0) return noStubPatterns
+  if (lists.length === 1) return lists[0]
+  return lists
+    .flat()
+    .sort((a, b) => (matcher.patternRank.get(a) ?? 0) - (matcher.patternRank.get(b) ?? 0))
+}
+
+function canonicalSourceModulePath(
+  modulePath: string,
+  sourcePackageIdentitiesByBasename: ReadonlyMap<
+    string,
+    ReadonlyArray<SourcePackageIdentity>
+  >,
+): string | null {
+  const normalized = modulePath.replace(/\\/g, '/')
+  if (normalized.startsWith('node_modules/') || normalized.includes('/node_modules/')) {
+    return null
+  }
+  const searchable = normalized.startsWith('/') ? normalized : `/${normalized}`
+  sourceDirectoryPattern.lastIndex = 0
+  let match: RegExpExecArray | null
+  while ((match = sourceDirectoryPattern.exec(searchable))) {
+    const sourceDirectory = match[1]
+    if (!sourceDirectory) continue
+    const packagePath = searchable.slice(0, match.index)
+    const basename = packagePath.slice(packagePath.lastIndexOf('/') + 1)
+    const identities = sourcePackageIdentitiesByBasename.get(basename)
+    if (!identities) continue
+    for (const identity of identities) {
+      if (packagePath.endsWith(`/${identity.pathSuffix}`)) {
+        return `${identity.packageName}/${sourceDirectory}/${searchable.slice(sourceDirectoryPattern.lastIndex)}`
+      }
+    }
+  }
+  return null
+}
+
+export function addMatchingStubPatterns(
+  modulePath: string,
+  matcher: StubPatternMatcher,
+  matches: Set<string>,
+): void {
+  const directPackage = extractPackageFromPath(modulePath) ?? getPackageName(modulePath)
+  const canonicalSourcePath = directPackage
+    ? null
+    : canonicalSourceModulePath(modulePath, matcher.sourcePackageIdentitiesByBasename)
+  const effectivePath = canonicalSourcePath ?? modulePath
+  const packageName =
+    directPackage ?? (canonicalSourcePath ? getPackageName(canonicalSourcePath) : null)
+  const packagePatterns = packageName
+    ? matcher.patternsByPackage.get(packageName)
+    : undefined
+  if (packageName && packagePatterns) {
+    // every pattern here is the package root or one of its subpaths, and the
+    // effective path belongs to the package, so matchesStubPattern reduces to
+    // the exclusions, a module entry, or a deep path read once for the module
+    let facts: DeepPathFacts | null = null
+    for (const pattern of packagePatterns) {
+      if (excludesPackageRootStub(effectivePath, pattern)) continue
+      if (
+        pattern === packageName ||
+        matchesModuleEntry(effectivePath, pattern) ||
+        deepPathMatchesTail(
+          (facts ??= readDeepPathFacts(effectivePath, packageName)),
+          pattern.slice(packageName.length + 1),
+        )
+      ) {
+        matches.add(pattern)
+      }
+    }
+  }
+  for (const pattern of matcher.fallbackPatterns) {
+    if (matchesStubPattern(modulePath, pattern)) {
+      matches.add(pattern)
+    }
+  }
+}