@granite-js/mpack 0.0.1

package/dist/metro/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/operations/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEBUGGER_FRONTEND_PATH = "debugger-frontend";
+export declare const DEBUGGER_TEMP_DIR = "granite-debugger";
+export declare const REACT_NATIVE_INSPECTOR_PAGE = "rn_inspector.html";

package/dist/operations/constants.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  DEBUGGER_FRONTEND_PATH: () => DEBUGGER_FRONTEND_PATH,
+  DEBUGGER_TEMP_DIR: () => DEBUGGER_TEMP_DIR,
+  REACT_NATIVE_INSPECTOR_PAGE: () => REACT_NATIVE_INSPECTOR_PAGE
+});
+module.exports = __toCommonJS(constants_exports);
+const DEBUGGER_FRONTEND_PATH = "debugger-frontend";
+const DEBUGGER_TEMP_DIR = "granite-debugger";
+const REACT_NATIVE_INSPECTOR_PAGE = "rn_inspector.html";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEBUGGER_FRONTEND_PATH,
+  DEBUGGER_TEMP_DIR,
+  REACT_NATIVE_INSPECTOR_PAGE
+});

package/dist/operations/createDebuggerMiddleware.d.ts

@@ -0,0 +1,11 @@
+import connect from 'connect';
+interface DebuggerMiddlewareConfig {
+    host?: string;
+    port: number;
+    broadcastMessage: (method: string, params?: Record<string, unknown>) => void;
+}
+export declare function createDebuggerMiddleware({ host, port, broadcastMessage }: DebuggerMiddlewareConfig): {
+    middleware: connect.Server;
+    enableStdinWatchMode: () => void;
+};
+export {};

package/dist/operations/createDebuggerMiddleware.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createDebuggerMiddleware_exports = {};
+__export(createDebuggerMiddleware_exports, {
+  createDebuggerMiddleware: () => createDebuggerMiddleware
+});
+module.exports = __toCommonJS(createDebuggerMiddleware_exports);
+var import_path = __toESM(require("path"));
+var import_readline = __toESM(require("readline"));
+var import_devtools_frontend = __toESM(require("@granite-js/devtools-frontend"));
+var import_prompts = require("@inquirer/prompts");
+var import_chalk = __toESM(require("chalk"));
+var import_connect = __toESM(require("connect"));
+var import_debug = __toESM(require("debug"));
+var import_serve_static = __toESM(require("serve-static"));
+var import_constants = require("./constants");
+var import_openDebugger = require("./openDebugger");
+var import_vendors = require("../vendors");
+const debug = (0, import_debug.default)("cli:start");
+const { InspectorProxy } = (0, import_vendors.getModule)("metro-inspector-proxy");
+const chromeInstanceMap = /* @__PURE__ */ new Map();
+function createDebuggerMiddleware({ host, port, broadcastMessage }) {
+  const middleware = (0, import_connect.default)().use(`/${import_constants.DEBUGGER_FRONTEND_PATH}`, (0, import_serve_static.default)(import_path.default.resolve(import_devtools_frontend.default)));
+  function enableStdinWatchMode() {
+    if (!process.stdout.isTTY || process.stdin.setRawMode == null) {
+      console.warn("Watch mode is not supported in this environment");
+      return;
+    }
+    import_readline.default.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    console.log(`To reload the app press ${import_chalk.default.blue('"r"')}`);
+    console.log(`To open developer menu press ${import_chalk.default.blue('"d"')}`);
+    console.log(`To open debugger press ${import_chalk.default.blue('"j"')}`);
+    console.log("");
+    process.stdin.on("keypress", (_key, data) => {
+      if (data.ctrl === true) {
+        switch (data.name) {
+          case "c":
+            process.exit(0);
+          // eslint-disable-next-line no-fallthrough
+          case "z":
+            process.emit("SIGTSTP", "SIGTSTP");
+            break;
+        }
+        return;
+      }
+      switch (data.name) {
+        case "r":
+          console.info("Reloading app...");
+          broadcastMessage("reload");
+          break;
+        case "d":
+          console.info("Opening developer menu...");
+          broadcastMessage("devMenu");
+          break;
+        case "j":
+          openReactNativeDebugger(host, port);
+          break;
+      }
+    });
+  }
+  return { middleware, enableStdinWatchMode };
+}
+async function openReactNativeDebugger(host = "localhost", port) {
+  const connectedDevices = Array.from(InspectorProxy.devices.entries());
+  let targetDevice;
+  for (const [id, device] of connectedDevices) {
+    debug(`[${id}] ${device.getName()}`);
+  }
+  if (connectedDevices.length === 0) {
+    console.log("No compatible apps connected");
+    return;
+  } else if (connectedDevices.length === 1) {
+    const [id, device] = connectedDevices[0];
+    const name = device.getName();
+    targetDevice = { id, name };
+  } else {
+    const deviceInfo = await (0, import_prompts.select)({
+      message: "Select a device to connect",
+      choices: connectedDevices.map(([id, device]) => ({
+        value: { id, name: device.getName() },
+        name: device.getName()
+      }))
+    });
+    process.stdin.resume();
+    targetDevice = deviceInfo;
+  }
+  console.log(`Opening debugger for '${targetDevice.name}'...`);
+  chromeInstanceMap.get(targetDevice.id)?.kill();
+  (0, import_openDebugger.openDebugger)(host, port, targetDevice.id.toString()).then((chrome) => {
+    chromeInstanceMap.set(targetDevice.id, chrome);
+  }).catch((error) => {
+    if (error.message.includes("ECONNREFUSED")) {
+      return;
+    }
+    console.error(error);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDebuggerMiddleware
+});

package/dist/operations/experimental/StartMenuHandler.d.ts

@@ -0,0 +1,13 @@
+interface Menu {
+    key: string;
+    description: string;
+    action: () => void;
+}
+export declare class StartMenuHandler {
+    private menus;
+    constructor(menus: Menu[]);
+    attach(): this;
+    close(): void;
+    private keyPressHandler;
+}
+export {};

package/dist/operations/experimental/StartMenuHandler.js

@@ -0,0 +1,86 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var StartMenuHandler_exports = {};
+__export(StartMenuHandler_exports, {
+  StartMenuHandler: () => StartMenuHandler
+});
+module.exports = __toCommonJS(StartMenuHandler_exports);
+var import_readline = __toESM(require("readline"));
+var import_chalk = __toESM(require("chalk"));
+class StartMenuHandler {
+  constructor(menus) {
+    this.menus = menus;
+  }
+  attach() {
+    const isSupportInteractiveMode = process.stdout.isTTY && typeof process.stdin.setRawMode === "function";
+    if (isSupportInteractiveMode) {
+      import_readline.default.emitKeypressEvents(process.stdin);
+      process.stdin.setRawMode(true);
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("keypress", this.keyPressHandler.bind(this));
+      process.stdout.write("\n");
+      this.menus.forEach(({ key, description }) => {
+        console.log(`${import_chalk.default.bold(key)} - ${description}`);
+      });
+      process.stdout.write("\n");
+    }
+    return this;
+  }
+  close() {
+    process.stdin.off("keypress", this.keyPressHandler);
+  }
+  keyPressHandler(_data, { ctrl, name }) {
+    if (name === void 0) {
+      console.log("\uD55C/\uC601\uD0A4\uB97C \uD655\uC778\uD574\uC8FC\uC138\uC694");
+      return;
+    }
+    if (ctrl) {
+      switch (name) {
+        // Ctrl + C: SIGINT
+        case "c":
+          process.exit(0);
+          return;
+        // Ctrl + Z: SIGTSTP
+        case "z":
+          process.emit("SIGTSTP", "SIGTSTP");
+          return;
+      }
+      return;
+    }
+    this.menus.forEach(({ key, action }) => {
+      if (key === name) {
+        action();
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StartMenuHandler
+});

package/dist/operations/experimental/runServer.d.ts

@@ -0,0 +1,16 @@
+import type { DevServerPlugin } from '../../server/types';
+import type { DevServerConfig } from '../../types/DevServerConfig';
+interface RunServerArgs {
+    appName: string;
+    scheme: string;
+    devServerConfig: DevServerConfig;
+    host?: string;
+    port?: number;
+    preloadBundle?: string;
+    plugins?: DevServerPlugin[];
+    onServerReady?: () => Promise<void> | void;
+}
+export declare function experimental_runServer({ appName, scheme, devServerConfig, host, port, plugins, preloadBundle, onServerReady, }: RunServerArgs): Promise<{
+    cleanup: () => Promise<void>;
+}>;
+export {};

package/dist/operations/experimental/runServer.js

@@ -0,0 +1,137 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runServer_exports = {};
+__export(runServer_exports, {
+  experimental_runServer: () => experimental_runServer
+});
+module.exports = __toCommonJS(runServer_exports);
+var import_prompts = require("@inquirer/prompts");
+var import_debug = __toESM(require("debug"));
+var import_StartMenuHandler = require("./StartMenuHandler");
+var import_constants = require("../../constants");
+var import_DevServer = require("../../server/DevServer");
+var import_printLogo = require("../../utils/printLogo");
+var import_openDebugger = require("../openDebugger");
+const debug = (0, import_debug.default)("cli:start");
+const chromeInstanceMap = /* @__PURE__ */ new Map();
+async function experimental_runServer({
+  appName,
+  scheme,
+  devServerConfig,
+  host,
+  port = import_constants.DEV_SERVER_DEFAULT_PORT,
+  plugins,
+  preloadBundle,
+  onServerReady
+}) {
+  const rootDir = process.cwd();
+  const server = new import_DevServer.DevServer({
+    appName,
+    scheme,
+    build: devServerConfig.build,
+    presets: devServerConfig.presets,
+    host,
+    port,
+    preloadBundle,
+    plugins,
+    rootDir
+  });
+  (0, import_printLogo.printLogo)();
+  await server.initialize();
+  await server.listen();
+  await onServerReady?.();
+  const menuHandler = new import_StartMenuHandler.StartMenuHandler([
+    {
+      key: "r",
+      description: "\uC0C8\uB85C\uACE0\uCE68",
+      action: () => {
+        console.log("\uC0C8\uB85C\uACE0\uCE68 \uC911...");
+        server.broadcastCommand("reload");
+      }
+    },
+    {
+      key: "d",
+      description: "\uAC1C\uBC1C\uC790 \uBA54\uB274 \uC5F4\uAE30",
+      action: () => {
+        console.log("\uAC1C\uBC1C\uC790 \uBA54\uB274 \uC5EC\uB294 \uC911...");
+        server.broadcastCommand("devMenu");
+      }
+    },
+    {
+      key: "j",
+      description: "Debugger \uC5F4\uAE30",
+      action: async () => {
+        const devices = server.getInspectorProxy()?.getDevices();
+        const connectedDevices = Array.from(devices?.entries() ?? []);
+        let targetDevice;
+        for (const [id, device] of connectedDevices) {
+          debug(`[${id}] ${device.getName()}`);
+        }
+        if (connectedDevices.length === 0) {
+          console.log("No compatible apps connected");
+          return;
+        } else if (connectedDevices.length === 1) {
+          const [id, device] = connectedDevices[0];
+          const name = device.getName();
+          targetDevice = { id, name };
+        } else {
+          const deviceInfo = await (0, import_prompts.select)({
+            message: "Select a device to connect",
+            choices: connectedDevices.map(([id, device]) => ({
+              value: { id, name: device.getName() },
+              name: device.getName()
+            }))
+          });
+          process.stdin.resume();
+          targetDevice = deviceInfo;
+        }
+        console.log(`Opening debugger for '${targetDevice.name}'...`);
+        chromeInstanceMap.get(targetDevice.id)?.kill();
+        (0, import_openDebugger.openDebugger)(server.host, server.port, targetDevice.id).then((chrome) => {
+          chromeInstanceMap.set(targetDevice.id, chrome);
+        }).catch((error) => {
+          if (error.message.includes("ECONNREFUSED")) {
+            return;
+          }
+          console.error(error);
+        });
+      }
+    }
+  ]).attach();
+  return {
+    cleanup: async () => {
+      await server.close();
+      menuHandler.close();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  experimental_runServer
+});

package/dist/operations/index.d.ts

@@ -0,0 +1,3 @@
+export * from './runBundle';
+export * from './runServer';
+export * from './experimental/runServer';

package/dist/operations/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var operations_exports = {};
+module.exports = __toCommonJS(operations_exports);
+__reExport(operations_exports, require("./runBundle"), module.exports);
+__reExport(operations_exports, require("./runServer"), module.exports);
+__reExport(operations_exports, require("./experimental/runServer"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./runBundle"),
+  ...require("./runServer"),
+  ...require("./experimental/runServer")
+});

package/dist/operations/openDebugger.d.ts

@@ -0,0 +1 @@
+export declare function openDebugger(host: string | undefined, port: number, deviceId: string): Promise<import("chrome-launcher").LaunchedChrome>;

package/dist/operations/openDebugger.js

@@ -0,0 +1,73 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var openDebugger_exports = {};
+__export(openDebugger_exports, {
+  openDebugger: () => openDebugger
+});
+module.exports = __toCommonJS(openDebugger_exports);
+var fs = __toESM(require("fs/promises"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var import_chrome_launcher = require("chrome-launcher");
+var import_constants = require("./constants");
+async function openDebugger(host = "localhost", port, deviceId) {
+  const appUrl = getDevToolsFrontendUrl(host, port, deviceId);
+  const tempDir = await createTemporaryDirectory();
+  const chromePath = (0, import_chrome_launcher.getChromePath)();
+  if (!chromePath) {
+    throw new Error("unable to get Chrome browser path");
+  }
+  return (0, import_chrome_launcher.launch)({
+    chromePath,
+    chromeFlags: [
+      `--app=${appUrl}`,
+      `--user-data-dir=${tempDir}`,
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--window-size=1200,800"
+    ]
+  });
+}
+function getDevToolsFrontendUrl(host, port, deviceId) {
+  const wsUrl = `${host}:${port}/inspector/debug?device=${deviceId}&page=-1`;
+  const url = new URL(`http://${host}:${port}/${import_constants.DEBUGGER_FRONTEND_PATH}/${import_constants.REACT_NATIVE_INSPECTOR_PAGE}`);
+  url.searchParams.set("ws", wsUrl);
+  url.searchParams.set("unstable_enableNetworkPanel", "true");
+  url.searchParams.set("sources.hide_add_folder", "true");
+  return url.toString();
+}
+async function createTemporaryDirectory() {
+  const tempDir = path.join(os.tmpdir(), import_constants.DEBUGGER_TEMP_DIR);
+  await fs.mkdir(tempDir, { recursive: true });
+  return tempDir;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openDebugger
+});

package/dist/operations/runBundle.d.ts

@@ -0,0 +1,12 @@
+import { BundlerConfig, Config, PluginFactory } from '../types';
+interface RunBundleOptions {
+    rootDir: BundlerConfig['rootDir'];
+    dev: BundlerConfig['dev'];
+    cache: BundlerConfig['cache'];
+    metafile: BundlerConfig['metafile'];
+    plugins?: PluginFactory[];
+    tag?: string;
+    config?: Config;
+}
+export declare function runBundle(options: RunBundleOptions): Promise<import("..").BuildResult[]>;
+export {};

package/dist/operations/runBundle.js

@@ -0,0 +1,97 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runBundle_exports = {};
+__export(runBundle_exports, {
+  runBundle: () => runBundle
+});
+module.exports = __toCommonJS(runBundle_exports);
+var import_assert = __toESM(require("assert"));
+var fs = __toESM(require("fs/promises"));
+var path = __toESM(require("path"));
+var import_semaphore = require("@shopify/semaphore");
+var import_es_toolkit = require("es-toolkit");
+var import__ = require("..");
+var import_bundler = require("../bundler");
+var import_performance = require("../performance");
+var import_loadPresets = require("../utils/loadPresets");
+var import_writeBundle = require("../utils/writeBundle");
+async function runBundle(options) {
+  const config = options.config ?? await (0, import__.loadConfig)({ rootDir: options.rootDir });
+  (0, import_assert.default)(config, "\uAD6C\uC131 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+  config.tasks = await Promise.all(
+    config.tasks.map(
+      (task) => (0, import_loadPresets.loadPresets)(task, {
+        appName: config.appName,
+        scheme: config.scheme,
+        rootDir: options.rootDir,
+        dev: options.dev
+      })
+    )
+  );
+  const semaphore = new import_semaphore.Semaphore(config.concurrency ?? 4);
+  const buildResults = await Promise.all(
+    config.tasks.map(async ({ tag, build }) => {
+      if (typeof options.tag === "string" && tag !== options.tag) {
+        return;
+      }
+      const bundler = new import_bundler.Bundler({
+        tag,
+        buildConfig: build,
+        appName: config.appName,
+        scheme: config.scheme,
+        services: config.services,
+        dev: options.dev,
+        metafile: options.metafile,
+        rootDir: options.rootDir,
+        cache: options.cache
+      });
+      if (options.plugins) {
+        options.plugins.forEach((fn) => bundler.addPlugin(fn()));
+      }
+      const permit = await semaphore.acquire();
+      try {
+        const result = await bundler.build();
+        await (0, import_writeBundle.writeBundle)(result.outfile, result.bundle);
+        return result;
+      } finally {
+        await permit.release();
+      }
+    })
+  ).then((results) => results.filter(import_es_toolkit.isNotNil));
+  const performanceSummary = import_performance.Performance.getSummary();
+  if (performanceSummary != null) {
+    (0, import_performance.printSummary)(performanceSummary);
+    await fs.writeFile(path.join(options.rootDir, "perf.json"), JSON.stringify(performanceSummary, null, 2), "utf-8");
+  }
+  return buildResults;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runBundle
+});