@teardown/cli 1.2.20 → 1.2.22

package/bin/teardown.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+
+require("../dist/index.js");

package/dist/commands/dev/dev.d.ts

@@ -0,0 +1,22 @@
+import { Command } from "commander";
+export interface DevServerOptions {
+    projectRoot: string;
+    port: number;
+    host: string;
+    config: string;
+    entryFile: string;
+    resetCache: boolean;
+    watchFolders?: string[];
+    assetPlugins?: string[];
+    sourceExts?: string[];
+    maxWorkers?: number;
+    transformer?: string;
+    https?: boolean;
+    key?: string;
+    cert?: string;
+    interactive?: boolean;
+}
+export declare class DevServerCommand {
+    createCommand(): Command;
+    private action;
+}

package/dist/commands/dev/dev.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevServerCommand = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const commander_1 = require("commander");
+const dev_server_1 = require("../../modules/dev/dev-server/dev-server");
+class DevServerCommand {
+    createCommand() {
+        const command = new commander_1.Command("dev")
+            .description("Start the development server")
+            .option("-p, --port <number>", "Port to start the server on", "8081")
+            .option("-h, --host <string>", "Host to listen on", "127.0.0.1")
+            .option("--project-root <path>", "Path to project root", process.cwd())
+            .option("--watch-folders <list>", "Specify additional folders to watch", (val) => val.split(",").map((folder) => node_path_1.default.resolve(folder)))
+            .option("--asset-plugins <list>", "Specify additional asset plugins", (val) => val.split(","))
+            .option("--source-exts <list>", "Specify additional source extensions", (val) => val.split(","))
+            .option("--max-workers <number>", "Maximum number of workers for transformation", (val) => Number(val))
+            .option("--transformer <string>", "Specify a custom transformer")
+            .option("--entry-file <path>", "Path to entry file", "index.js")
+            .option("--reset-cache", "Reset the metro cache", false)
+            .option("--https", "Enable HTTPS connections")
+            .option("--key <path>", "Path to SSL key")
+            .option("--cert <path>", "Path to SSL certificate")
+            .option("--config <path>", "Path to config file", (val) => node_path_1.default.resolve(val))
+            .option("--no-interactive", "Disable interactive mode");
+        command.action(this.action);
+        return command;
+    }
+    async action(options) {
+        try {
+            const server = new dev_server_1.DevServer({
+                projectRoot: options.projectRoot,
+                host: options.host,
+                port: options.port,
+                logRequests: true,
+                https: options.https
+                    ? {
+                        key: options.key ?? "",
+                        cert: options.cert ?? "",
+                    }
+                    : undefined,
+            });
+            await server.initialize();
+            await server.start();
+        }
+        catch (error) {
+            console.error("Failed to start development server:", error);
+            throw error;
+        }
+    }
+}
+exports.DevServerCommand = DevServerCommand;

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

@@ -0,0 +1,64 @@
+/**
+ * Raw React Native stack frame.
+ */
+export interface ReactNativeStackFrame {
+    lineNumber: number | null;
+    column: number | null;
+    file: string | null;
+    methodName: string;
+}
+/**
+ * React Native stack frame used as input when processing by {@link Symbolicator}.
+ */
+export interface InputStackFrame extends ReactNativeStackFrame {
+    file: string;
+}
+/**
+ * Final symbolicated stack frame.
+ */
+export interface StackFrame extends InputStackFrame {
+    collapse: boolean;
+}
+/**
+ * Represents [@babel/core-frame](https://babeljs.io/docs/en/babel-code-frame).
+ */
+export interface CodeFrame {
+    content: string;
+    location: {
+        row: number;
+        column: number;
+    };
+    fileName: string;
+}
+/**
+ * Represents results of running {@link process} method on {@link Symbolicator} instance.
+ */
+export interface SymbolicatorResults {
+    codeFrame: CodeFrame | null;
+    stack: StackFrame[];
+}
+/**
+ * Delegate with implementation for symbolication functions.
+ */
+export interface SymbolicatorDelegate {
+    /**
+     * Get source code of file in the URL.
+     *
+     * @param fileUrl A full URL pointing to a file.
+     */
+    getSource: (fileUrl: string) => Promise<string | Buffer>;
+    /**
+     * Get source map for the file in the URL.
+     *
+     * @param fileUrl A full (usually `http:`) URL pointing to a compiled file.
+     * The URL points to a file for which to return source map, not to the source map file itself,
+     * e.g: `http://localhost:8081/index.bundle?platform=ios`.
+     */
+    getSourceMap: (fileUrl: string) => Promise<string | Buffer>;
+    /**
+     * Check if given stack frame should be included in the new symbolicated stack.
+     *
+     * @param frame Stack frame to check.
+     */
+    shouldIncludeFrame: (frame: StackFrame) => boolean;
+}

package/dist/commands/dev/types.js

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

package/dist/index.js

@@ -1,41 +1,20 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
+const dev_1 = require("./commands/dev/dev");
 const program = new commander_1.Command();
 program
     .name("Teardown CLI")
     .description("CLI to use the Teardown")
     .version("0.0.1");
-program
-    .command("init")
-    .description("Initialize Teardown in the current project")
-    .action(async () => {
-    const project = await Promise.resolve().then(() => __importStar(require("./init-teardown")));
-    await new project.InitTeardown({
-        projectName: "example ",
-    }).init();
-});
+// program
+// 	.command("init")
+// 	.description("Initialize Teardown in the current project")
+// 	.action(async () => {
+// 		const project = await import("./commands/init/init-teardown");
+// 		await new project.InitTeardown({
+// 			projectName: "example ",
+// 		}).init();
+// 	});
+program.addCommand(new dev_1.DevServerCommand().createCommand());
 program.parse();

package/dist/modules/dev/dev-menu/keyboard-handler.d.ts

@@ -0,0 +1,20 @@
+import type { DevServer } from "../dev-server/dev-server";
+export declare class KeyboardHandlerManager {
+    readonly devServer: DevServer;
+    private static readonly CTRL_C;
+    private static readonly CTRL_D;
+    private static readonly RELOAD_TIMEOUT;
+    private readonly openDebuggerKeyboardHandler;
+    private previousCallTimestamp;
+    constructor(devServer: DevServer);
+    initialize(): void;
+    private isTTYSupported;
+    private setupKeyboardHandlers;
+    private handleKeyPress;
+    private handleReload;
+    private handleDevMenu;
+    private handleOpenDebugger;
+    private handleExit;
+    private setRawMode;
+    private printAvailableCommands;
+}

package/dist/modules/dev/dev-menu/keyboard-handler.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardHandlerManager = void 0;
+const node_readline_1 = __importDefault(require("node:readline"));
+const node_tty_1 = require("node:tty");
+// @ts-ignore
+const chalk_1 = __importDefault(require("chalk"));
+const open_debugger_keyboard_handler_1 = __importDefault(require("./open-debugger-keyboard-handler"));
+class KeyboardHandlerManager {
+    devServer;
+    static CTRL_C = "\u0003";
+    static CTRL_D = "\u0004";
+    static RELOAD_TIMEOUT = 500;
+    openDebuggerKeyboardHandler;
+    previousCallTimestamp = 0;
+    constructor(devServer) {
+        this.devServer = devServer;
+        this.openDebuggerKeyboardHandler = new open_debugger_keyboard_handler_1.default({
+            reporter: this.devServer.terminalReporter,
+            devServerUrl: this.devServer.getDevServerUrl(),
+        });
+    }
+    initialize() {
+        if (!this.isTTYSupported()) {
+            this.devServer.terminalReporter.update({
+                type: "client_log",
+                level: "info",
+                data: ["Interactive mode is not supported in this environment"],
+            });
+            return;
+        }
+        this.setupKeyboardHandlers();
+        this.printAvailableCommands();
+    }
+    isTTYSupported() {
+        return process.stdin.isTTY === true;
+    }
+    setupKeyboardHandlers() {
+        node_readline_1.default.emitKeypressEvents(process.stdin);
+        this.setRawMode(true);
+        process.stdin.on("keypress", (str, key) => {
+            this.handleKeyPress(key);
+        });
+    }
+    handleKeyPress(key) {
+        if (this.openDebuggerKeyboardHandler.maybeHandleTargetSelection(key.name)) {
+            return;
+        }
+        switch (key.sequence) {
+            case "r":
+                this.handleReload();
+                break;
+            case "d":
+                this.handleDevMenu();
+                break;
+            case "j":
+                void this.handleOpenDebugger();
+                break;
+            case KeyboardHandlerManager.CTRL_C:
+            case KeyboardHandlerManager.CTRL_D:
+                this.handleExit();
+                break;
+        }
+    }
+    handleReload() {
+        const currentCallTimestamp = new Date().getTime();
+        if (currentCallTimestamp - this.previousCallTimestamp >
+            KeyboardHandlerManager.RELOAD_TIMEOUT) {
+            this.previousCallTimestamp = currentCallTimestamp;
+            this.devServer.terminalReporter.update({
+                type: "client_log",
+                level: "info",
+                data: ["Reloading connected app(s)..."],
+            });
+            this.devServer.messageServer.broadcast("reload");
+        }
+    }
+    handleDevMenu() {
+        this.devServer.terminalReporter.update({
+            type: "client_log",
+            level: "info",
+            data: ["Opening Dev Menu..."],
+        });
+        this.devServer.messageServer.broadcast("devMenu");
+    }
+    async handleOpenDebugger() {
+        await this.openDebuggerKeyboardHandler.handleOpenDebugger();
+    }
+    handleExit() {
+        this.openDebuggerKeyboardHandler.dismiss();
+        this.devServer.terminalReporter.update({
+            type: "client_log",
+            level: "info",
+            data: ["Stopping server"],
+        });
+        this.setRawMode(false);
+        process.stdin.pause();
+        process.emit("SIGINT");
+        process.exit();
+    }
+    setRawMode(enable) {
+        invariant(process.stdin instanceof node_tty_1.ReadStream, "process.stdin must be a readable stream to modify raw mode");
+        process.stdin.setRawMode(enable);
+    }
+    printAvailableCommands() {
+        this.devServer.terminalReporter.update({
+            type: "client_log",
+            level: "info",
+            data: [
+                "Key commands available:",
+                `${chalk_1.default.bold.inverse(" r ")} - reload app(s)`,
+                `${chalk_1.default.bold.inverse(" d ")} - open Dev Menu`,
+                `${chalk_1.default.bold.inverse(" j ")} - open DevTools`,
+            ],
+        });
+    }
+}
+exports.KeyboardHandlerManager = KeyboardHandlerManager;
+const invariant = (condition, message) => {
+    if (!condition) {
+        throw new Error(message);
+    }
+};

package/dist/modules/dev/dev-menu/open-debugger-keyboard-handler.d.ts

@@ -0,0 +1,18 @@
+import type { TeardownTerminalReporter } from "../terminal/terminal.reporter";
+interface OpenDebuggerConfig {
+    reporter: TeardownTerminalReporter;
+    devServerUrl: string;
+}
+export default class OpenDebuggerKeyboardHandler {
+    private readonly reporter;
+    private readonly devServerUrl;
+    private isTargetSelectionActive;
+    private targets;
+    constructor(config: OpenDebuggerConfig);
+    handleOpenDebugger(): Promise<void>;
+    maybeHandleTargetSelection(key: string): boolean;
+    dismiss(): void;
+    private openTarget;
+    private showTargetSelection;
+}
+export {};

package/dist/modules/dev/dev-menu/open-debugger-keyboard-handler.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const chalk_1 = __importDefault(require("chalk"));
+const open_1 = __importDefault(require("open"));
+class OpenDebuggerKeyboardHandler {
+    reporter;
+    devServerUrl;
+    isTargetSelectionActive = false;
+    targets = [];
+    constructor(config) {
+        this.reporter = config.reporter;
+        this.devServerUrl = config.devServerUrl;
+    }
+    async handleOpenDebugger() {
+        try {
+            const response = await fetch(`${this.devServerUrl}/json`);
+            const pages = await response.json();
+            this.targets = pages.map((page) => ({
+                name: page.title,
+                url: page.devtoolsFrontendUrl,
+            }));
+            if (this.targets.length === 0) {
+                this.reporter.update({
+                    type: "client_log",
+                    level: "info",
+                    data: ["No available debugging targets"],
+                });
+                return;
+            }
+            if (this.targets.length === 1) {
+                await this.openTarget(this.targets[0]);
+                return;
+            }
+            this.showTargetSelection();
+        }
+        catch (error) {
+            this.reporter.update({
+                type: "client_log",
+                level: "warn",
+                data: [
+                    `Failed to open debugger: ${error instanceof Error ? error.message : String(error)}`,
+                ],
+            });
+        }
+    }
+    maybeHandleTargetSelection(key) {
+        if (!this.isTargetSelectionActive) {
+            return false;
+        }
+        const targetIndex = Number.parseInt(key, 10) - 1;
+        if (targetIndex >= 0 && targetIndex < this.targets.length) {
+            void this.openTarget(this.targets[targetIndex]);
+            this.dismiss();
+            return true;
+        }
+        if (key === "escape") {
+            this.dismiss();
+            return true;
+        }
+        return false;
+    }
+    dismiss() {
+        this.isTargetSelectionActive = false;
+        this.targets = [];
+    }
+    async openTarget(target) {
+        try {
+            console.log("openTarget", target.url);
+            await (0, open_1.default)(target.url);
+            this.reporter.update({
+                type: "client_log",
+                level: "info",
+                data: [`Opening debugger for: ${target.name}`],
+            });
+        }
+        catch (error) {
+            this.reporter.update({
+                type: "client_log",
+                // @ts-ignore
+                level: "error",
+                data: [
+                    `Failed to open debugger: ${error instanceof Error ? error.message : String(error)}`,
+                ],
+            });
+        }
+    }
+    showTargetSelection() {
+        this.isTargetSelectionActive = true;
+        const targetList = this.targets
+            .map((target, i) => `  ${chalk_1.default.bold.inverse(` ${i + 1} `)} ${target.name}`)
+            .join("\n");
+        this.reporter.update({
+            type: "client_log",
+            level: "info",
+            data: [
+                `Select a target to debug:\n${targetList}\n\n  ${chalk_1.default.bold.inverse(" ESC ")} to cancel\n`,
+            ],
+        });
+    }
+}
+exports.default = OpenDebuggerKeyboardHandler;

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

@@ -0,0 +1,22 @@
+export declare enum DevServerStatusResultEnum {
+    PACKAGER_STATUS_RUNNING = "packager-status:running"
+}
+export declare enum DevServerStatusEnum {
+    NOT_RUNNING = "not_running",
+    MATCHED_SERVER_RUNNING = "matched_server_running",
+    PORT_TAKEN = "port_taken",
+    UNKNOWN = "unknown"
+}
+export type DevServerOptions = {
+    host: string;
+    port: number;
+    projectRoot: string;
+    devServerStatusPath?: string;
+};
+export declare class DevServerChecker {
+    readonly options: DevServerOptions;
+    constructor(options: DevServerOptions);
+    private getUrl;
+    getServerStatus(): Promise<DevServerStatusEnum>;
+    private isPortInUse;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevServerChecker = exports.DevServerStatusEnum = exports.DevServerStatusResultEnum = void 0;
+const bun_1 = require("bun");
+const node_net_1 = __importDefault(require("node:net"));
+var DevServerStatusResultEnum;
+(function (DevServerStatusResultEnum) {
+    DevServerStatusResultEnum["PACKAGER_STATUS_RUNNING"] = "packager-status:running";
+})(DevServerStatusResultEnum || (exports.DevServerStatusResultEnum = DevServerStatusResultEnum = {}));
+var DevServerStatusEnum;
+(function (DevServerStatusEnum) {
+    DevServerStatusEnum["NOT_RUNNING"] = "not_running";
+    DevServerStatusEnum["MATCHED_SERVER_RUNNING"] = "matched_server_running";
+    DevServerStatusEnum["PORT_TAKEN"] = "port_taken";
+    DevServerStatusEnum["UNKNOWN"] = "unknown";
+})(DevServerStatusEnum || (exports.DevServerStatusEnum = DevServerStatusEnum = {}));
+class DevServerChecker {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    getUrl() {
+        const devServerStatusPath = this.options.devServerStatusPath ?? "/status";
+        return `${this.options.host}:${this.options.port}${devServerStatusPath}`;
+    }
+    async getServerStatus() {
+        try {
+            if (!(await this.isPortInUse(this.options.host, this.options.port))) {
+                return DevServerStatusEnum.NOT_RUNNING;
+            }
+            const statusResponse = await (0, bun_1.fetch)(this.getUrl());
+            const body = await statusResponse.text();
+            if (body !== DevServerStatusResultEnum.PACKAGER_STATUS_RUNNING) {
+                return DevServerStatusEnum.PORT_TAKEN;
+            }
+            const projectRoot = statusResponse.headers.get("X-React-Native-Project-Root");
+            if (projectRoot !== this.options.projectRoot) {
+                return DevServerStatusEnum.PORT_TAKEN;
+            }
+            return DevServerStatusEnum.MATCHED_SERVER_RUNNING;
+        }
+        catch (error) {
+            console.error(error);
+            return DevServerStatusEnum.UNKNOWN;
+        }
+    }
+    async isPortInUse(hostname, port) {
+        return new Promise((resolve) => {
+            const server = node_net_1.default.createServer();
+            server.once("error", (e) => {
+                console.log("Server error:", e);
+                server.close();
+                if (e.code === "EADDRINUSE") {
+                    resolve(true);
+                }
+                else {
+                    // For any other errors, assume port is not in use
+                    resolve(false);
+                }
+            });
+            server.once("listening", () => {
+                server.close();
+                resolve(false);
+            });
+            server.listen(port, hostname);
+        });
+    }
+}
+exports.DevServerChecker = DevServerChecker;

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

@@ -0,0 +1,68 @@
+import { type FastifyInstance } from "fastify";
+import type { TerminalReportableEvent } from "metro/src/lib/TerminalReporter";
+import { TeardownTerminalReporter } from "../terminal/terminal.reporter";
+import { WebSocketEventsServer } from "./plugins/wss/servers/web-socket-events.server";
+import { WebSocketMessageServer } from "./plugins/wss/servers/web-socket-message.server";
+import { KeyboardHandlerManager } from "../dev-menu/keyboard-handler";
+export type DevServerOptions = {
+    projectRoot: string;
+    host: string;
+    port: number;
+    logRequests: boolean;
+    https?: {
+        key: string;
+        cert: string;
+    };
+};
+export declare class DevServer {
+    readonly config: DevServerOptions;
+    terminalReporter: TeardownTerminalReporter;
+    private instance;
+    messageServer: WebSocketMessageServer;
+    eventsServer: WebSocketEventsServer;
+    keyboardHandler: KeyboardHandlerManager;
+    constructor(config: DevServerOptions);
+    getDevServerUrl(): string;
+    onInitializeDone(): void;
+    reportMetroEvent(event: TerminalReportableEvent): void;
+    private onBundleBuilt;
+    private onMessage;
+    private onClientConnected;
+    private loadMetroConfig;
+    private _metroConfig;
+    private getMetroConfig;
+    private registerPlugins;
+    private registerHooks;
+    private registerRoutes;
+    initialize(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getInstance(): FastifyInstance;
+}
+type Log = {
+    level: number;
+    time: number;
+    pid: number;
+    hostname: string;
+    msg: string;
+} & Record<string, any>;
+export interface Reporter {
+    process(log: LogEntry): void;
+    flush(): void;
+    stop(): void;
+}
+/** Log message type. */
+export type LogType = "debug" | "info" | "warn" | "error" | "success" | "progress";
+/**
+ * Represent log message with all necessary data.
+ *
+ * @internal
+ */
+export interface LogEntry {
+    timestamp: number;
+    type: LogType;
+    issuer: string;
+    message: Array<string | number | boolean | Object>;
+}
+export declare function makeLogEntryFromFastifyLog(data: Log): LogEntry;
+export {};