@callstack/repack-dev-server 5.0.0-rc.2 → 5.0.0-rc.4

package/dist/plugins/multipart/multipartPlugin.js

@@ -4,52 +4,54 @@ import fastifyPlugin from 'fastify-plugin';
  * Implementation is based on:
  * https://github.com/facebook/metro/blob/347b1d7ed87995d7951aaa9fd597c04b06013dac/packages/metro/src/Server/MultipartResponse.js
  */
-
 const CRLF = '\r\n';
 const BOUNDARY = '3beqjf3apnqeu3h5jqorms4i';
 async function multipartPlugin(instance) {
-  function asMultipart() {
-    // We should check if is included in accept or if accept has multipart/* or */*,
-    // but React Native will set accept to exactly `multipart/mixed`, so a simple check
-    // will suffice.
-    if (this.request.headers.accept !== 'multipart/mixed') {
-      return undefined;
+    function asMultipart() {
+        // We should check if is included in accept or if accept has multipart/* or */*,
+        // but React Native will set accept to exactly `multipart/mixed`, so a simple check
+        // will suffice.
+        if (this.request.headers.accept !== 'multipart/mixed') {
+            return undefined;
+        }
+        const headers = {};
+        const stream = new PassThrough();
+        this.code(200)
+            .header('Content-Type', `multipart/mixed; boundary="${BOUNDARY}"`)
+            .send(stream);
+        function serializeHeaders(headers) {
+            return Object.keys(headers)
+                .map((key) => `${key}: ${headers[key]}`)
+                .join(CRLF);
+        }
+        function writeChunk(headers, data, isLast) {
+            let chunk = `${CRLF}--${BOUNDARY}${CRLF}`;
+            if (headers) {
+                chunk += serializeHeaders(headers) + CRLF + CRLF;
+            }
+            if (data) {
+                chunk += data;
+            }
+            if (isLast) {
+                chunk += `${CRLF}--${BOUNDARY}--${CRLF}`;
+            }
+            stream.write(chunk);
+        }
+        function setHeader(name, value) {
+            headers[name] = value;
+        }
+        function end(data) {
+            writeChunk(headers, data, true);
+            stream.end();
+        }
+        return {
+            writeChunk,
+            setHeader,
+            end,
+        };
     }
-    const headers = {};
-    const stream = new PassThrough();
-    this.code(200).header('Content-Type', `multipart/mixed; boundary="${BOUNDARY}"`).send(stream);
-    function serializeHeaders(headers) {
-      return Object.keys(headers).map(key => `${key}: ${headers[key]}`).join(CRLF);
-    }
-    function writeChunk(headers, data, isLast) {
-      let chunk = `${CRLF}--${BOUNDARY}${CRLF}`;
-      if (headers) {
-        chunk += serializeHeaders(headers) + CRLF + CRLF;
-      }
-      if (data) {
-        chunk += data;
-      }
-      if (isLast) {
-        chunk += `${CRLF}--${BOUNDARY}--${CRLF}`;
-      }
-      stream.write(chunk);
-    }
-    function setHeader(name, value) {
-      headers[name] = value;
-    }
-    function end(data) {
-      writeChunk(headers, data, true);
-      stream.end();
-    }
-    return {
-      writeChunk,
-      setHeader,
-      end
-    };
-  }
-  instance.decorateReply('asMultipart', asMultipart);
+    instance.decorateReply('asMultipart', asMultipart);
 }
 export default fastifyPlugin(multipartPlugin, {
-  name: 'multipart-plugin'
+    name: 'multipart-plugin',
 });
-//# sourceMappingURL=multipartPlugin.js.map

package/dist/plugins/multipart/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/plugins/symbolicate/Symbolicator.d.ts

@@ -1,6 +1,6 @@
 import type { FastifyLoggerInstance } from 'fastify';
 import { SourceMapConsumer } from 'source-map';
-import type { ReactNativeStackFrame, SymbolicatorDelegate, SymbolicatorResults } from './types';
+import type { ReactNativeStackFrame, SymbolicatorDelegate, SymbolicatorResults } from './types.js';
 /**
  * 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

package/dist/plugins/symbolicate/Symbolicator.js

@@ -8,201 +8,183 @@ import { SourceMapConsumer } from 'source-map';
  * 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) {
-    for (const frame of stack) {
-      if (!frame.file) {
-        continue;
-      }
-      const {
-        searchParams,
-        pathname
-      } = new URL(frame.file, 'file://');
-      const platform = searchParams.get('platform');
-      if (platform) {
-        return platform;
-      }
-      const [bundleFilename] = pathname.split('/').reverse();
-      const [, platformOrExtension, extension] = bundleFilename.split('.');
-      if (extension) {
-        return platformOrExtension;
-      }
-    }
-  }
-
-  /**
-   * Cache with initialized `SourceMapConsumer` to improve symbolication performance.
-   */
-  sourceMapConsumerCache = {};
-
-  /**
-   * Constructs new `Symbolicator` instance.
-   *
-   * @param delegate Delegate instance with symbolication functions.
-   */
-  constructor(delegate) {
-    this.delegate = delegate;
-  }
-
-  /**
-   * 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, stack) {
-    logger.debug({
-      msg: 'Filtering out unnecessary frames'
-    });
-    const frames = [];
-    for (const frame of stack) {
-      const {
-        file
-      } = frame;
-      if (file?.startsWith('http')) {
-        frames.push(frame);
-      }
-    }
-    try {
-      logger.debug({
-        msg: 'Processing frames',
-        frames
-      });
-      const processedFrames = [];
-      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;
+    /**
+     * 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) {
+        for (const frame of stack) {
+            if (!frame.file) {
+                continue;
+            }
+            const { searchParams, pathname } = new URL(frame.file, 'file://');
+            const platform = searchParams.get('platform');
+            if (platform) {
+                return platform;
+            }
+            const [bundleFilename] = pathname.split('/').reverse();
+            const [, platformOrExtension, extension] = bundleFilename.split('.');
+            if (extension) {
+                return platformOrExtension;
+            }
         }
-        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];
-      }
     }
-  }
-  processFrame(frame) {
-    if (!frame.lineNumber || !frame.column) {
-      return {
-        ...frame,
-        collapse: false
-      };
+    /**
+     * Constructs new `Symbolicator` instance.
+     *
+     * @param delegate Delegate instance with symbolication functions.
+     */
+    constructor(delegate) {
+        this.delegate = delegate;
+        /**
+         * Cache with initialized `SourceMapConsumer` to improve symbolication performance.
+         */
+        this.sourceMapConsumerCache = {};
     }
-    const consumer = this.sourceMapConsumerCache[frame.file];
-    if (!consumer) {
-      return {
-        ...frame,
-        collapse: false
-      };
-    }
-    const lookup = consumer.originalPositionFor({
-      line: frame.lineNumber,
-      column: frame.column,
-      bias: SourceMapConsumer.LEAST_UPPER_BOUND
-    });
-
-    // 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
-      };
+    /**
+     * 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, stack) {
+        logger.debug({ msg: 'Filtering out unnecessary frames' });
+        const frames = [];
+        for (const frame of stack) {
+            const { file } = frame;
+            if (file?.startsWith('http')) {
+                frames.push(frame);
+            }
+        }
+        try {
+            logger.debug({ msg: 'Processing frames', frames });
+            const processedFrames = [];
+            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];
+            }
+        }
     }
-    return {
-      lineNumber: lookup.line || frame.lineNumber,
-      column: lookup.column || frame.column,
-      file: lookup.source,
-      methodName: lookup.name || frame.methodName,
-      collapse: false
-    };
-  }
-  async getCodeFrame(logger, processedFrames) {
-    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 {
+    processFrame(frame) {
+        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,
+            bias: SourceMapConsumer.LEAST_UPPER_BOUND,
+        });
+        // 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 {
-          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
+            lineNumber: lookup.line || frame.lineNumber,
+            column: lookup.column || frame.column,
+            file: lookup.source,
+            methodName: lookup.name || frame.methodName,
+            collapse: false,
         };
-      } catch (error) {
-        logger.error({
-          msg: 'Failed to create code frame',
-          error: error.message
-        });
-      }
-      return undefined;
     }
-  }
+    async getCodeFrame(logger, processedFrames) {
+        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.message,
+                });
+            }
+            return undefined;
+        }
+    }
 }
-//# sourceMappingURL=Symbolicator.js.map

package/dist/plugins/symbolicate/index.d.ts

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

package/dist/plugins/symbolicate/index.js

@@ -1,4 +1,3 @@
-export { default } from "./sybmolicatePlugin.js";
-export * from "./Symbolicator.js";
-export * from "./types.js";
-//# sourceMappingURL=index.js.map
+export { default } from './sybmolicatePlugin.js';
+export * from './Symbolicator.js';
+export * from './types.js';

package/dist/plugins/symbolicate/sybmolicatePlugin.d.ts

@@ -1,5 +1,5 @@
 import type { FastifyInstance } from 'fastify';
-import type { Server } from '../../types';
+import type { Server } from '../../types.js';
 declare function symbolicatePlugin(instance: FastifyInstance, { delegate, }: {
     delegate: Server.Delegate;
 }): Promise<void>;

package/dist/plugins/symbolicate/sybmolicatePlugin.js

@@ -1,44 +1,33 @@
 import fastifyPlugin from 'fastify-plugin';
-import { Symbolicator } from "./Symbolicator.js";
-async function symbolicatePlugin(instance, {
-  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.
-
-    try {
-      const {
-        stack
-      } = JSON.parse(request.body);
-      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.message
-      });
-      reply.internalServerError();
-    }
-  });
+import { Symbolicator } from './Symbolicator.js';
+async function symbolicatePlugin(instance, { 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.
+        try {
+            const { stack } = JSON.parse(request.body);
+            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.message,
+            });
+            reply.internalServerError();
+        }
+    });
 }
 export default fastifyPlugin(symbolicatePlugin, {
-  name: 'symbolicate-plugin',
-  dependencies: ['@fastify/sensible']
+    name: 'symbolicate-plugin',
+    dependencies: ['@fastify/sensible'],
 });
-//# sourceMappingURL=sybmolicatePlugin.js.map

package/dist/plugins/symbolicate/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/plugins/wss/WebSocketRouter.d.ts

@@ -1,5 +1,5 @@
 import type { FastifyInstance } from 'fastify';
-import type { WebSocketServerInterface } from './types';
+import type { WebSocketServerInterface } from './types.js';
 /**
  * Class for creating a WebSocket router to forward connections to the
  * respective {@link WebSocketServer} as long as the connection is accepted for the upgrade by the