@teardown/cli 1.2.20 → 1.2.22

package/dist/modules/dev/dev-server/plugins/wss/web-socket-router.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketRouter = void 0;
+/**
+ * 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
+ * server.
+ *
+ * If the connection is not accepted by any `WebSocketServer`, it will be destroyed to avoid
+ * creating handling connections and potentially throwing `ECONNRESET` errors.
+ *
+ * @category Development server
+ */
+class WebSocketRouter {
+    fastify;
+    /** The list of all register WebSocket servers. */
+    servers = [];
+    /**
+     * Create new instance of `WebSocketRouter` and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket router to.
+     */
+    constructor(fastify) {
+        this.fastify = fastify;
+        this.fastify.server.on("upgrade", (request, socket, head) => {
+            // console.log("WebSocketRouter upgrade", request.url);
+            const { pathname } = new URL(request.url || "", "http://localhost");
+            let matched = false;
+            for (const server of this.servers) {
+                if (server.shouldUpgrade(pathname)) {
+                    // console.log("WebSocketRouter upgrade matched", pathname);
+                    matched = true;
+                    server.upgrade(request, socket, head);
+                    break;
+                }
+            }
+            if (!matched) {
+                this.fastify.log.debug({
+                    msg: "Destroying socket connection as no server was matched",
+                    pathname,
+                });
+                socket.destroy();
+            }
+        });
+    }
+    /**
+     * Register a new {@link WebSocketServer}. New connection will now
+     * check if the given server will accept them and forward them.
+     *
+     * @param server WebSocket server to register.
+     * @returns The same instance of the WebSocket server after it's been registered.
+     */
+    registerServer(server) {
+        this.servers.push(server);
+        return server;
+    }
+}
+exports.WebSocketRouter = WebSocketRouter;

package/dist/modules/dev/dev-server/plugins/wss/web-socket-server-adapter.d.ts

@@ -0,0 +1,13 @@
+import type { IncomingMessage } from "node:http";
+import type { Socket } from "node:net";
+import type { FastifyInstance } from "fastify";
+import type { WebSocketServer } from "ws";
+import type { WebSocketServerInterface } from "./types";
+export declare class WebSocketServerAdapter implements WebSocketServerInterface {
+    private fastify;
+    private path;
+    private server?;
+    constructor(fastify: FastifyInstance, path: string, server?: WebSocketServer | undefined);
+    shouldUpgrade(pathname: string): boolean;
+    upgrade(request: IncomingMessage, socket: Socket, head: Buffer): void;
+}

package/dist/modules/dev/dev-server/plugins/wss/web-socket-server-adapter.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketServerAdapter = void 0;
+class WebSocketServerAdapter {
+    fastify;
+    path;
+    server;
+    constructor(fastify, path, server) {
+        this.fastify = fastify;
+        this.path = path;
+        this.server = server;
+    }
+    shouldUpgrade(pathname) {
+        if (!this.server) {
+            this.fastify.log.warn({ msg: `No handler active for ${this.path}` });
+            return false;
+        }
+        return this.path === pathname;
+    }
+    upgrade(request, socket, head) {
+        this.server?.handleUpgrade(request, socket, head, (webSocket) => {
+            this.server?.emit("connection", webSocket, request);
+        });
+    }
+}
+exports.WebSocketServerAdapter = WebSocketServerAdapter;

package/dist/modules/dev/dev-server/plugins/wss/web-socket-server.d.ts

@@ -0,0 +1,39 @@
+import type { IncomingMessage } from "node:http";
+import type { Socket } from "node:net";
+import type { FastifyInstance } from "fastify";
+import { type ServerOptions, type WebSocket, WebSocketServer as WebSocketServerImpl } from "ws";
+import type { WebSocketServerInterface } from "./types";
+/**
+/**
+ * Abstract class for providing common logic (eg routing) for all WebSocket servers.
+ *
+ * @category Development server
+ */
+export declare abstract class WebSocketServer implements WebSocketServerInterface {
+    /** An instance of the underlying WebSocket server. */
+    protected server: WebSocketServerImpl;
+    /** Fastify instance from which {@link server} will receive upgrade connections. */
+    protected fastify: FastifyInstance;
+    protected paths: string[];
+    /**
+     * Create a new instance of the WebSocketServer.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to which the WebSocket will be attached to.
+     * @param path Path on which this WebSocketServer will be accepting connections.
+     * @param wssOptions WebSocket Server options.
+     */
+    constructor(fastify: FastifyInstance, path: string | string[], wssOptions?: Omit<ServerOptions, "noServer" | "server" | "host" | "port" | "path">);
+    shouldUpgrade(pathname: string): boolean;
+    upgrade(request: IncomingMessage, socket: Socket, head: Buffer): void;
+    /**
+     * Process incoming WebSocket connection.
+     *
+     * @param socket Incoming WebSocket connection.
+     * @param request Upgrade request for the connection.
+     */
+    abstract onConnection(socket: WebSocket, request: IncomingMessage): void;
+    onError(error: Error): void;
+    onMessage(message: string): void;
+    onClose(socket: WebSocket): void;
+}

package/dist/modules/dev/dev-server/plugins/wss/web-socket-server.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketServer = void 0;
+const ws_1 = require("ws");
+/**
+/**
+ * Abstract class for providing common logic (eg routing) for all WebSocket servers.
+ *
+ * @category Development server
+ */
+class WebSocketServer {
+    /** An instance of the underlying WebSocket server. */
+    server;
+    /** Fastify instance from which {@link server} will receive upgrade connections. */
+    fastify;
+    paths;
+    /**
+     * Create a new instance of the WebSocketServer.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to which the WebSocket will be attached to.
+     * @param path Path on which this WebSocketServer will be accepting connections.
+     * @param wssOptions WebSocket Server options.
+     */
+    constructor(fastify, path, wssOptions = {}) {
+        this.fastify = fastify;
+        this.server = new ws_1.WebSocketServer({ noServer: true, ...wssOptions });
+        this.server.on("connection", this.onConnection.bind(this));
+        this.server.on("error", this.onError.bind(this));
+        this.server.on("message", this.onMessage.bind(this));
+        this.server.on("close", this.onClose.bind(this));
+        this.paths = Array.isArray(path) ? path : [path];
+    }
+    shouldUpgrade(pathname) {
+        return this.paths.includes(pathname);
+    }
+    upgrade(request, socket, head) {
+        this.server.handleUpgrade(request, socket, head, (webSocket) => {
+            this.server.emit("connection", webSocket, request);
+        });
+    }
+    onError(error) { }
+    onMessage(message) { }
+    onClose(socket) { }
+}
+exports.WebSocketServer = WebSocketServer;

package/dist/modules/dev/dev-server/plugins/wss/wss.plugin.d.ts

@@ -0,0 +1,46 @@
+import type { ConfigT } from "metro-config";
+import type MetroServer from "metro/src/Server";
+import type { WebSocketServer } from "ws";
+import { WebSocketApiServer } from "./servers/web-socket-api.server";
+import { WebSocketDebuggerServer } from "./servers/web-socket-debugger.server";
+import { WebSocketDevClientServer } from "./servers/web-socket-dev-client.server";
+import type { WebSocketEventsServer } from "./servers/web-socket-events.server";
+import { WebSocketHMRServer } from "./servers/web-socket-hmr.server";
+import type { WebSocketMessageServer } from "./servers/web-socket-message.server";
+import { WebSocketRouter } from "./web-socket-router";
+import { WebSocketServerAdapter } from "./web-socket-server-adapter";
+declare module "fastify" {
+    interface FastifyInstance {
+        wss: {
+            debuggerServer: WebSocketDebuggerServer;
+            devClientServer: WebSocketDevClientServer;
+            messageServer: WebSocketMessageServer;
+            eventsServer: WebSocketEventsServer;
+            apiServer: WebSocketApiServer;
+            hmrServer: WebSocketHMRServer;
+            deviceConnectionServer: WebSocketServerAdapter;
+            debuggerConnectionServer: WebSocketServerAdapter;
+            router: WebSocketRouter;
+        };
+    }
+}
+/**
+ * Defined in @react-native/dev-middleware
+ * Reference: https://github.com/facebook/react-native/blob/main/packages/dev-middleware/src/inspector-proxy/InspectorProxy.js
+ */
+declare const WS_DEVICE_URL = "/inspector/device";
+declare const WS_DEBUGGER_URL = "/inspector/debug";
+declare const WS_NETWORK_URL = "/inspector/network";
+export declare const wssPlugin: import("fastify").FastifyPluginCallback<{
+    metroConfig: ConfigT;
+    metroServer: MetroServer;
+    onClientConnected: (platform: string, clientId: string) => void;
+    messageServer: WebSocketMessageServer;
+    eventsServer: WebSocketEventsServer;
+    endpoints: {
+        [WS_DEVICE_URL]: WebSocketServer;
+        [WS_DEBUGGER_URL]: WebSocketServer;
+        [WS_NETWORK_URL]: WebSocketServer;
+    };
+}, import("fastify").RawServerDefault, import("fastify").FastifyTypeProviderDefault, import("fastify").FastifyBaseLogger>;
+export {};

package/dist/modules/dev/dev-server/plugins/wss/wss.plugin.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wssPlugin = void 0;
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const web_socket_api_server_1 = require("./servers/web-socket-api.server");
+const web_socket_debugger_server_1 = require("./servers/web-socket-debugger.server");
+const web_socket_dev_client_server_1 = require("./servers/web-socket-dev-client.server");
+const web_socket_hmr_server_1 = require("./servers/web-socket-hmr.server");
+const web_socket_router_1 = require("./web-socket-router");
+const web_socket_server_adapter_1 = require("./web-socket-server-adapter");
+/**
+ * Defined in @react-native/dev-middleware
+ * Reference: https://github.com/facebook/react-native/blob/main/packages/dev-middleware/src/inspector-proxy/InspectorProxy.js
+ */
+const WS_DEVICE_URL = "/inspector/device";
+const WS_DEBUGGER_URL = "/inspector/debug";
+const WS_NETWORK_URL = "/inspector/network";
+exports.wssPlugin = (0, fastify_plugin_1.default)(async (instance, { metroConfig, metroServer, onClientConnected, endpoints, messageServer, eventsServer, }) => {
+    const router = new web_socket_router_1.WebSocketRouter(instance);
+    const debuggerServer = new web_socket_debugger_server_1.WebSocketDebuggerServer(instance);
+    const devClientServer = new web_socket_dev_client_server_1.WebSocketDevClientServer(instance);
+    const apiServer = new web_socket_api_server_1.WebSocketApiServer(instance);
+    const hmrServer = new web_socket_hmr_server_1.WebSocketHMRServer(instance, {
+        metroConfig,
+        metroServer,
+        onClientConnected,
+    });
+    // @react-native/dev-middleware servers
+    const deviceConnectionServer = new web_socket_server_adapter_1.WebSocketServerAdapter(instance, WS_DEVICE_URL, endpoints[WS_DEVICE_URL]);
+    const debuggerConnectionServer = new web_socket_server_adapter_1.WebSocketServerAdapter(instance, WS_DEBUGGER_URL, endpoints[WS_DEBUGGER_URL]);
+    const networkConnectionServer = new web_socket_server_adapter_1.WebSocketServerAdapter(instance, WS_NETWORK_URL, endpoints[WS_NETWORK_URL]);
+    router.registerServer(debuggerServer);
+    router.registerServer(devClientServer);
+    router.registerServer(messageServer);
+    router.registerServer(eventsServer);
+    router.registerServer(apiServer);
+    router.registerServer(hmrServer);
+    router.registerServer(deviceConnectionServer);
+    router.registerServer(debuggerConnectionServer);
+    router.registerServer(networkConnectionServer);
+    instance.decorate("wss", {
+        debuggerServer,
+        devClientServer,
+        messageServer,
+        eventsServer,
+        apiServer,
+        hmrServer,
+        deviceConnectionServer,
+        debuggerConnectionServer,
+        router,
+    });
+}, {
+    name: "wss-plugin",
+});

package/dist/modules/dev/dev-server/types.d.ts

@@ -0,0 +1,27 @@
+export type { SymbolicatorDelegate, ReactNativeStackFrame, InputStackFrame, StackFrame, CodeFrame, SymbolicatorResults, } from './plugins/symbolicate';
+/** Representation of the compilation progress. */
+export interface ProgressData {
+    /** Number of modules built. */
+    completed: number;
+    /** Total number of modules detect as part of compilation. */
+    total: number;
+}
+/**
+ * Type representing a function to send the progress.
+ *
+ * Used by {@link CompilerDelegate} in `getAsset` function to send the compilation
+ * progress to the client who requested the asset.
+ */
+export type SendProgress = (data: ProgressData) => void;
+/**
+ * Internal types. Do not use.
+ *
+ * @internal
+ */
+export declare namespace Internal {
+    enum EventTypes {
+        BuildStart = "BuildStart",
+        BuildEnd = "BuildEnd",
+        HmrEvent = "HmrEvent"
+    }
+}

package/dist/modules/dev/dev-server/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Internal = void 0;
+/**
+ * Internal types. Do not use.
+ *
+ * @internal
+ */
+var Internal;
+(function (Internal) {
+    let EventTypes;
+    (function (EventTypes) {
+        EventTypes["BuildStart"] = "BuildStart";
+        EventTypes["BuildEnd"] = "BuildEnd";
+        EventTypes["HmrEvent"] = "HmrEvent";
+    })(EventTypes = Internal.EventTypes || (Internal.EventTypes = {}));
+})(Internal || (exports.Internal = Internal = {}));

package/dist/modules/dev/terminal/base.terminal.reporter.d.ts

@@ -0,0 +1,25 @@
+import { TerminalReporter as MetroTerminalReporter } from "metro";
+import type { TerminalReportableEvent } from "metro/src/lib/TerminalReporter";
+export declare class BaseTerminalReporter extends MetroTerminalReporter {
+    update(event: TerminalReportableEvent): void;
+    _getElapsedTime(startTime: bigint): bigint;
+    _log(event: TerminalReportableEvent): void;
+    _logInitializing(port: number, hasReducedPerformance: boolean): void;
+    _logInitializingFailed(port: number, error: Error): void;
+    _logBundleBuildDone(buildID: string): void;
+    _logBundleBuildFailed(buildID: string): void;
+    _logBundlingError(error: Error): void;
+    _logWorkerChunk(origin: string, chunk: string): void;
+    _logHmrClientError(error: Error): void;
+    _logWarning(message: string): void;
+    _logWatcherHealthCheckResult(result: any): void;
+    _logWatcherStatus(status: any): void;
+    _getBundleStatusMessage(progress: any, phase: "done" | "failed" | "in_progress"): string;
+    _updateBundleProgress(data: {
+        buildID: string;
+        transformedFileCount: number;
+        totalFileCount: number;
+    }): void;
+    _updateState(event: TerminalReportableEvent): void;
+    _getStatusMessage(): string;
+}

package/dist/modules/dev/terminal/base.terminal.reporter.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTerminalReporter = void 0;
+const metro_1 = require("metro");
+class BaseTerminalReporter extends metro_1.TerminalReporter {
+    // constructor(terminal: Terminal) {
+    // 	super(terminal);
+    // }
+    update(event) {
+        // @ts-ignore
+        super.update(event);
+    }
+    _getElapsedTime(startTime) {
+        // @ts-ignore
+        return super._getElapsedTime(startTime);
+    }
+    _log(event) {
+        // @ts-ignore
+        super._log(event);
+    }
+    _logInitializing(port, hasReducedPerformance) {
+        // @ts-ignore
+        super._logInitializing(port, hasReducedPerformance);
+    }
+    _logInitializingFailed(port, error) {
+        // @ts-ignore
+        super._logInitializingFailed(port, error);
+    }
+    _logBundleBuildDone(buildID) {
+        // @ts-ignore
+        super._logBundleBuildDone(buildID);
+    }
+    _logBundleBuildFailed(buildID) {
+        // @ts-ignore
+        super._logBundleBuildFailed(buildID);
+    }
+    _logBundlingError(error) {
+        // @ts-ignore
+        super._logBundlingError(error);
+    }
+    _logWorkerChunk(origin, chunk) {
+        // @ts-ignore
+        super._logWorkerChunk(origin, chunk);
+    }
+    _logHmrClientError(error) {
+        // @ts-ignore
+        super._logHmrClientError(error);
+    }
+    _logWarning(message) {
+        // @ts-ignore
+        super._logWarning(message);
+    }
+    _logWatcherHealthCheckResult(result) {
+        // @ts-ignore
+        super._logWatcherHealthCheckResult(result);
+    }
+    _logWatcherStatus(status) {
+        // @ts-ignore
+        super._logWatcherStatus(status);
+    }
+    _getBundleStatusMessage(progress, phase) {
+        // @ts-ignore
+        return super._getBundleStatusMessage(progress, phase);
+    }
+    _updateBundleProgress(data) {
+        // @ts-ignore
+        super._updateBundleProgress(data);
+    }
+    _updateState(event) {
+        // @ts-ignore
+        super._updateState(event);
+    }
+    _getStatusMessage() {
+        // @ts-ignore
+        return super._getStatusMessage();
+    }
+}
+exports.BaseTerminalReporter = BaseTerminalReporter;

package/dist/modules/dev/terminal/terminal.reporter.d.ts

@@ -0,0 +1,12 @@
+import type { TerminalReportableEvent } from "metro/src/lib/TerminalReporter";
+import type { DevServer } from "../dev-server/dev-server";
+import { BaseTerminalReporter } from "./base.terminal.reporter";
+export declare class TeardownTerminalReporter extends BaseTerminalReporter {
+    readonly devServer: DevServer;
+    constructor(devServer: DevServer);
+    _log(event: TerminalReportableEvent): void;
+    _logInitializing(port: number, hasReducedPerformance: boolean): void;
+    dependencyGraphLoading(hasReducedPerformance: boolean): void;
+    _logWorkerChunk(origin: "stdout" | "stderr", chunk: string): void;
+    update(event: TerminalReportableEvent): void;
+}

package/dist/modules/dev/terminal/terminal.reporter.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeardownTerminalReporter = void 0;
+const node_util_1 = __importDefault(require("node:util"));
+const metro_core_1 = require("metro-core");
+// @ts-ignore
+const chalk_1 = __importDefault(require("chalk"));
+const base_terminal_reporter_1 = require("./base.terminal.reporter");
+class LogRespectingTerminal extends metro_core_1.Terminal {
+    constructor(stream) {
+        super(stream);
+        const sendLog = (...args) => {
+            // @ts-expect-error
+            this._logLines.push(
+            // format args like console.log
+            node_util_1.default.format(...args));
+            // @ts-expect-error
+            this._scheduleUpdate();
+            // Flush the logs to the terminal immediately so logs at the end of the process are not lost.
+            this.flush();
+        };
+        console.log = sendLog;
+        console.info = sendLog;
+    }
+}
+const terminal = new LogRespectingTerminal(process.stdout);
+class TeardownTerminalReporter extends base_terminal_reporter_1.BaseTerminalReporter {
+    devServer;
+    constructor(devServer) {
+        super(terminal);
+        this.devServer = devServer;
+    }
+    _log(event) {
+        switch (event.type) {
+            // Handle specific cases if needed
+            case "dep_graph_loading":
+                this.dependencyGraphLoading(event.hasReducedPerformance);
+                return;
+        }
+        super._log(event);
+    }
+    _logInitializing(port, hasReducedPerformance) {
+        this.terminal.log(chalk_1.default.dim("Starting Bundler on port"), chalk_1.default.dim(`${port}`));
+    }
+    dependencyGraphLoading(hasReducedPerformance) {
+        this.terminal.log(chalk_1.default.dim("Loading dependency graph"), chalk_1.default.dim(`${hasReducedPerformance ? "with reduced performance" : ""}`));
+    }
+    _logWorkerChunk(origin, chunk) {
+        const lines = chunk.split("\n");
+        if (lines.length >= 1 && lines[lines.length - 1] === "") {
+            lines.splice(lines.length - 1, 1);
+        }
+        const originTag = origin === "stdout" ? chalk_1.default.dim("|") : chalk_1.default.yellow("|");
+        lines.forEach((line) => {
+            this.terminal.log(originTag, line);
+        });
+    }
+    update(event) {
+        super.update(event);
+        this.devServer?.reportMetroEvent(event);
+        switch (event.type) {
+            case "initialize_done":
+                this.devServer.onInitializeDone?.();
+                break;
+        }
+    }
+}
+exports.TeardownTerminalReporter = TeardownTerminalReporter;

package/dist/modules/dev/types.d.ts

@@ -0,0 +1,20 @@
+import type { CustomMessageHandlerConnection } from '@react-native/dev-middleware';
+export type Connection = CustomMessageHandlerConnection;
+export type DeviceMetadata = Connection['device'];
+export type DebuggerMetadata = Connection['debugger'];
+export type Page = Connection['page'];
+export type TargetCapabilityFlags = Page['capabilities'];
+/**
+ * The outline of a basic Chrome DevTools Protocol request, either from device or debugger.
+ * Both the request and response parameters could be optional, use `never` to enforce these fields.
+ */
+export type CdpMessage<Method extends string = string, Request extends object = object, Response extends object = object> = {
+    id: number;
+    method: Method;
+    params: Request;
+    result: Response;
+};
+export type DeviceRequest<M extends CdpMessage = CdpMessage> = Pick<M, 'method' | 'params'>;
+export type DeviceResponse<M extends CdpMessage = CdpMessage> = Pick<M, 'id' | 'result'>;
+export type DebuggerRequest<M extends CdpMessage = CdpMessage> = Pick<M, 'id' | 'method' | 'params'>;
+export type DebuggerResponse<M extends CdpMessage = CdpMessage> = Pick<M, 'result'>;

package/dist/modules/dev/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/dev/utils/log.d.ts

@@ -0,0 +1,23 @@
+export declare function time(label?: string): void;
+export declare function timeEnd(label?: string): void;
+export declare function error(...message: string[]): void;
+/** Print an error and provide additional info (the stack trace) in debug mode. */
+export declare function exception(e: Error): void;
+export declare function warn(...message: string[]): void;
+export declare function log(...message: string[]): void;
+export declare function debug(...message: any[]): void;
+/** Clear the terminal of all text. */
+export declare function clear(): void;
+/** Log a message and exit the current process. If the `code` is non-zero then `console.error` will be used instead of `console.log`. */
+export declare function exit(message: string | Error, code?: number): never;
+export declare const Log: {
+    time: typeof time;
+    timeEnd: typeof timeEnd;
+    error: typeof error;
+    exception: typeof exception;
+    warn: typeof warn;
+    log: typeof log;
+    debug: typeof debug;
+    clear: typeof clear;
+    exit: typeof exit;
+};

package/dist/modules/dev/utils/log.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+exports.time = time;
+exports.timeEnd = timeEnd;
+exports.error = error;
+exports.exception = exception;
+exports.warn = warn;
+exports.log = log;
+exports.debug = debug;
+exports.clear = clear;
+exports.exit = exit;
+// @ts-ignore
+const chalk_1 = __importDefault(require("chalk"));
+function time(label) {
+    console.time(label);
+}
+function timeEnd(label) {
+    console.timeEnd(label);
+}
+function error(...message) {
+    console.error(...message);
+}
+/** Print an error and provide additional info (the stack trace) in debug mode. */
+function exception(e) {
+    const { env } = require('./utils/env');
+    error(chalk_1.default.red(e.toString()) + (env.EXPO_DEBUG ? `\n${chalk_1.default.gray(e.stack)}` : ''));
+}
+function warn(...message) {
+    console.warn(...message.map((value) => chalk_1.default.yellow(value)));
+}
+function log(...message) {
+    console.log(...message);
+}
+function debug(...message) {
+    const debug = require('debug')('teardown');
+    debug(...message);
+}
+/** Clear the terminal of all text. */
+function clear() {
+    process.stdout.write(process.platform === 'win32' ? '\x1B[2J\x1B[0f' : '\x1B[2J\x1B[3J\x1B[H');
+}
+/** Log a message and exit the current process. If the `code` is non-zero then `console.error` will be used instead of `console.log`. */
+function exit(message, code = 1) {
+    if (message instanceof Error) {
+        exception(message);
+        process.exit(code);
+    }
+    if (message) {
+        if (code === 0) {
+            log(message);
+        }
+        else {
+            error(message);
+        }
+    }
+    process.exit(code);
+}
+// The re-export makes auto importing easier.
+exports.Log = {
+    time,
+    timeEnd,
+    error,
+    exception,
+    warn,
+    log,
+    debug,
+    clear,
+    exit,
+};