vxrn 0.1.4 → 0.1.6

package/src/vendor/repack/dev-server/src/plugins/symbolicate/Symbolicator.ts

@@ -1,233 +1,233 @@
-import { URL } from 'url'
-
-import { codeFrameColumns } from '@babel/code-frame'
-import type { FastifyLoggerInstance } from 'fastify'
-import { SourceMapConsumer } from 'source-map'
-
-import type {
-  CodeFrame,
-  InputStackFrame,
-  ReactNativeStackFrame,
-  StackFrame,
-  SymbolicatorDelegate,
-  SymbolicatorResults,
-} from './types'
-
-/**
- * Class for transforming stack traces from React Native application with using Source Map.
- * Raw stack frames produced by React Native, points to some location from the bundle
- * eg `index.bundle?platform=ios:567:1234`. By using Source Map for that bundle `Symbolicator`
- * produces frames that point to source code inside your project eg `Hello.tsx:10:9`.
- */
-export class Symbolicator {
-  /**
-   * Infer platform from stack frames.
-   * Usually at least one frame has `file` field with the bundle URL eg:
-   * `http://localhost:8081/index.bundle?platform=ios&...`, which can be used to infer platform.
-   *
-   * @param stack Array of stack frames.
-   * @returns Inferred platform or `undefined` if cannot infer.
-   */
-  static inferPlatformFromStack(stack: ReactNativeStackFrame[]) {
-    for (const frame of stack) {
-      if (!frame.file) {
-        return
-      }
-
-      const { searchParams, pathname } = new URL(frame.file, 'file://')
-      const platform = searchParams.get('platform')
-      if (platform) {
-        return platform
-      } else {
-        const [bundleFilename] = pathname.split('/').reverse()
-        const [, platformOrExtension, extension] = bundleFilename.split('.')
-        if (extension) {
-          return platformOrExtension
-        }
-      }
-    }
-  }
-
-  /**
-   * Cache with initialized `SourceMapConsumer` to improve symbolication performance.
-   */
-  sourceMapConsumerCache: Record<string, SourceMapConsumer> = {}
-
-  /**
-   * Constructs new `Symbolicator` instance.
-   *
-   * @param delegate Delegate instance with symbolication functions.
-   */
-  constructor(private delegate: SymbolicatorDelegate) {}
-
-  /**
-   * Process raw React Native stack frames and transform them using Source Maps.
-   * Method will try to symbolicate as much data as possible, but if the Source Maps
-   * are not available, invalid or the original positions/data is not found in Source Maps,
-   * the method will return raw values - the same as supplied with `stack` parameter.
-   * For example out of 10 frames, it's possible that only first 7 will be symbolicated and the
-   * remaining 3 will be unchanged.
-   *
-   * @param logger Fastify logger instance.
-   * @param stack Raw stack frames.
-   * @returns Symbolicated stack frames.
-   */
-  async process(
-    logger: FastifyLoggerInstance,
-    stack: ReactNativeStackFrame[]
-  ): Promise<SymbolicatorResults> {
-    logger.debug({ msg: 'Filtering out unnecessary frames' })
-
-    const frames: InputStackFrame[] = []
-    for (const frame of stack) {
-      const { file } = frame
-      if (file?.startsWith('http') && !file.includes('debuggerWorker')) {
-        frames.push(frame as InputStackFrame)
-      }
-    }
-
-    try {
-      logger.debug({ msg: 'Processing frames', frames })
-
-      const processedFrames: StackFrame[] = []
-      for (const frame of frames) {
-        if (!this.sourceMapConsumerCache[frame.file]) {
-          logger.debug({
-            msg: 'Loading raw source map data',
-            fileUrl: frame.file,
-          })
-
-          const rawSourceMap = await this.delegate.getSourceMap(frame.file)
-
-          logger.debug({
-            msg: 'Creating source map instance',
-            fileUrl: frame.file,
-            sourceMapLength: rawSourceMap.length,
-          })
-          const sourceMapConsumer = await new SourceMapConsumer(rawSourceMap.toString())
-
-          logger.debug({
-            msg: 'Saving source map instance into cache',
-            fileUrl: frame.file,
-          })
-          this.sourceMapConsumerCache[frame.file] = sourceMapConsumer
-        }
-
-        logger.debug({
-          msg: 'Symbolicating frame',
-          frame,
-        })
-        const processedFrame = this.processFrame(frame)
-
-        logger.debug({
-          msg: 'Finished symbolicating frame',
-          frame,
-        })
-        processedFrames.push(processedFrame)
-      }
-
-      const codeFrame = (await this.getCodeFrame(logger, processedFrames)) ?? null
-
-      logger.debug({
-        msg: 'Finished symbolicating frames',
-        processedFrames,
-        codeFrame,
-      })
-
-      return {
-        stack: processedFrames,
-        codeFrame,
-      }
-    } finally {
-      for (const key in this.sourceMapConsumerCache) {
-        this.sourceMapConsumerCache[key].destroy()
-        delete this.sourceMapConsumerCache[key]
-      }
-    }
-  }
-
-  private processFrame(frame: InputStackFrame): StackFrame {
-    if (!frame.lineNumber || !frame.column) {
-      return {
-        ...frame,
-        collapse: false,
-      }
-    }
-
-    const consumer = this.sourceMapConsumerCache[frame.file]
-    if (!consumer) {
-      return {
-        ...frame,
-        collapse: false,
-      }
-    }
-
-    const lookup = consumer.originalPositionFor({
-      line: frame.lineNumber,
-      column: frame.column,
-    })
-
-    // If lookup fails, we get the same shape object, but with
-    // all values set to null
-    if (!lookup.source) {
-      // It is better to gracefully return the original frame
-      // than to throw an exception
-      return {
-        ...frame,
-        collapse: false,
-      }
-    }
-
-    return {
-      lineNumber: lookup.line || frame.lineNumber,
-      column: lookup.column || frame.column,
-      file: lookup.source,
-      methodName: lookup.name || frame.methodName,
-      collapse: false,
-    }
-  }
-
-  private async getCodeFrame(
-    logger: FastifyLoggerInstance,
-    processedFrames: StackFrame[]
-  ): Promise<CodeFrame | undefined> {
-    for (const frame of processedFrames) {
-      if (frame.collapse || !frame.lineNumber || !frame.column) {
-        continue
-      }
-
-      if (!this.delegate.shouldIncludeFrame(frame)) {
-        return undefined
-      }
-
-      logger.debug({
-        msg: 'Generating code frame',
-        frame,
-      })
-
-      try {
-        return {
-          content: codeFrameColumns(
-            (await this.delegate.getSource(frame.file)).toString(),
-            {
-              start: { column: frame.column, line: frame.lineNumber },
-            },
-            { forceColor: true }
-          ),
-          location: {
-            row: frame.lineNumber,
-            column: frame.column,
-          },
-          fileName: frame.file,
-        }
-      } catch (error) {
-        logger.error({
-          msg: 'Failed to create code frame',
-          error: (error as Error).message,
-        })
-      }
-
-      return undefined
-    }
-  }
-}
+// import { URL } from 'url'
+
+// import { codeFrameColumns } from '@babel/code-frame'
+// import type { FastifyLoggerInstance } from 'fastify'
+// import { SourceMapConsumer } from 'source-map'
+
+// import type {
+//   CodeFrame,
+//   InputStackFrame,
+//   ReactNativeStackFrame,
+//   StackFrame,
+//   SymbolicatorDelegate,
+//   SymbolicatorResults,
+// } from './types'
+
+// /**
+//  * Class for transforming stack traces from React Native application with using Source Map.
+//  * Raw stack frames produced by React Native, points to some location from the bundle
+//  * eg `index.bundle?platform=ios:567:1234`. By using Source Map for that bundle `Symbolicator`
+//  * produces frames that point to source code inside your project eg `Hello.tsx:10:9`.
+//  */
+// export class Symbolicator {
+//   /**
+//    * Infer platform from stack frames.
+//    * Usually at least one frame has `file` field with the bundle URL eg:
+//    * `http://localhost:8081/index.bundle?platform=ios&...`, which can be used to infer platform.
+//    *
+//    * @param stack Array of stack frames.
+//    * @returns Inferred platform or `undefined` if cannot infer.
+//    */
+//   static inferPlatformFromStack(stack: ReactNativeStackFrame[]) {
+//     for (const frame of stack) {
+//       if (!frame.file) {
+//         return
+//       }
+
+//       const { searchParams, pathname } = new URL(frame.file, 'file://')
+//       const platform = searchParams.get('platform')
+//       if (platform) {
+//         return platform
+//       } else {
+//         const [bundleFilename] = pathname.split('/').reverse()
+//         const [, platformOrExtension, extension] = bundleFilename.split('.')
+//         if (extension) {
+//           return platformOrExtension
+//         }
+//       }
+//     }
+//   }
+
+//   /**
+//    * Cache with initialized `SourceMapConsumer` to improve symbolication performance.
+//    */
+//   sourceMapConsumerCache: Record<string, SourceMapConsumer> = {}
+
+//   /**
+//    * Constructs new `Symbolicator` instance.
+//    *
+//    * @param delegate Delegate instance with symbolication functions.
+//    */
+//   constructor(private delegate: SymbolicatorDelegate) {}
+
+//   /**
+//    * Process raw React Native stack frames and transform them using Source Maps.
+//    * Method will try to symbolicate as much data as possible, but if the Source Maps
+//    * are not available, invalid or the original positions/data is not found in Source Maps,
+//    * the method will return raw values - the same as supplied with `stack` parameter.
+//    * For example out of 10 frames, it's possible that only first 7 will be symbolicated and the
+//    * remaining 3 will be unchanged.
+//    *
+//    * @param logger Fastify logger instance.
+//    * @param stack Raw stack frames.
+//    * @returns Symbolicated stack frames.
+//    */
+//   async process(
+//     logger: FastifyLoggerInstance,
+//     stack: ReactNativeStackFrame[]
+//   ): Promise<SymbolicatorResults> {
+//     logger.debug({ msg: 'Filtering out unnecessary frames' })
+
+//     const frames: InputStackFrame[] = []
+//     for (const frame of stack) {
+//       const { file } = frame
+//       if (file?.startsWith('http') && !file.includes('debuggerWorker')) {
+//         frames.push(frame as InputStackFrame)
+//       }
+//     }
+
+//     try {
+//       logger.debug({ msg: 'Processing frames', frames })
+
+//       const processedFrames: StackFrame[] = []
+//       for (const frame of frames) {
+//         if (!this.sourceMapConsumerCache[frame.file]) {
+//           logger.debug({
+//             msg: 'Loading raw source map data',
+//             fileUrl: frame.file,
+//           })
+
+//           const rawSourceMap = await this.delegate.getSourceMap(frame.file)
+
+//           logger.debug({
+//             msg: 'Creating source map instance',
+//             fileUrl: frame.file,
+//             sourceMapLength: rawSourceMap.length,
+//           })
+//           const sourceMapConsumer = await new SourceMapConsumer(rawSourceMap.toString())
+
+//           logger.debug({
+//             msg: 'Saving source map instance into cache',
+//             fileUrl: frame.file,
+//           })
+//           this.sourceMapConsumerCache[frame.file] = sourceMapConsumer
+//         }
+
+//         logger.debug({
+//           msg: 'Symbolicating frame',
+//           frame,
+//         })
+//         const processedFrame = this.processFrame(frame)
+
+//         logger.debug({
+//           msg: 'Finished symbolicating frame',
+//           frame,
+//         })
+//         processedFrames.push(processedFrame)
+//       }
+
+//       const codeFrame = (await this.getCodeFrame(logger, processedFrames)) ?? null
+
+//       logger.debug({
+//         msg: 'Finished symbolicating frames',
+//         processedFrames,
+//         codeFrame,
+//       })
+
+//       return {
+//         stack: processedFrames,
+//         codeFrame,
+//       }
+//     } finally {
+//       for (const key in this.sourceMapConsumerCache) {
+//         this.sourceMapConsumerCache[key].destroy()
+//         delete this.sourceMapConsumerCache[key]
+//       }
+//     }
+//   }
+
+//   private processFrame(frame: InputStackFrame): StackFrame {
+//     if (!frame.lineNumber || !frame.column) {
+//       return {
+//         ...frame,
+//         collapse: false,
+//       }
+//     }
+
+//     const consumer = this.sourceMapConsumerCache[frame.file]
+//     if (!consumer) {
+//       return {
+//         ...frame,
+//         collapse: false,
+//       }
+//     }
+
+//     const lookup = consumer.originalPositionFor({
+//       line: frame.lineNumber,
+//       column: frame.column,
+//     })
+
+//     // If lookup fails, we get the same shape object, but with
+//     // all values set to null
+//     if (!lookup.source) {
+//       // It is better to gracefully return the original frame
+//       // than to throw an exception
+//       return {
+//         ...frame,
+//         collapse: false,
+//       }
+//     }
+
+//     return {
+//       lineNumber: lookup.line || frame.lineNumber,
+//       column: lookup.column || frame.column,
+//       file: lookup.source,
+//       methodName: lookup.name || frame.methodName,
+//       collapse: false,
+//     }
+//   }
+
+//   private async getCodeFrame(
+//     logger: FastifyLoggerInstance,
+//     processedFrames: StackFrame[]
+//   ): Promise<CodeFrame | undefined> {
+//     for (const frame of processedFrames) {
+//       if (frame.collapse || !frame.lineNumber || !frame.column) {
+//         continue
+//       }
+
+//       if (!this.delegate.shouldIncludeFrame(frame)) {
+//         return undefined
+//       }
+
+//       logger.debug({
+//         msg: 'Generating code frame',
+//         frame,
+//       })
+
+//       try {
+//         return {
+//           content: codeFrameColumns(
+//             (await this.delegate.getSource(frame.file)).toString(),
+//             {
+//               start: { column: frame.column, line: frame.lineNumber },
+//             },
+//             { forceColor: true }
+//           ),
+//           location: {
+//             row: frame.lineNumber,
+//             column: frame.column,
+//           },
+//           fileName: frame.file,
+//         }
+//       } catch (error) {
+//         logger.error({
+//           msg: 'Failed to create code frame',
+//           error: (error as Error).message,
+//         })
+//       }
+
+//       return undefined
+//     }
+//   }
+// }

package/src/vendor/repack/dev-server/src/plugins/symbolicate/index.ts

@@ -1,3 +1,3 @@
-export { default } from './sybmolicatePlugin'
-export * from './Symbolicator'
-export * from './types'
+// export { default } from './sybmolicatePlugin'
+// export * from './Symbolicator'
+// export * from './types'

package/src/vendor/repack/dev-server/src/plugins/symbolicate/sybmolicatePlugin.ts

@@ -1,48 +1,48 @@
-import type { FastifyInstance } from 'fastify'
-import fastifyPlugin from 'fastify-plugin'
+// import type { FastifyInstance } from 'fastify'
+// import fastifyPlugin from 'fastify-plugin'
 
-import type { Server } from '../../types'
-import { Symbolicator } from './Symbolicator'
-import type { ReactNativeStackFrame } from './types'
+// import type { Server } from '../../types'
+// import { Symbolicator } from './Symbolicator'
+// import type { ReactNativeStackFrame } from './types'
 
-async function symbolicatePlugin(
-  instance: FastifyInstance,
-  {
-    delegate,
-  }: {
-    delegate: Server.Delegate
-  }
-) {
-  const symbolicator = new Symbolicator(delegate.symbolicator)
+// async function symbolicatePlugin(
+//   instance: FastifyInstance,
+//   {
+//     delegate,
+//   }: {
+//     delegate: Server.Delegate
+//   }
+// ) {
+//   const symbolicator = new Symbolicator(delegate.symbolicator)
 
-  instance.post('/symbolicate', async (request, reply) => {
-    // React Native sends stack as JSON but tests content-type to text/plain, so
-    // we cannot use JSON schema to validate the body.
+//   instance.post('/symbolicate', async (request, reply) => {
+//     // React Native sends stack as JSON but tests content-type to text/plain, so
+//     // we cannot use JSON schema to validate the body.
 
-    try {
-      const { stack } = JSON.parse(request.body as string) as {
-        stack: ReactNativeStackFrame[]
-      }
-      const platform = Symbolicator.inferPlatformFromStack(stack)
-      if (!platform) {
-        request.log.debug({ msg: 'Received stack', stack })
-        reply.badRequest('Cannot infer platform from stack trace')
-      } else {
-        request.log.debug({ msg: 'Starting symbolication', platform, stack })
-        const results = await symbolicator.process(request.log, stack)
-        reply.send(results)
-      }
-    } catch (error) {
-      request.log.error({
-        msg: 'Failed to symbolicate',
-        error: (error as Error).message,
-      })
-      reply.internalServerError()
-    }
-  })
-}
+//     try {
+//       const { stack } = JSON.parse(request.body as string) as {
+//         stack: ReactNativeStackFrame[]
+//       }
+//       const platform = Symbolicator.inferPlatformFromStack(stack)
+//       if (!platform) {
+//         request.log.debug({ msg: 'Received stack', stack })
+//         reply.badRequest('Cannot infer platform from stack trace')
+//       } else {
+//         request.log.debug({ msg: 'Starting symbolication', platform, stack })
+//         const results = await symbolicator.process(request.log, stack)
+//         reply.send(results)
+//       }
+//     } catch (error) {
+//       request.log.error({
+//         msg: 'Failed to symbolicate',
+//         error: (error as Error).message,
+//       })
+//       reply.internalServerError()
+//     }
+//   })
+// }
 
-export default fastifyPlugin(symbolicatePlugin, {
-  name: 'symbolicate-plugin',
-  dependencies: ['fastify-sensible'],
-})
+// export default fastifyPlugin(symbolicatePlugin, {
+//   name: 'symbolicate-plugin',
+//   dependencies: ['fastify-sensible'],
+// })