@arms/rum-reactnative 0.1.4 → 0.1.5

package/harmony/rum_sdk/src/main/ets/crash/CrashManager.ts

@@ -0,0 +1,344 @@
+/**
+ * 崩溃文件管理器（鸿蒙端）。
+ *
+ * 与 Android 端语义对齐：崩溃报告以 JSON 文件形式持久化在应用沙箱
+ * {filesDir}/rum_crashes/ 目录，文件命名 crash_{timestamp}_{crash_id}.json；
+ * JS 层上报成功 ack 后按 crash_id 删除文件。
+ *
+ * 与 Android 的差异：鸿蒙应用无法在崩溃时同步落盘（ArkTS 无信号回调），
+ * 崩溃现场由系统 faultLogger 服务负责持久化；本模块在下次启动时调用
+ * faultLogger.query 拉取本应用 faultlog，解析转换为 Android 对齐结构的
+ * JSON 后落盘，再走既有的 getPendingCrashes / ack 链路。
+ *
+ * 去重策略：已落盘的 fault 指纹（type_timestamp_pid）记录在 preferences，
+ * 避免 ack 删除崩溃文件后 faultLogger 重复查询导致重复上报。
+ */
+import fs from '@ohos.file.fs'
+import faultLogger from '@ohos.faultLogger'
+import dataPreferences from '@ohos.data.preferences'
+import deviceInfo from '@ohos.deviceInfo'
+import bundleManager from '@ohos.bundle.bundleManager'
+import emitter from '@ohos.events.emitter'
+import type common from '@ohos.app.ability.common'
+import {
+  buildCrashJson,
+  makeCrashFileName,
+  parseFullLog,
+  type FaultInfo,
+} from './FaultLogParser'
+
+const CRASH_DIR_NAME = 'rum_crashes'
+const PREFS_NAME = 'com.aliyun.rum.reactnative'
+const CONTEXT_KEY = 'rum_crash_context'
+const PROCESSED_KEY = 'rum_processed_faults'
+/** 已处理 fault 指纹上限，防止 preferences 无限增长 */
+const PROCESSED_MAX = 50
+/** fault 过期时间：超过 7 天的 fault 不再落盘（与 JS 层 cleanupOldCrashes 对齐） */
+const FAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000
+
+export class CrashManager {
+  private context: common.UIAbilityContext
+  private crashDir: string
+  private prefs: dataPreferences.Preferences
+
+  constructor(context: common.UIAbilityContext) {
+    this.context = context
+    this.crashDir = `${context.filesDir}/${CRASH_DIR_NAME}`
+    this.prefs = dataPreferences.getPreferencesSync(context, { name: PREFS_NAME })
+    this.ensureCrashDir()
+  }
+
+  private ensureCrashDir(): void {
+    try {
+      if (!fs.accessSync(this.crashDir)) {
+        fs.mkdirSync(this.crashDir)
+      }
+    } catch (_) {
+      // 目录创建失败时后续文件操作会静默降级
+    }
+  }
+
+  // region fault 同步（faultLogger → 崩溃文件）
+
+  /**
+   * 拉取 faultLogger 中未处理的崩溃类 fault 并落盘，随后读取全部待上报崩溃文件。
+   * 仅处理 CPP_CRASH(2) / JS_CRASH(3)；APP_FREEZE 属卡顿范畴，不在崩溃采集范围。
+   */
+  async getPendingCrashes(): Promise<string> {
+    try {
+      const infos = (await faultLogger.query(
+        faultLogger.FaultType.NO_SPECIFIC
+      )) as Array<FaultInfo>
+      if (infos && infos.length > 0) {
+        const processed = this.loadProcessedFingerprints()
+        const now = Date.now()
+        for (const info of infos) {
+          if (info.type !== faultLogger.FaultType.CPP_CRASH &&
+            info.type !== faultLogger.FaultType.JS_CRASH) {
+            continue
+          }
+          const fingerprint = `${info.type}_${info.timestamp}_${info.pid}`
+          if (processed.has(fingerprint)) {
+            continue
+          }
+          // faultLogger.timestamp 为秒级
+          if (info.timestamp * 1000 >= now - FAULT_MAX_AGE_MS) {
+            this.persistFault(info)
+          }
+          processed.add(fingerprint)
+        }
+        this.saveProcessedFingerprints(processed)
+      }
+    } catch (_) {
+      // faultLogger 服务不可用时仅读取已落盘的崩溃文件
+    }
+    const names = this.listCrashFiles()
+    const arr: string[] = []
+    for (const name of names) {
+      try {
+        const text = fs.readTextSync(`${this.crashDir}/${name}`)
+        if (text) {
+          JSON.parse(text)
+          arr.push(text)
+        }
+      } catch (_) {
+        // 损坏文件跳过，由 cleanupOldCrashes 兜底清理
+      }
+    }
+    return `[${arr.join(',')}]`
+  }
+
+  /** 单条 fault 解析落盘 */
+  private persistFault(info: FaultInfo): void {
+    try {
+      const parsed = parseFullLog(info.fullLog || '')
+      const json = buildCrashJson({
+        info,
+        parsed,
+        contextJson: this.readContextRaw(),
+        deviceJson: JSON.stringify(buildDevice()),
+        appJson: JSON.stringify(buildApp(this.context)),
+      })
+      this.writeFile(`${this.crashDir}/${makeCrashFileName(info)}`, json)
+    } catch (_) {
+      // 单条 fault 处理失败不影响其余数据
+    }
+  }
+
+  // endregion
+
+  // region 崩溃文件删除（对齐 Android 端语义）
+
+  /** 按 crash_id 删除崩溃文件（文件名后缀匹配） */
+  clearCrashReports(crashIds: string): void {
+    const ids = new Set<string>()
+    try {
+      const parsed = JSON.parse(crashIds) as string[]
+      for (const id of parsed) {
+        if (id) {
+          ids.add(id)
+        }
+      }
+    } catch (_) {
+      return
+    }
+    if (ids.size === 0) {
+      return
+    }
+    for (const name of this.listCrashFiles()) {
+      for (const id of ids) {
+        if (name.endsWith(`_${id}.json`) || name === `${id}.json`) {
+          this.deleteFile(`${this.crashDir}/${name}`)
+          break
+        }
+      }
+    }
+  }
+
+  clearAllCrashReports(): void {
+    for (const name of this.listCrashFiles()) {
+      this.deleteFile(`${this.crashDir}/${name}`)
+    }
+  }
+
+  /** 清理过期与超限的崩溃文件 */
+  cleanupOldCrashes(maxFiles: number, maxAgeMs: number): void {
+    const limit = maxFiles > 0 ? maxFiles : 1
+    const names = this.listCrashFiles()
+    if (names.length === 0) {
+      return
+    }
+    const now = Date.now()
+    const entries: Array<{ name: string; ts: number }> = []
+    for (const name of names) {
+      const ts = parseTimestampFromName(name)
+      const expired = ts > 0 && now - ts > maxAgeMs
+      if (expired) {
+        this.deleteFile(`${this.crashDir}/${name}`)
+      } else {
+        entries.push({ name, ts })
+      }
+    }
+    if (entries.length > limit) {
+      entries.sort((a, b) => a.ts - b.ts)
+      const overflow = entries.slice(0, entries.length - limit)
+      for (const entry of overflow) {
+        this.deleteFile(`${this.crashDir}/${entry.name}`)
+      }
+    }
+  }
+
+  /** 崩溃目录中是否存在崩溃文件 */
+  hasCrashFiles(): boolean {
+    return this.listCrashFiles().length > 0
+  }
+
+  // endregion
+
+  // region 崩溃上下文（session / view 快照，JS 侧变更时同步）
+
+  updateContext(contextJson: string): void {
+    try {
+      this.prefs.putSync(CONTEXT_KEY, contextJson)
+      this.prefs.flush()
+    } catch (_) {
+      // ignore
+    }
+  }
+
+  readContextRaw(): string {
+    try {
+      if (this.prefs.hasSync(CONTEXT_KEY)) {
+        return this.prefs.getSync(CONTEXT_KEY, '') as string
+      }
+    } catch (_) {
+      // ignore
+    }
+    return ''
+  }
+
+  // endregion
+
+  // region 内部工具
+
+  /** 列出崩溃目录下的崩溃报告文件（排除子目录与临时文件） */
+  private listCrashFiles(): string[] {
+    try {
+      if (!fs.accessSync(this.crashDir)) {
+        return []
+      }
+      const names = fs.listFileSync(this.crashDir)
+      return names.filter((name) => {
+        return name.endsWith('.json') && name.startsWith('crash_')
+      })
+    } catch (_) {
+      return []
+    }
+  }
+
+  private writeFile(path: string, content: string): void {
+    const file = fs.openSync(path, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE | fs.OpenMode.TRUNC)
+    try {
+      fs.writeSync(file.fd, content)
+    } finally {
+      fs.closeSync(file)
+    }
+  }
+
+  private deleteFile(path: string): void {
+    try {
+      fs.unlinkSync(path)
+    } catch (_) {
+      // ignore
+    }
+  }
+
+  private loadProcessedFingerprints(): Set<string> {
+    const result = new Set<string>()
+    try {
+      if (this.prefs.hasSync(PROCESSED_KEY)) {
+        const raw = this.prefs.getSync(PROCESSED_KEY, '[]') as string
+        const arr = JSON.parse(raw) as string[]
+        for (const item of arr) {
+          result.add(item)
+        }
+      }
+    } catch (_) {
+      // ignore
+    }
+    return result
+  }
+
+  private saveProcessedFingerprints(set: Set<string>): void {
+    try {
+      // 只保留最近的指纹，超出上限时丢最旧的（Set 保持插入序）
+      let items = Array.from(set)
+      if (items.length > PROCESSED_MAX) {
+        items = items.slice(items.length - PROCESSED_MAX)
+      }
+      this.prefs.putSync(PROCESSED_KEY, JSON.stringify(items))
+      this.prefs.flush()
+    } catch (_) {
+      // ignore
+    }
+  }
+
+  // endregion
+}
+
+/** 从文件名 crash_{timestamp}_{crash_id}.json 提取毫秒时间戳，解析失败返回 -1 */
+function parseTimestampFromName(name: string): number {
+  const m = name.match(/^crash_(\d+)_/)
+  if (m) {
+    const ts = Number(m[1])
+    if (Number.isFinite(ts) && ts > 0) {
+      return ts
+    }
+  }
+  return -1
+}
+
+/** 设备信息（对齐 Android CrashHandler.buildDevice 字段） */
+function buildDevice(): Record<string, Object> {
+  const obj: Record<string, Object> = {}
+  try {
+    obj.model = deviceInfo.productModel
+    obj.brand = deviceInfo.manufacture
+    obj.os_version = deviceInfo.osFullName
+  } catch (_) {
+    // ignore
+  }
+  return obj
+}
+
+/** 应用信息（对齐 Android CrashHandler.buildApp 字段） */
+function buildApp(context: common.UIAbilityContext): Record<string, Object> {
+  const obj: Record<string, Object> = {}
+  try {
+    const bundleInfo = bundleManager.getBundleInfoForSelfSync(
+      bundleManager.BundleFlag.GET_BUNDLE_INFO_DEFAULT
+    )
+    obj.package = bundleInfo.name
+    obj.version = bundleInfo.versionName
+    obj.build = String(bundleInfo.versionCode)
+  } catch (_) {
+    obj.package = context.applicationInfo.name
+  }
+  return obj
+}
+
+/**
+ * 测试崩溃事件 ID：SDK 侧 triggerTestCrash 通过 emitter 发出，
+ * 由应用主线程（UIAbility）侧订阅并抛出未捕获异常。
+ *
+ * HarmonyOS 新版本中 worker 线程的未捕获异常不再导致进程退出（也不生成
+ * faultlog），只有主线程（JSAPP）未捕获异常会产生 JS_CRASH faultlog；
+ * 而 TurboModule 运行在 RNOH worker 线程，因此测试崩溃需要应用侧在
+ * 主线程配合订阅（见 example-harmony EntryAbility）。
+ */
+export const TEST_CRASH_EVENT_ID = 9527
+
+/** 测试崩溃触发（triggerTestCrash 调用）：通知应用主线程抛出未捕获异常 */
+export function triggerArkTsCrash(): void {
+  emitter.emit({ eventId: TEST_CRASH_EVENT_ID })
+}

package/harmony/rum_sdk/src/main/ets/crash/FaultLogParser.ts

@@ -0,0 +1,331 @@
+/**
+ * faultLogger fullLog 文本解析与崩溃 JSON 构建。
+ *
+ * faultlog 文本格式无强契约（JS_CRASH / CPP_CRASH / 不同系统版本的段落存在差异），
+ * 解析策略为「容忍式提取」：能解析出结构化堆栈则输出帧数据，
+ * 解析失败时依赖 raw_log 透传保证信息不丢失。
+ *
+ * 已实测的 JS_CRASH 格式（API 20）关键段落：
+ *   Reason:Error
+ *   Error name:Error
+ *   Error message:RUM SDK Test: Uncaught ArkTS Exception
+ *   Stacktrace:
+ *       at anonymous entry (entry/src/main/ets/entryability/EntryAbility.ets:14:13)
+ *   HybridStack:
+ *   #00 pc 0000000000413db0 /system/lib64/platformsdk/libark_jsruntime.so(hash)
+ *   HiLog:
+ *   （日志内容，不应参与堆栈解析）
+ */
+
+/** 崩溃帧（与 JS 层 NativeCrashFrame 对齐，采用 NDK 风格字段以便 formatStack 消费） */
+export interface ParsedFrame {
+  library?: string
+  symbol?: string
+  address?: string
+  offset?: string
+  line?: number
+}
+
+/** fullLog 解析结果 */
+export interface ParsedFullLog {
+  /** 崩溃线程 id（取自 "Tid:" 行，解析失败时由调用方用 pid 兜底） */
+  tid: string
+  /** JS 栈帧（JS_CRASH 的 "at fn (file:line:col)" 格式） */
+  jsFrames: ParsedFrame[]
+  /** 原生机帧（"#NN pc addr lib(sym+off)" 格式） */
+  pcFrames: ParsedFrame[]
+  /** "Error name:" 行（JS_CRASH） */
+  errorName: string
+  /** "Error message:" 行（JS_CRASH） */
+  errorMessage: string
+}
+
+/** faultLogger FaultLogInfo（@ohos.faultLogger 已废弃但 API 20 仍可用，此处仅声明用到的字段） */
+export interface FaultInfo {
+  pid: number
+  uid: number
+  type: number
+  /** 秒级时间戳 */
+  timestamp: number
+  reason: string
+  module: string
+  summary: string
+  fullLog: string
+}
+
+/** 原生帧行：#00 pc 0000000000014d74 /system/lib/xxx.so(func+0xb4) */
+const PC_FRAME_RE = /^#(\w+)\s+pc\s+(0x[0-9a-fA-F]+|\d+)\s+(\S+)\s*(.*)$/
+
+/** 原生帧尾部符号：func+0xb4 */
+const PC_SYMBOL_RE = /^(\S+?)\+(0x[0-9a-fA-F]+|\d+)$/
+
+/** JS 帧（at 格式，symbol 可含空格）：at anonymous entry (file.ets:12:5) */
+const JS_FRAME_PAREN_RE = /^\s*at\s+(.+?)\s*\((.+?):(\d+)(?::(\d+))?\)\s*$/
+
+/** JS 帧（无括号格式）：at file.ets:12:5 */
+const JS_FRAME_BARE_RE = /^\s*at\s+(.+?):(\d+)(?::(\d+))?\s*$/
+
+/** 头部属性行：Tid:825 */
+const TID_RE = /^Tid:\s*(\d+)/
+
+/** 键值属性行：Error name:xxx / Reason:xxx */
+const ATTRIB_RE = /^([A-Za-z][A-Za-z0-9 _]*?):\s*(.*)$/
+
+/** 段落标题行（无值）：Stacktrace: / HybridStack: / HiLog: */
+const SECTION_RE = /^([A-Za-z][A-Za-z0-9 _]*?):\s*$/
+
+/** 帧数超过 512 时双侧截断，中间插入标记帧（与 Android 端策略一致） */
+const TRUNCATION_THRESHOLD = 512
+const KEEP_PER_SIDE = 256
+
+function truncateFrames(frames: ParsedFrame[]): ParsedFrame[] {
+  if (frames.length <= TRUNCATION_THRESHOLD) {
+    return frames
+  }
+  const head = frames.slice(0, KEEP_PER_SIDE)
+  const tail = frames.slice(frames.length - KEEP_PER_SIDE)
+  const marker: ParsedFrame = {
+    symbol: 'frames omitted',
+    library: 'truncated',
+    address: `omitted_count=${frames.length - TRUNCATION_THRESHOLD}`,
+  }
+  return head.concat([marker]).concat(tail)
+}
+
+/** 段落内堆栈解析开关：HiLog 等日志段内的 "at"/pc 行不参与解析 */
+function isStackSection(section: string): boolean {
+  return section === 'Stacktrace' ||
+    section === 'HybridStack' ||
+    section === 'Fault thread Info' ||
+    section === 'JsStack' ||
+    section === 'Js stack'
+}
+
+/**
+ * 解析 fullLog 文本，提取崩溃线程、异常信息与堆栈帧。
+ */
+export function parseFullLog(fullLog: string): ParsedFullLog {
+  const result: ParsedFullLog = { tid: '', jsFrames: [], pcFrames: [], errorName: '', errorMessage: '' }
+  if (!fullLog) {
+    return result
+  }
+  let section = ''
+  const lines = fullLog.split('\n')
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\r$/, '')
+    const sectionMatch = line.match(SECTION_RE)
+    if (sectionMatch) {
+      section = sectionMatch[1] ?? ''
+      continue
+    }
+    const attribMatch = line.match(ATTRIB_RE)
+    if (attribMatch) {
+      const key = attribMatch[1] ?? ''
+      const value = attribMatch[2] ?? ''
+      if (key === 'Error name') {
+        result.errorName = value
+        continue
+      }
+      if (key === 'Error message') {
+        result.errorMessage = value
+        continue
+      }
+      const tidMatch = line.match(TID_RE)
+      if (tidMatch && !result.tid) {
+        result.tid = tidMatch[1] ?? ''
+        continue
+      }
+      continue
+    }
+    if (!isStackSection(section)) {
+      continue
+    }
+    if (line.startsWith('#')) {
+      const frame = parsePcFrame(line)
+      if (frame) {
+        result.pcFrames.push(frame)
+      }
+      continue
+    }
+    const trimmed = line.trim()
+    if (trimmed.startsWith('at ')) {
+      const frame = parseJsFrame(trimmed)
+      if (frame) {
+        result.jsFrames.push(frame)
+      }
+    }
+  }
+  return result
+}
+
+/** 解析原生机帧行 */
+function parsePcFrame(line: string): ParsedFrame | undefined {
+  const m = line.match(PC_FRAME_RE)
+  if (!m) {
+    return undefined
+  }
+  const address = m[2] ?? ''
+  const library = m[3] ?? ''
+  const tail = (m[4] ?? '').trim()
+  const frame: ParsedFrame = { library, address }
+  if (tail) {
+    // 尾部形如 "(func+0xb4)" 或 "(func+0xb4)(build_id_hash)"
+    const symbolPart = tail.replace(/^\(/, '').split(')')[0] ?? ''
+    const sym = symbolPart.match(PC_SYMBOL_RE)
+    if (sym) {
+      frame.symbol = sym[1]
+      frame.offset = sym[2]
+    } else if (symbolPart) {
+      frame.symbol = symbolPart
+    }
+  }
+  return frame
+}
+
+/** 解析 JS 栈帧行 */
+function parseJsFrame(line: string): ParsedFrame | undefined {
+  const paren = line.match(JS_FRAME_PAREN_RE)
+  if (paren) {
+    const frame = buildJsFrame(paren[2] ?? '', paren[3], paren[4])
+    const symbol = paren[1]?.trim() ?? ''
+    if (symbol) {
+      frame.symbol = symbol
+    }
+    return frame
+  }
+  const bare = line.match(JS_FRAME_BARE_RE)
+  if (bare) {
+    return buildJsFrame(bare[1] ?? '', bare[2], bare[3])
+  }
+  return undefined
+}
+
+function buildJsFrame(file: string, lineNo: string, colNo?: string): ParsedFrame {
+  const lineNum = Number(lineNo)
+  const frame: ParsedFrame = {
+    library: file,
+    line: Number.isFinite(lineNum) ? lineNum : 0,
+  }
+  if (colNo) {
+    frame.offset = colNo
+  }
+  return frame
+}
+
+/** fault 类别到崩溃 JSON exception.type 的映射 */
+function faultTypeToName(type: number): string {
+  if (type === 2) {
+    return 'cpp_crash'
+  }
+  if (type === 4) {
+    return 'app_freeze'
+  }
+  return 'js_crash'
+}
+
+/** 从 reason 提取异常类名（如 "TypeError: xxx" → "TypeError"；信号名整行返回） */
+function extractClassName(reason: string): string {
+  const text = (reason || '').trim()
+  if (!text) {
+    return ''
+  }
+  const firstLine = text.split('\n')[0] ?? text
+  const idx = firstLine.indexOf(':')
+  if (idx > 0 && !firstLine.slice(0, idx).includes(' ')) {
+    return firstLine.slice(0, idx)
+  }
+  return firstLine
+}
+
+/** raw_log 截断上限：faultlog 全文（含 HiLog 段）可能超过 100KB，防止事件体积失控 */
+const RAW_LOG_MAX_LENGTH = 32 * 1024
+
+export interface BuildCrashJsonParams {
+  info: FaultInfo
+  parsed: ParsedFullLog
+  contextJson: string
+  deviceJson: string
+  appJson: string
+}
+
+/**
+ * 构建 Android 对齐结构的崩溃 JSON（JS 层 convertCrashToRumEvent 直接消费）：
+ * crash_id / timestamp(ms) / platform / exception / crashed_thread /
+ * context / device / app / mechanism / raw_log。
+ */
+export function buildCrashJson(params: BuildCrashJsonParams): string {
+  const { info, parsed } = params
+  const crashId = `hm_${info.type}_${info.timestamp}_${info.pid}`
+  const type = faultTypeToName(info.type)
+
+  // JS 崩溃优先使用 JS 栈（符号化、可读），否则使用原生机帧
+  const frames = truncateFrames(
+    parsed.jsFrames.length > 0 ? parsed.jsFrames : parsed.pcFrames
+  )
+
+  // FaultLogInfo.reason 对 JS 崩溃仅为错误名（如 "Error"），
+  // 完整信息需从 fullLog 的 Error name / Error message 提取
+  const className = parsed.errorName || extractClassName(info.reason)
+  const message = parsed.errorMessage || (info.reason || '').trim()
+
+  const exception: Record<string, Object> = {
+    type,
+    class_name: className || 'HarmonyCrash',
+    message,
+  }
+
+  const crashedThread: Record<string, Object> = {
+    id: parsed.tid !== '' ? parsed.tid : String(info.pid),
+    name: info.module || '',
+    frames: frames as Object[],
+  }
+
+  const mechanism: Record<string, Object> = {
+    type,
+    handled: false,
+    fault_type: String(info.type),
+  }
+
+  const root: Record<string, Object> = {
+    crash_id: crashId,
+    timestamp: info.timestamp * 1000,
+    platform: 'harmony',
+    exception: exception as Object,
+    crashed_thread: crashedThread as Object,
+    mechanism: mechanism as Object,
+    pid: info.pid,
+    context: safeParse(params.contextJson) as Object,
+    device: safeParse(params.deviceJson) as Object,
+    app: safeParse(params.appJson) as Object,
+  }
+
+  const rawLog = info.fullLog || ''
+  if (rawLog.length > RAW_LOG_MAX_LENGTH) {
+    root.raw_log = `${rawLog.slice(0, RAW_LOG_MAX_LENGTH)}...[truncated]`
+  } else {
+    root.raw_log = rawLog
+  }
+
+  return JSON.stringify(root)
+}
+
+function safeParse(text: string): Record<string, Object> | Object {
+  if (!text) {
+    return {}
+  }
+  try {
+    const obj = JSON.parse(text)
+    if (obj !== null && typeof obj === 'object') {
+      return obj as Record<string, Object>
+    }
+    return {}
+  } catch (_) {
+    return {}
+  }
+}
+
+/** 崩溃文件命名：crash_{毫秒时间戳}_{crash_id}.json（crash_id 与 buildCrashJson 派生一致） */
+export function makeCrashFileName(info: FaultInfo): string {
+  const crashId = `hm_${info.type}_${info.timestamp}_${info.pid}`
+  return `crash_${info.timestamp * 1000}_${crashId}.json`
+}

package/harmony/rum_sdk/src/main/ets/generated/components/ts.ts

@@ -0,0 +1,5 @@
+
+/**
+ */
+
+export {}

package/harmony/rum_sdk/src/main/ets/generated/index.ets

@@ -0,0 +1,5 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * from "./ts"

package/harmony/rum_sdk/src/main/ets/generated/ts.ts

@@ -0,0 +1,6 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * as RNC from "./components/ts"
+export * as TM from "./turboModules/ts"