peachsim 0.1.527

package/src/index.ts

@@ -0,0 +1,71 @@
+// sootsim public package — SDK client, CLI + framework integrations.
+//
+// the bridge client and plugins live here. the canvas rendering engine lives
+// in the private `sootsim-engine` workspace package.
+
+export { connect, type ConnectOptions } from './connect'
+export {
+  SimClient,
+  SimClientError,
+  SimConnectError,
+  SimKeyboardError,
+  SimPerformError,
+  SimReadyTimeoutError,
+  SimResetError,
+  SimTapError,
+  type SimClientOptions,
+  type SimFindOptions,
+  type SimPerformStep,
+  type SimScreenshot,
+  type SimTapTarget,
+} from './sim-client'
+export type {
+  PerformOptions,
+  PerformResult,
+  PerformStep,
+  ResetOptions,
+  ResetResult,
+  SimStateOptions,
+  SimStateResult,
+  SimSemanticGeometry,
+  SimSemanticNode,
+  SimSemanticQuery,
+  SimSemanticQueryResult,
+  SimSemanticResolveResult,
+  SimSemanticResolveSelector,
+  SimSemanticSelector,
+} from './bridge-contract'
+export {
+  isRnxCaptureRegionAtlas,
+  isRnxScreenCapture,
+  rnxCaptureRasterRegions,
+  rnxRasterFrames,
+  RNX_SCREEN_CAPTURE_VERSION,
+  selectRnxRasterNodeIds,
+  type RnxCaptureAccessibility,
+  type RnxCaptureAccessibilityState,
+  type RnxCaptureAccessibilityValue,
+  type RnxCaptureAtlasRegion,
+  type RnxCaptureInteractionState,
+  type RnxCaptureNode,
+  type RnxCaptureRect,
+  type RnxCaptureRegionAtlas,
+  type RnxCaptureRegionRequest,
+  type RnxCaptureSource,
+  type RnxCaptureStyleTokenBinding,
+  type RnxCaptureTextLine,
+  type RnxCaptureTextSegment,
+  type RnxCaptureTree,
+  type RnxCaptureVisualEvidence,
+  type RnxRasterRegionTree,
+  type RnxScreenCapture,
+} from './capture-contract'
+
+export { rnxPlugin } from './vite-plugin-one'
+export { default as metroPlugin } from './metro-plugin'
+export { default as jumpToSourceBabelPlugin } from './jump-to-source-babel'
+export {
+  DEFAULT_SOOTSIM_BRIDGE_PORT,
+  DEFAULT_SOOTSIM_BRIDGE_URL,
+} from './bridge-constants'
+export { DEFAULT_SOOTSIM_SHELL_URL } from './cli-constants'

package/src/jump-to-source-babel.ts

@@ -0,0 +1,135 @@
+export interface SootsimJumpToSourceBabelOptions {
+  enabled?: boolean
+  attrName?: string
+  include?: readonly SourcePathMatcher[]
+  exclude?: readonly SourcePathMatcher[]
+}
+
+type SourcePathMatcher = string | RegExp
+
+interface BabelApi {
+  types: {
+    jsxAttribute(name: unknown, value: unknown): JSXAttributeNode
+    jsxIdentifier(name: string): unknown
+    stringLiteral(value: string): unknown
+  }
+}
+
+interface BabelPluginState {
+  file?: {
+    opts?: {
+      filename?: string
+    }
+  }
+}
+
+interface SourceLocation {
+  line: number
+  column: number
+}
+
+interface JSXNameNode {
+  type: string
+  name?: string
+  object?: JSXNameNode
+  property?: JSXNameNode
+}
+
+interface JSXAttributeNode {
+  type: string
+  name?: JSXNameNode
+}
+
+interface JSXOpeningElementNode {
+  name?: JSXNameNode
+  attributes?: JSXAttributeNode[]
+  loc?: {
+    start?: SourceLocation
+  }
+}
+
+interface JSXOpeningElementPath {
+  node: JSXOpeningElementNode
+}
+
+function normalizeSourcePath(path: string): string {
+  const queryStart = path.indexOf('?')
+  const clean = queryStart >= 0 ? path.slice(0, queryStart) : path
+  return clean.replace(/\\/g, '/')
+}
+
+function matchesPath(path: string, matcher: SourcePathMatcher): boolean {
+  return typeof matcher === 'string' ? path.includes(matcher) : matcher.test(path)
+}
+
+function shouldStampFile(
+  filename: string,
+  options: SootsimJumpToSourceBabelOptions,
+): boolean {
+  const normalized = normalizeSourcePath(filename)
+  if (normalized.includes('/node_modules/')) return false
+  if (normalized.includes('/dist/') || normalized.includes('/build/')) return false
+  if (options.exclude?.some((matcher) => matchesPath(normalized, matcher))) return false
+  if (options.include?.length) {
+    return options.include.some((matcher) => matchesPath(normalized, matcher))
+  }
+  return true
+}
+
+function getJSXName(node: JSXNameNode | undefined): string | null {
+  if (!node) return null
+  if (node.type === 'JSXIdentifier' && node.name) return node.name
+  if (node.type === 'JSXMemberExpression') {
+    const object = getJSXName(node.object)
+    const property = getJSXName(node.property)
+    return object && property ? `${object}.${property}` : null
+  }
+  return null
+}
+
+function hasAttribute(node: JSXOpeningElementNode, attrName: string): boolean {
+  return (
+    node.attributes?.some((attr) => {
+      if (attr.type !== 'JSXAttribute') return false
+      return attr.name?.type === 'JSXIdentifier' && attr.name.name === attrName
+    }) ?? false
+  )
+}
+
+export default function sootsimJumpToSourceBabelPlugin(
+  api: BabelApi,
+  options: SootsimJumpToSourceBabelOptions = {},
+) {
+  const attrName = options.attrName || 'srcloc'
+
+  return {
+    name: 'sootsim-jump-to-source',
+    visitor: {
+      JSXOpeningElement(path: JSXOpeningElementPath, state: BabelPluginState) {
+        if (options.enabled === false) return
+
+        const filename = state.file?.opts?.filename
+        if (!filename || !shouldStampFile(filename, options)) return
+
+        const node = path.node
+        const tagName = getJSXName(node.name)
+        if (!tagName || tagName === 'Fragment' || tagName.endsWith('.Fragment')) return
+        if (hasAttribute(node, attrName)) return
+
+        const loc = node.loc?.start
+        if (!loc) return
+
+        const source = `${normalizeSourcePath(filename)}:${loc.line}:${loc.column + 1}`
+        node.attributes ??= []
+        node.attributes.push(
+          api.types.jsxAttribute(
+            api.types.jsxIdentifier(attrName),
+            api.types.stringLiteral(source),
+          ),
+        )
+      },
+    },
+  }
+}
+
+export { sootsimJumpToSourceBabelPlugin }

package/src/jump-to-source-native.ts

@@ -0,0 +1,102 @@
+import MagicString from 'magic-string'
+import { parseSync, Visitor } from 'oxc-parser'
+import type { SootsimJumpToSourceBabelOptions } from './jump-to-source-babel.ts'
+
+export type JumpToSourceNativeOptions = SootsimJumpToSourceBabelOptions
+
+function matchesPath(path: string, matcher: string | RegExp): boolean {
+  return typeof matcher === 'string' ? path.includes(matcher) : matcher.test(path)
+}
+
+// stamp the same one-based source locations as the babel plugin before native
+// jsx compilation, without running babel in the native bundle pipeline.
+export function stampJsxSourceLocations(
+  code: string,
+  filename: string,
+  options: JumpToSourceNativeOptions = {},
+): string | null {
+  if (options.enabled === false || !filename || !code.includes('<')) return null
+  const source = filename.split('?')[0].replace(/\\/g, '/')
+  if (
+    source.includes('/node_modules/') ||
+    source.includes('/dist/') ||
+    source.includes('/build/')
+  )
+    return null
+  if (options.exclude?.some((matcher) => matchesPath(source, matcher))) return null
+  if (
+    options.include?.length &&
+    !options.include.some((matcher) => matchesPath(source, matcher))
+  )
+    return null
+
+  const { program, errors } = parseSync(source, code, {
+    lang: source.endsWith('.tsx') ? 'tsx' : source.endsWith('.ts') ? 'ts' : 'jsx',
+  })
+  if (errors.length) return null
+
+  const attrName = options.attrName || 'srcloc'
+  const lineStarts = [0]
+  for (let i = 0; i < code.length; i++) {
+    if (code.charCodeAt(i) === 10) lineStarts.push(i + 1)
+  }
+  const magic = new MagicString(code)
+  let stamped = false
+  new Visitor({
+    JSXOpeningElement(node) {
+      const name = node.name
+      if (name.type === 'JSXNamespacedName') return
+      if (name.type === 'JSXIdentifier' && name.name === 'Fragment') return
+      if (name.type === 'JSXMemberExpression' && name.property.name === 'Fragment') return
+      if (
+        node.attributes.some(
+          (attr) =>
+            attr.type === 'JSXAttribute' &&
+            attr.name.type === 'JSXIdentifier' &&
+            attr.name.name === attrName,
+        )
+      )
+        return
+
+      // binary search keeps location lookup logarithmic for large source files.
+      let lo = 0
+      let hi = lineStarts.length - 1
+      while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1
+        if (lineStarts[mid] <= node.start) lo = mid
+        else hi = mid - 1
+      }
+      const location = `${source}:${lo + 1}:${node.start - lineStarts[lo] + 1}`
+      // append after spreads, matching babel's precedence. a jsx expression
+      // preserves path characters that a quoted jsx attribute would decode.
+      magic.appendLeft(
+        node.end - (node.selfClosing ? 2 : 1),
+        ` ${attrName}={${JSON.stringify(location)}}`,
+      )
+      stamped = true
+    },
+  }).visit(program)
+  return stamped ? magic.toString() : null
+}
+
+// metro's nativeTransformModules accepts module ids; consumers can export an
+// instance of this transform from a module to supply their include filters.
+export function createJumpToSourceNativeTransform(
+  options: JumpToSourceNativeOptions = {},
+) {
+  return function jumpToSourceNativeTransform(code: string, ctx: { filename: string }) {
+    return stampJsxSourceLocations(code, ctx.filename, options)
+  }
+}
+
+export function jumpToSourceNativePlugin(options: JumpToSourceNativeOptions = {}) {
+  return {
+    name: 'sootsim-jump-to-source',
+    transform(code: string, id: string) {
+      const stamped = stampJsxSourceLocations(code, id, options)
+      return stamped == null ? null : { code: stamped, map: null }
+    },
+  }
+}
+
+export default createJumpToSourceNativeTransform()