@granite-js/cli 0.0.1

package/dist/index.cjs

@@ -0,0 +1,695 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  commonResolver: () => commonResolver,
+  defineConfig: () => defineConfig,
+  getGlobalVariables: () => getGlobalVariables,
+  initialize: () => initialize,
+  loadConfig: () => loadConfig,
+  service: () => service
+});
+module.exports = __toCommonJS(index_exports);
+var import_clipanion4 = require("clipanion");
+var import_cosmiconfig2 = require("cosmiconfig");
+
+// src/commands/BuildCommand/BuildCommand.ts
+var import_clipanion = require("clipanion");
+
+// src/build.ts
+var import_mpack = require("@granite-js/mpack");
+var import_plugins = require("@granite-js/mpack/plugins");
+var import_plugin_core = require("@granite-js/plugin-core");
+async function build(config, {
+  tag,
+  cache
+}) {
+  const resolvedPlugins = await (0, import_plugin_core.resolvePlugins)(config.plugins);
+  const pluginContext = {
+    meta: /* @__PURE__ */ Object.create(null)
+  };
+  for (const preHandler of resolvedPlugins.build.preHandlers) {
+    await preHandler?.call(pluginContext, {
+      cwd: config.cwd,
+      entryFile: config.entryFile,
+      appName: config.appName,
+      outdir: config.outdir,
+      buildResults: []
+    });
+  }
+  const results = await (0, import_mpack.runBundle)({
+    tag,
+    rootDir: config.cwd,
+    dev: false,
+    cache,
+    metafile: true,
+    plugins: [import_plugins.statusPlugin],
+    config: config.mpack.build.config
+  });
+  for (const postHandler of resolvedPlugins.build.postHandlers) {
+    await postHandler?.call(pluginContext, {
+      cwd: config.cwd,
+      entryFile: config.entryFile,
+      appName: config.appName,
+      outdir: config.outdir,
+      buildResults: results
+    });
+  }
+}
+
+// src/config/loadConfig.ts
+var import_utils = require("@granite-js/utils");
+var import_cosmiconfig = require("cosmiconfig");
+var import_cosmiconfig_typescript_loader = require("cosmiconfig-typescript-loader");
+var MODULE_NAME = "granite";
+var loadConfig = async () => {
+  const explorer = (0, import_cosmiconfig.cosmiconfig)(MODULE_NAME, {
+    searchPlaces: [
+      `${MODULE_NAME}.config.ts`,
+      `${MODULE_NAME}.config.mts`,
+      `${MODULE_NAME}.config.js`,
+      `${MODULE_NAME}.config.cjs`
+    ],
+    loaders: {
+      ".ts": (0, import_cosmiconfig_typescript_loader.TypeScriptLoader)(),
+      ".mts": (0, import_cosmiconfig_typescript_loader.TypeScriptLoader)()
+    }
+  });
+  const result = await explorer.search((0, import_utils.getPackageRoot)());
+  const config = await result?.config;
+  return config;
+};
+
+// src/commands/BuildCommand/BuildCommand.ts
+var BuildCommand = class extends import_clipanion.Command {
+  static paths = [[`build`]];
+  static usage = import_clipanion.Command.Usage({
+    category: "Build",
+    description: "Granite App \uBC88\uB4E4\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4",
+    examples: [
+      ["\uBE4C\uB4DC\uD558\uAE30", "granite build"],
+      ["\uC9C0\uC815\uB41C \uB300\uC0C1\uB9CC \uBE4C\uB4DC\uD558\uAE30", "granite build --id service-ios"]
+    ]
+  });
+  tag = import_clipanion.Option.String("--tag", {
+    description: "\uAD6C\uC131 \uD30C\uC77C\uC5D0\uC11C \uC9C0\uC815\uD55C \uD0DC\uADF8\uC5D0 \uD574\uB2F9\uD558\uB294 \uB300\uC0C1\uB9CC \uBC88\uB4E4\uB9C1 \uD569\uB2C8\uB2E4"
+  });
+  disableCache = import_clipanion.Option.Boolean("--disable-cache", {
+    description: "\uCE90\uC2DC\uB97C \uBE44\uD65C\uC131\uD654 \uD569\uB2C8\uB2E4"
+  });
+  async execute() {
+    try {
+      const { tag, disableCache = false } = this;
+      const config = await loadConfig();
+      await build(config, {
+        tag,
+        cache: !disableCache
+      });
+      return 0;
+    } catch (error) {
+      console.error(error);
+      return 1;
+    }
+  }
+};
+
+// src/commands/HermesCommand/HermesCommand.ts
+var import_path2 = __toESM(require("path"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+var import_clipanion2 = require("clipanion");
+
+// src/utils/compileHbc.ts
+var import_assert = __toESM(require("assert"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_es_toolkit = require("es-toolkit");
+var import_execa = __toESM(require("execa"), 1);
+var binary = {
+  Darwin: "react-native/sdks/hermesc/osx-bin/hermesc",
+  Linux: "react-native/sdks/hermesc/linux64-bin/hermesc",
+  Windows_NT: "react-native/sdks/hermesc/win64-bin/hermesc.exe"
+};
+async function compileHbc({ rootDir, filePath, sourcemap }) {
+  const binary2 = getHermesc(rootDir);
+  const outfile = import_path.default.resolve(rootDir, filePath.replace(new RegExp(`${import_path.default.extname(filePath)}$`), ".hbc"));
+  await (0, import_execa.default)(
+    binary2,
+    [
+      // Disable warnings
+      "-w",
+      // Expensive optimizations
+      "-O",
+      // Emit binary
+      "-emit-binary",
+      // Emit source map
+      sourcemap ? "-output-source-map" : null,
+      // Output path
+      "-out",
+      outfile,
+      filePath
+    ].filter(import_es_toolkit.isNotNil)
+  );
+  return { outfile, sourcemapOutfile: sourcemap ? `${outfile}.map` : null };
+}
+function getHermesc(rootDir) {
+  const os2 = getOs();
+  const binarySource = binary[os2];
+  (0, import_assert.default)(binarySource, `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 OS \uC785\uB2C8\uB2E4: ${os2}`);
+  return resolveFromRoot(rootDir, binarySource);
+}
+function getOs() {
+  return import_os.default.type();
+}
+function resolveFromRoot(rootDir, request) {
+  return require.resolve(request, { paths: [rootDir] });
+}
+
+// src/commands/HermesCommand/HermesCommand.ts
+var HermesCommand = class extends import_clipanion2.Command {
+  static paths = [[`hermes`]];
+  static usage = import_clipanion2.Command.Usage({
+    category: "Hermes",
+    description: "\uC9C0\uC815\uD55C \uBC88\uB4E4\uC744 Hermes \uBC14\uC774\uD2B8 \uCF54\uB4DC\uB85C \uCEF4\uD30C\uC77C \uD569\uB2C8\uB2E4",
+    examples: [["\uCEF4\uD30C\uC77C\uD558\uAE30", "granite hermes --jsbundle dist/bundle.js"]]
+  });
+  jsBundleFile = import_clipanion2.Option.String("--jsbundle", {
+    required: true,
+    description: "Hermes \uBC14\uC774\uD2B8 \uCF54\uB4DC\uB85C \uCEF4\uD30C\uC77C \uD560 Javascript \uD30C\uC77C \uACBD\uB85C \uC785\uB2C8\uB2E4"
+  });
+  sourcemap = import_clipanion2.Option.Boolean("--sourcemap", true, {
+    description: "\uC18C\uC2A4\uB9F5 \uD30C\uC77C\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4"
+  });
+  async execute() {
+    try {
+      const rootDir = process.cwd();
+      const filePath = import_path2.default.resolve(rootDir, this.jsBundleFile);
+      const { outfile, sourcemapOutfile } = await compileHbc({ rootDir, filePath, sourcemap: this.sourcemap });
+      console.log(`\u2705 \uCEF4\uD30C\uC77C \uC644\uB8CC: ${import_chalk.default.gray(outfile)}`);
+      if (sourcemapOutfile) {
+        console.log(`\u2705 \uC18C\uC2A4\uB9F5 \uC0DD\uC131 \uC644\uB8CC: ${import_chalk.default.gray(sourcemapOutfile)}`);
+      }
+      return 0;
+    } catch (error) {
+      console.error(error.stack);
+      return 1;
+    }
+  }
+};
+
+// src/commands/DevCommand/DevCommand.ts
+var import_assert2 = __toESM(require("assert"), 1);
+var mpack = __toESM(require("@granite-js/mpack"), 1);
+var import_plugin_core2 = require("@granite-js/plugin-core");
+var import_clipanion3 = require("clipanion");
+var import_debug = __toESM(require("debug"), 1);
+
+// src/config/mergeTransformFromPlugins.ts
+async function mergeTransformFromPlugins(plugins) {
+  const mergedTransformFunctions = plugins.reduce(
+    (acc, plugin) => {
+      if (plugin.transformSync) {
+        acc.transformSync.push(plugin.transformSync);
+      }
+      if (plugin.transformAsync) {
+        acc.transformAsync.push(plugin.transformAsync);
+      }
+      return acc;
+    },
+    {
+      transformSync: [],
+      transformAsync: []
+    }
+  );
+  if (mergedTransformFunctions.transformSync.length === 0 && mergedTransformFunctions.transformAsync.length > 0) {
+    console.warn(
+      `Metro is only supported 'transformSync', but ${mergedTransformFunctions.transformAsync.length} 'transformAsync' are detected and it will be ignored.`
+    );
+  }
+  return {
+    transformSync: (id, code) => {
+      return mergedTransformFunctions.transformSync.reduce((acc, transform) => transform?.(id, acc) ?? acc, code);
+    },
+    transformAsync: async (id, code) => {
+      return mergedTransformFunctions.transformAsync.reduce(async (acc, transform) => {
+        return await transform?.(id, await acc) ?? acc;
+      }, Promise.resolve(code));
+    }
+  };
+}
+
+// src/commands/DevCommand/DevCommand.ts
+var debug = (0, import_debug.default)("cli");
+var DEFAULT_HOST = "0.0.0.0";
+var DEFAULT_LOCALHOST_PORT = 8081;
+var DevCommand = class extends import_clipanion3.Command {
+  static paths = [[`dev`]];
+  static usage = import_clipanion3.Command.Usage({
+    category: "Development",
+    description: "Granite \uAC1C\uBC1C \uC11C\uBC84\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4",
+    examples: [["\uAC1C\uBC1C \uC11C\uBC84 \uC2E4\uD589\uD558\uAE30", "granite dev"]]
+  });
+  host = import_clipanion3.Option.String("--host");
+  port = import_clipanion3.Option.String("--port");
+  disableEmbeddedReactDevTools = import_clipanion3.Option.Boolean("--disable-embedded-react-devtools", false);
+  // mpack dev-server
+  experimentalMode = import_clipanion3.Option.Boolean("--experimental-mode");
+  preloadBundle = import_clipanion3.Option.String("--preload-bundle", {
+    description: "Preload \uD560 \uBC88\uB4E4 \uD30C\uC77C\uC758 \uACBD\uB85C"
+  });
+  async execute() {
+    try {
+      const config = await loadConfig();
+      const serverOptions = {
+        host: this.host,
+        port: this.port ? parseInt(this.port, 10) : void 0
+      };
+      (0, import_assert2.default)(config?.appName, "\uC571 \uC774\uB984\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+      debug("StartCommand", {
+        ...serverOptions,
+        disableEmbeddedReactDevTools: this.disableEmbeddedReactDevTools,
+        experimentalMode: this.experimentalMode,
+        preloadBundle: this.preloadBundle
+      });
+      if (this.experimentalMode) {
+        const mpackConfig = config.mpack.devServer.config;
+        const mpackDevServerConfig = mpackConfig?.devServer;
+        (0, import_assert2.default)(mpackDevServerConfig, "mpack dev server \uC124\uC815\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+        await mpack.experimental_runServer({
+          appName: config.appName,
+          scheme: config.scheme,
+          devServerConfig: mpackDevServerConfig,
+          host: serverOptions.host,
+          port: serverOptions.port,
+          preloadBundle: this.preloadBundle
+        });
+      } else {
+        const resolvedPlugins = await (0, import_plugin_core2.resolvePlugins)(config.plugins);
+        const mergedTransform = await mergeTransformFromPlugins(resolvedPlugins.plugins);
+        const additionalMetroConfig = {
+          ...config.metro,
+          transformSync: mergedTransform?.transformSync
+        };
+        for (const preHandler of resolvedPlugins.devServer.preHandlers) {
+          debug("preHandler", preHandler);
+          await preHandler?.({
+            host: serverOptions.host || DEFAULT_HOST,
+            port: serverOptions.port || DEFAULT_LOCALHOST_PORT,
+            appName: config.appName,
+            outdir: config.outdir,
+            cwd: config.cwd,
+            entryFile: config.entryFile
+          });
+        }
+        await mpack.runServer({
+          cwd: config.cwd,
+          host: serverOptions.host,
+          port: serverOptions.port,
+          middlewares: config.mpack.devServer.middlewares,
+          config: config.mpack.devServer.config,
+          onServerReady: async () => {
+            for (const postHandler of resolvedPlugins.devServer.postHandlers) {
+              debug("postHandler", postHandler);
+              await postHandler?.({
+                host: serverOptions.host || DEFAULT_HOST,
+                port: serverOptions.port || DEFAULT_LOCALHOST_PORT,
+                appName: config.appName,
+                outdir: config.outdir,
+                cwd: config.cwd,
+                entryFile: config.entryFile
+              });
+            }
+          },
+          enableEmbeddedReactDevTools: !this.disableEmbeddedReactDevTools,
+          additionalConfig: additionalMetroConfig
+        });
+      }
+    } catch (error) {
+      console.log(`ERROR OCCURRED`);
+      console.log(error);
+      console.log(error.message);
+      console.error(error.stack);
+      process.exit(1);
+    }
+  }
+};
+
+// src/config/defineConfig.ts
+var import_path4 = __toESM(require("path"), 1);
+var import_mpack2 = require("@granite-js/mpack");
+var import_plugin_core4 = require("@granite-js/plugin-core");
+var import_utils2 = require("@granite-js/utils");
+var import_es_toolkit4 = require("es-toolkit");
+var import_zod = require("zod");
+
+// src/config/mergeConfigFromPlugins.ts
+var import_plugin_core3 = require("@granite-js/plugin-core");
+var import_es_toolkit2 = require("es-toolkit");
+function concatArray(objValue, srcValue) {
+  if (Array.isArray(objValue) && Array.isArray(srcValue)) {
+    return objValue.concat(srcValue);
+  }
+  return;
+}
+function mergeMetroConfig(objValue, srcValue, key) {
+  if (key === "getPolyfills" && typeof objValue === "function" && typeof srcValue === "function") {
+    return () => [...objValue(), ...srcValue()];
+  }
+  return void 0;
+}
+function combineComparers(...fns) {
+  return (targetValue, sourceValue, key, target, source) => {
+    for (const fn of fns) {
+      const result = fn(targetValue, sourceValue, key, target, source);
+      if (result !== void 0) {
+        return result;
+      }
+    }
+    return void 0;
+  };
+}
+async function mergeConfigFromPlugins(plugins) {
+  const pluginsResolved = await (0, import_plugin_core3.flattenPlugins)(plugins);
+  return pluginsResolved.reduce(
+    (acc, plugin) => (0, import_es_toolkit2.mergeWith)(acc, plugin.config ?? {}, combineComparers(concatArray, mergeMetroConfig)),
+    {}
+  );
+}
+
+// src/presets/service.ts
+var import_es_toolkit3 = require("es-toolkit");
+
+// src/presets/common/graniteRequireProtocol.ts
+var graniteRequireProtocol = {
+  load: (args) => {
+    return { loader: "js", contents: `module.exports = __granite_require__('${args.path}');` };
+  }
+};
+
+// src/presets/common/optimizations.ts
+var resolveTslibEsm = () => ({
+  from: "tslib",
+  to: async ({ resolve, args }) => {
+    const result = await resolve(args.path, {
+      kind: args.kind,
+      resolveDir: args.resolveDir
+    });
+    if (result.errors.length) {
+      throw new Error(`resolveTslibEsm: ${args.path}`);
+    }
+    return result.path.replace(/(tslib\.js|modules\/index\.js)$/, "tslib.es6.js");
+  },
+  exact: true
+});
+var optimizations = { resolveTslibEsm };
+
+// src/presets/common/preludeScripts.ts
+var import_path3 = __toESM(require("path"), 1);
+function getReactNativeSetupScripts(rootDir) {
+  const reactNativePath = import_path3.default.dirname(
+    require.resolve("react-native/package.json", {
+      paths: [rootDir]
+    })
+  );
+  return [
+    ...require(import_path3.default.join(reactNativePath, "rn-get-polyfills"))(),
+    import_path3.default.join(reactNativePath, "Libraries/Core/InitializeCore.js")
+  ];
+}
+function getGlobalVariables({ dev = true }) {
+  return {
+    global: "window",
+    __DEV__: JSON.stringify(dev),
+    "process.env.NODE_ENV": JSON.stringify(dev ? "development" : "production")
+  };
+}
+var preludePresets = {
+  globalVariables: ({ dev }) => {
+    return [
+      "var __BUNDLE_START_TIME__=this.nativePerformanceNow?nativePerformanceNow():Date.now();",
+      `var __DEV__=${JSON.stringify(dev)};`,
+      `var window=typeof globalThis!=='undefined'?globalThis:typeof global!=='undefined'?global:typeof window!=='undefined'?window:this;`
+    ].join("\n");
+  },
+  graniteSharedEnvironment: ({ buildNumber }) => {
+    return [
+      "window.__granite = window.__granite || {};",
+      `window.__granite.shared = { buildNumber: ${JSON.stringify(buildNumber)} };`
+    ].join("\n");
+  },
+  graniteAppEnvironment: ({
+    appName,
+    scheme,
+    buildNumber
+  }) => {
+    return [
+      "window.__granite = window.__granite || {};",
+      `window.__granite.app = { name: ${JSON.stringify(appName)}, scheme: ${JSON.stringify(scheme)}, buildNumber: ${JSON.stringify(buildNumber)} };`
+    ].join("\n");
+  }
+};
+
+// src/presets/common/babelConditions.ts
+var babelConditions = [
+  /**
+   * @TODO
+   * zod 에서 hermes 가 지원하지 않는 RegExp 를 사용 중이며,
+   * 대응 가능한 swc 구성/플러그인이 존재하지 않기에 babel 로 트랜스파일하도록 합니다
+   *
+   * @see zod {@link https://github.com/colinhacks/zod/issues/2302}
+   */
+  (_code, path5) => path5.includes("node_modules/zod")
+];
+
+// src/presets/utils/getBuildNumber.ts
+function getBuildNumber() {
+  const date = /* @__PURE__ */ new Date();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hours}${minutes}${seconds}`;
+}
+
+// src/presets/service.ts
+var DEFAULT_OPTIMIZATION_OPTIONS = {
+  "tslib-esm": false
+};
+function commonResolver({ optimization = DEFAULT_OPTIMIZATION_OPTIONS }) {
+  return {
+    alias: [
+      ...[
+        "@react-navigation/native-stack",
+        "@react-navigation/native",
+        "react-native-safe-area-context",
+        "react-native-screens",
+        "react-native-svg",
+        "react-native-gesture-handler",
+        "react-native",
+        "react"
+      ].map((module2) => ({ from: module2, to: `granite-require:${module2}`, exact: true })),
+      optimization["tslib-esm"] ? optimizations.resolveTslibEsm() : null
+    ].filter(import_es_toolkit3.isNotNil),
+    protocols: {
+      "granite-require": graniteRequireProtocol
+    }
+  };
+}
+function getCommonServicePreset(context, { optimization = DEFAULT_OPTIMIZATION_OPTIONS }) {
+  const { dev } = context;
+  const buildNumber = getBuildNumber();
+  return {
+    resolver: commonResolver({ optimization }),
+    esbuild: {
+      /**
+       * React Native 및 Granite 앱에서 사용되는 전역변수
+       */
+      define: getGlobalVariables({ dev }),
+      banner: {
+        js: [
+          preludePresets.graniteAppEnvironment({
+            appName: context.appName,
+            scheme: context.scheme,
+            buildNumber
+          }),
+          // symbol-asynciterator polyfill (ES5)
+          `(function(){if(typeof Symbol!=="undefined"&&!Symbol.asyncIterator){Symbol.asyncIterator=Symbol.for("@@asyncIterator")}})();`
+        ].join("\n")
+      }
+    },
+    babel: {
+      conditions: babelConditions
+    }
+  };
+}
+var service = (options = {}) => (context) => {
+  return getCommonServicePreset(context, options);
+};
+
+// src/presets/shared.ts
+function getCommonSharedPreset(context) {
+  const { rootDir, dev } = context;
+  const buildNumber = getBuildNumber();
+  return {
+    esbuild: {
+      define: getGlobalVariables({ dev }),
+      banner: {
+        js: [preludePresets.globalVariables({ dev }), preludePresets.graniteSharedEnvironment({ buildNumber })].join(
+          "\n"
+        )
+      },
+      prelude: [...getReactNativeSetupScripts(rootDir)]
+    },
+    babel: {
+      conditions: babelConditions
+    }
+  };
+}
+var shared = () => (context) => {
+  return getCommonSharedPreset(context);
+};
+
+// src/config/defineConfig.ts
+var graniteConfigSchema = import_zod.z.object({
+  appName: import_zod.z.string(),
+  scheme: import_zod.z.string(),
+  plugins: import_zod.z.custom(),
+  outdir: import_zod.z.string().default("dist"),
+  entryFile: import_zod.z.string().default("./src/_app.tsx"),
+  cwd: import_zod.z.string().default(process.cwd()),
+  mpack: import_plugin_core4.mpackConfigScheme.optional(),
+  babel: import_mpack2.babelConfigSchema.optional(),
+  esbuild: import_mpack2.esbuildConfigSchema.optional(),
+  metro: import_zod.z.custom().optional(),
+  INTERNAL__useSharedPreset: import_zod.z.boolean().optional()
+});
+var defineConfig = async (config) => {
+  const parsedConfig = graniteConfigSchema.parse(config);
+  const appName = parsedConfig.appName;
+  const scheme = parsedConfig.scheme;
+  const outdir = import_path4.default.join((0, import_utils2.getPackageRoot)(), parsedConfig.outdir);
+  const entryFile = parsedConfig.entryFile;
+  const plugins = await (0, import_plugin_core4.flattenPlugins)(parsedConfig.plugins);
+  const mergedConfig = await mergeConfigFromPlugins(plugins);
+  const mergedTransform = await mergeTransformFromPlugins(plugins);
+  const esbuild = mergedConfig?.esbuild ? (0, import_es_toolkit4.merge)(mergedConfig.esbuild, parsedConfig?.esbuild ?? {}) : void 0;
+  const metro = mergedConfig?.metro ? (0, import_es_toolkit4.merge)(mergedConfig.metro, parsedConfig?.metro ?? {}) : void 0;
+  const babel = mergedConfig?.babel ? (0, import_es_toolkit4.merge)(mergedConfig.babel, parsedConfig?.babel ?? {}) : void 0;
+  const mpackDevServer = mergedConfig?.mpack?.devServer ? (0, import_es_toolkit4.merge)(mergedConfig?.mpack?.devServer ?? {}, parsedConfig?.mpack?.devServer ?? {}) : void 0;
+  const buildPreset = config.INTERNAL__useSharedPreset ? shared : service;
+  const createTask = (platform) => ({
+    tag: `${appName}-${platform}`,
+    presets: [buildPreset()],
+    build: {
+      esbuild,
+      babel,
+      platform,
+      entry: entryFile,
+      outfile: import_path4.default.join(outdir, `bundle.${platform}.js`),
+      transformSync: mergedTransform?.transformSync,
+      transformAsync: mergedTransform?.transformAsync
+    }
+  });
+  return {
+    ...parsedConfig,
+    outdir,
+    mpack: {
+      devServer: {
+        middlewares: mpackDevServer?.middlewares ?? [],
+        config: {
+          appName,
+          scheme,
+          services: {
+            /* TODO: Plugin 구조로 변경 필요 */
+            sentry: {
+              enabled: false
+            }
+          },
+          devServer: {
+            presets: [buildPreset()],
+            build: {
+              entry: entryFile
+            }
+          },
+          tasks: []
+        }
+      },
+      build: {
+        config: {
+          appName,
+          scheme,
+          services: {
+            /* TODO: Plugin 구조로 변경 필요 */
+            sentry: {
+              enabled: false
+            }
+          },
+          concurrency: 2,
+          tasks: [createTask("ios"), createTask("android")]
+        }
+      }
+    },
+    metro: {
+      ...metro,
+      babelConfig: babel,
+      transformSync: mergedTransform?.transformSync
+    }
+  };
+};
+
+// src/index.ts
+var cli = new import_clipanion4.Cli({
+  binaryLabel: "granite",
+  binaryName: "granite",
+  enableCapture: true
+});
+async function initialize() {
+  const explorer = await (0, import_cosmiconfig2.cosmiconfig)("mpack");
+  const result = await explorer.search(process.cwd());
+  cli.register(BuildCommand);
+  cli.register(HermesCommand);
+  cli.register(DevCommand);
+  cli.register(import_clipanion4.Builtins.HelpCommand);
+  if (Array.isArray(result?.config?.commands)) {
+    (result?.config?.commands).forEach((command) => cli.register(command));
+  }
+  cli.runExit(process.argv.slice(2));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  commonResolver,
+  defineConfig,
+  getGlobalVariables,
+  initialize,
+  loadConfig,
+  service
+});