@granite-js/mpack 0.0.1

package/dist/metro/enhancedResolver.js

@@ -0,0 +1,127 @@
+"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 enhancedResolver_exports = {};
+__export(enhancedResolver_exports, {
+  createResolver: () => createResolver
+});
+module.exports = __toCommonJS(enhancedResolver_exports);
+var import_module = __toESM(require("module"));
+var import_path = __toESM(require("path"));
+var import_enhanced_resolve = __toESM(require("enhanced-resolve"));
+var import_constants = require("../constants");
+const SINGLETON_MODULES = ["@babel/runtime"];
+const NATIVE_MODULES = ["react-native", "react"];
+const SUPPORTED_BUILTIN_FALLBACKS = {
+  http: "stream-http",
+  https: "https-browserify",
+  zlib: "browserify-zlib",
+  url: "url",
+  util: "util",
+  path: "path-browserify",
+  buffer: "buffer",
+  stream: "stream-browserify",
+  assert: "assert",
+  events: "events"
+};
+const builtinModules = new Set(import_module.default.builtinModules);
+const resolvers = /* @__PURE__ */ new Map();
+function createResolver(rootPath) {
+  function createResolverImpl(context, platform, rootPath2) {
+    const baseExtensions = context.sourceExts.map((extension) => `.${extension}`);
+    let finalExtensions = [...baseExtensions];
+    if (context.preferNativePlatform) {
+      finalExtensions = [...baseExtensions.map((extension) => `.native${extension}`), ...finalExtensions];
+    }
+    if (platform) {
+      finalExtensions = [...baseExtensions.map((extension) => `.${platform}${extension}`), ...finalExtensions];
+    }
+    const resolver = import_enhanced_resolve.default.create.sync({
+      extensions: finalExtensions,
+      mainFields: import_constants.RESOLVER_MAIN_FIELDS,
+      mainFiles: ["index"],
+      conditionNames: [...import_constants.RESOLVER_EXPORTS_MAP_CONDITIONS, "require", "node", "default"],
+      modules: ["node_modules", import_path.default.join(rootPath2, "src")]
+    });
+    function resolve(context2, request) {
+      for (const nativeModule of NATIVE_MODULES) {
+        if (request === nativeModule) {
+          return {
+            type: "sourceFile",
+            filePath: resolver({}, rootPath2, request)
+          };
+        }
+      }
+      for (const singletonModule of SINGLETON_MODULES) {
+        if (request.startsWith(singletonModule)) {
+          return {
+            type: "sourceFile",
+            filePath: resolver({}, rootPath2, request)
+          };
+        }
+      }
+      if (builtinModules.has(request)) {
+        if (request in SUPPORTED_BUILTIN_FALLBACKS) {
+          const source = SUPPORTED_BUILTIN_FALLBACKS[request];
+          return {
+            type: "sourceFile",
+            filePath: require.resolve(`${source}/`)
+          };
+        }
+        request = `${request}/`;
+      }
+      try {
+        const resolveResult = resolver({}, import_path.default.dirname(context2.originModulePath), request);
+        return {
+          type: "sourceFile",
+          filePath: resolveResult
+        };
+      } catch (error) {
+        const typedError = error;
+        if ("code" in typedError && typedError.code !== "QUALIFIED_PATH_RESOLUTION_FAILED") {
+          typedError.message = `"${context2.originModulePath}"\uC5D0\uC11C "${request}"\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC5C8\uC2B5\uB2C8\uB2E4.
+${typedError.message}`;
+        }
+        throw typedError;
+      }
+    }
+    return resolve;
+  }
+  return function resolve(context, request, platform) {
+    let resolver = resolvers.get(platform);
+    if (resolver == null) {
+      resolver = createResolverImpl(context, platform, rootPath);
+      resolvers.set(platform, resolver);
+    }
+    return resolver(context, request, platform);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createResolver
+});

package/dist/metro/getMetroConfig.d.ts

@@ -0,0 +1,12 @@
+import type * as babel from '@babel/core';
+import type { MetroConfig } from './types';
+export interface GetMetroConfig {
+    rootPath: string;
+    appName: string;
+    scheme: string;
+}
+export interface AdditionalMetroConfig extends MetroConfig {
+    transformSync?: (id: string, code: string) => string;
+    babelConfig?: babel.TransformOptions;
+}
+export declare function getMetroConfig({ rootPath, appName, scheme }: GetMetroConfig, additionalConfig?: AdditionalMetroConfig): Promise<any>;

package/dist/metro/getMetroConfig.js

@@ -0,0 +1,138 @@
+"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 getMetroConfig_exports = {};
+__export(getMetroConfig_exports, {
+  getMetroConfig: () => getMetroConfig
+});
+module.exports = __toCommonJS(getMetroConfig_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@granite-js/utils");
+var import_enhancedResolver = require("./enhancedResolver");
+var import_getMonorepoRoot = require("./getMonorepoRoot");
+var import_runtime = require("./runtime");
+var import_constants = require("../constants");
+var import_defaults = require("../vendors/metro-config/src/defaults");
+var import_exclusionList = __toESM(require("../vendors/metro-config/src/defaults/exclusionList"));
+var import_loadConfig = require("../vendors/metro-config/src/loadConfig");
+const INTERNAL_CALLSITES_REGEX = new RegExp(
+  [
+    "/Libraries/Renderer/implementations/.+\\.js$",
+    "/Libraries/BatchedBridge/MessageQueue\\.js$",
+    "/Libraries/YellowBox/.+\\.js$",
+    "/Libraries/LogBox/.+\\.js$",
+    "/Libraries/Core/Timers/.+\\.js$",
+    "/Libraries/WebSocket/.+\\.js$",
+    "/Libraries/vendor/.+\\.js$",
+    "/node_modules/react-devtools-core/.+\\.js$",
+    "/node_modules/react-refresh/.+\\.js$",
+    "/node_modules/scheduler/.+\\.js$",
+    "/node_modules/event-target-shim/.+\\.js$",
+    "/node_modules/invariant/.+\\.js$",
+    "/node_modules/react-native/index.js$",
+    "/metro-runtime/.+\\.js$",
+    "^\\[native code\\]$"
+  ].join("|")
+);
+async function getMetroConfig({ rootPath, appName, scheme }, additionalConfig) {
+  const defaultConfig = (0, import_defaults.getDefaultValues)(rootPath);
+  const reactNativePath = import_path.default.dirname(resolveFromRoot("react-native/package.json", rootPath));
+  const resolvedRootPath = await (0, import_getMonorepoRoot.getMonorepoRoot)(rootPath);
+  const packageRootPath = await (0, import_utils.getPackageRoot)();
+  const { path: envFilePath } = await (0, import_runtime.writeEnvScript)(packageRootPath, appName, scheme);
+  return (0, import_loadConfig.mergeConfig)(defaultConfig, {
+    watchFolders: [resolvedRootPath, packageRootPath],
+    transformerPath: resolveVendors("metro-transform-worker/src"),
+    transformer: {
+      allowOptionalDependencies: true,
+      assetRegistryPath: import_path.default.resolve(__dirname, "assetRegistry.js"),
+      workerPath: resolveVendors("metro/src/DeltaBundler/Worker"),
+      getTransformOptions: async () => ({
+        transform: {
+          experimentalImportSupport: false,
+          inlineRequires: false
+        }
+      }),
+      babelTransformerPath: require.resolve("metro-react-native-babel-transformer"),
+      asyncRequireModulePath: require.resolve("metro-runtime/src/modules/asyncRequire"),
+      unstable_collectDependenciesPath: resolveVendors("metro/src/ModuleGraph/worker/collectDependencies"),
+      unstable_allowRequireContext: true,
+      /**
+       * @see [WorkerFarm.js](../vendors/metro/src/DeltaBundler/WorkerFarm.js)
+       */
+      INTERNAL__transformSync: additionalConfig?.transformSync,
+      /**
+       * @see [index.js](../vendors/metro-transform-worker/src/index.js)
+       */
+      INTERNAL__babelConfig: additionalConfig?.babelConfig
+    },
+    resolver: {
+      // metro
+      platforms: ["android", "ios"],
+      useWatchman: false,
+      resolveRequest: (0, import_enhancedResolver.createResolver)(rootPath),
+      // metro-file-map
+      sourceExts: [...import_constants.SOURCE_EXTENSIONS.map((extension) => extension.replace(/^\.?/, "")), "cjs", "mjs"],
+      blockList: (0, import_exclusionList.default)(
+        additionalConfig?.resolver?.blockList ? asArray(additionalConfig.resolver.blockList) : []
+      )
+    },
+    serializer: {
+      getModulesRunBeforeMainModule: () => [resolveFromRoot("react-native/Libraries/Core/InitializeCore", rootPath)],
+      getPolyfills: () => [
+        envFilePath,
+        ...additionalConfig?.serializer?.getPolyfills?.() ?? [],
+        ...require(import_path.default.join(reactNativePath, "rn-get-polyfills"))()
+      ]
+    },
+    symbolicator: {
+      customizeFrame: (frame) => {
+        const collapse = Boolean(frame.file && INTERNAL_CALLSITES_REGEX.test(frame.file));
+        return { collapse };
+      }
+    },
+    server: {
+      port: import_constants.DEV_SERVER_DEFAULT_PORT
+    },
+    ...process.env.METRO_RESET_CACHE !== "false" ? { resetCache: true } : {}
+  });
+}
+function resolveFromRoot(source, rootPath) {
+  return require.resolve(source, { paths: [rootPath] });
+}
+function resolveVendors(source) {
+  const vendorsBase = import_path.default.resolve(__dirname, "../vendors");
+  return require.resolve(import_path.default.join(vendorsBase, source));
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMetroConfig
+});

package/dist/metro/getMonorepoRoot.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 단일 혹은 워크스페이스 기반 프로젝트 환경에서 적절한 루트 경로를 가져오는 유틸입니다
+ */
+export declare function getMonorepoRoot(basePath: string): Promise<string>;

package/dist/metro/getMonorepoRoot.js

@@ -0,0 +1,80 @@
+"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 getMonorepoRoot_exports = {};
+__export(getMonorepoRoot_exports, {
+  getMonorepoRoot: () => getMonorepoRoot
+});
+module.exports = __toCommonJS(getMonorepoRoot_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_pnpapi = require("./pnpapi");
+async function getMonorepoRoot(basePath) {
+  if (import_pnpapi.pnpapi) {
+    return import_pnpapi.pnpapi.getPackageInformation(import_pnpapi.pnpapi.topLevel).packageLocation ?? null;
+  }
+  let curr = basePath;
+  while (curr !== import_path.default.dirname(curr)) {
+    if (await isWorkspace(basePath)) {
+      return curr;
+    }
+    curr = import_path.default.dirname(curr);
+  }
+  return basePath;
+}
+async function safeReadPackageJson(basePath) {
+  try {
+    return JSON.parse(await import_promises.default.readFile(import_path.default.join(basePath, "package.json"), "utf-8"));
+  } catch {
+  }
+}
+async function safeAccess(path2) {
+  try {
+    await import_promises.default.access(path2, import_promises.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isWorkspace(basePath) {
+  const packageJson = await safeReadPackageJson(basePath);
+  const hasPackageJson = Boolean(packageJson);
+  const hasWorkspacesField = Array.isArray(packageJson?.workspaces);
+  if (hasWorkspacesField) {
+    return true;
+  }
+  const hasWorkspaceManifest = await safeAccess(import_path.default.join(basePath, "pnpm-workspace.yaml"));
+  if (hasPackageJson && hasWorkspaceManifest) {
+    return true;
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMonorepoRoot
+});

package/dist/metro/index.d.ts

@@ -0,0 +1,3 @@
+export * from './getMetroConfig';
+export * from './runBuild';
+export type { MetroConfig } from './types';

package/dist/metro/index.js

@@ -0,0 +1,24 @@
+"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 metro_exports = {};
+module.exports = __toCommonJS(metro_exports);
+__reExport(metro_exports, require("./getMetroConfig"), module.exports);
+__reExport(metro_exports, require("./runBuild"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./getMetroConfig"),
+  ...require("./runBuild")
+});

package/dist/metro/pnpapi.d.ts

@@ -0,0 +1,6 @@
+import type { getPackageInformation, topLevel } from 'pnpapi';
+export interface PnpApi {
+    getPackageInformation: typeof getPackageInformation;
+    topLevel: typeof topLevel;
+}
+export declare let pnpapi: PnpApi | undefined;

package/dist/metro/pnpapi.js

@@ -0,0 +1,32 @@
+"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 pnpapi_exports = {};
+__export(pnpapi_exports, {
+  pnpapi: () => pnpapi
+});
+module.exports = __toCommonJS(pnpapi_exports);
+let pnpapi;
+try {
+  pnpapi = require("pnpapi");
+} catch {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pnpapi
+});

package/dist/metro/runBuild.d.ts

@@ -0,0 +1,12 @@
+import type { MetroConfig } from './types';
+export declare function runBuild({ appName, scheme, rootPath, entry, platform, minify, out, dev, additionalConfig, }: {
+    appName: string;
+    scheme: string;
+    rootPath: string;
+    entry: string;
+    platform: 'ios' | 'android';
+    minify: boolean;
+    out: string;
+    dev: boolean;
+    additionalConfig?: MetroConfig;
+}): Promise<void>;

package/dist/metro/runBuild.js

@@ -0,0 +1,66 @@
+"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 runBuild_exports = {};
+__export(runBuild_exports, {
+  runBuild: () => runBuild
+});
+module.exports = __toCommonJS(runBuild_exports);
+var import_getMetroConfig = require("./getMetroConfig");
+var import_src = __toESM(require("../vendors/metro/src"));
+async function runBuild({
+  appName,
+  scheme,
+  rootPath,
+  entry,
+  platform,
+  minify,
+  out,
+  dev,
+  additionalConfig
+}) {
+  const config = await (0, import_getMetroConfig.getMetroConfig)(
+    {
+      appName,
+      rootPath,
+      scheme
+    },
+    additionalConfig
+  );
+  await import_src.default.runBuild(config, {
+    entry,
+    platform,
+    minify,
+    out,
+    dev
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runBuild
+});

package/dist/metro/runtime.d.ts

@@ -0,0 +1,3 @@
+export declare function writeEnvScript(rootPath: string, appName: string, scheme: string): Promise<{
+    path: string;
+}>;

package/dist/metro/runtime.js

@@ -0,0 +1,56 @@
+"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 runtime_exports = {};
+__export(runtime_exports, {
+  writeEnvScript: () => writeEnvScript
+});
+module.exports = __toCommonJS(runtime_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+async function writeEnvScript(rootPath, appName, scheme) {
+  const script = getEnvScript(appName, scheme);
+  const basePath = import_path.default.join(rootPath, ".granite");
+  const filePath = import_path.default.join(basePath, ".env.js");
+  await import_promises.default.access(basePath).catch(() => import_promises.default.mkdir(basePath));
+  await import_promises.default.writeFile(filePath, script, { encoding: "utf-8" });
+  return { path: filePath };
+}
+function getEnvScript(appName, scheme) {
+  const buildNumber = "00000000";
+  const script = [
+    "global.__granite = global.__granite || {};",
+    `global.__granite.shared = { buildNumber: ${JSON.stringify(buildNumber)} };`,
+    `global.__granite.app = { name: ${appName.startsWith("babel:") ? appName.slice(6) : JSON.stringify(appName)}, scheme: ${JSON.stringify(scheme)}, buildNumber: ${JSON.stringify(buildNumber)} };`
+  ].join("\n");
+  return script;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  writeEnvScript
+});

package/dist/metro/types.d.ts

@@ -0,0 +1,88 @@
+type Untyped = any;
+interface PackageJson {
+    readonly name?: string;
+    readonly main?: string;
+    readonly exports?: string | Untyped;
+}
+interface PackageInfo {
+    readonly packageJson: PackageJson;
+    readonly rootPath: string;
+}
+type ResolveAsset = (dirPath: string, assetName: string, extension: string) => string[] | undefined;
+interface ResolutionContext {
+    readonly assetExts: string[];
+    readonly allowHaste: boolean;
+    readonly customResolverOptions: Untyped;
+    readonly disableHierarchicalLookup: boolean;
+    readonly doesFileExist: Untyped;
+    readonly extraNodeModules?: {
+        [key: string]: string;
+    };
+    readonly getPackage: (packageJsonPath: string) => PackageJson | null;
+    readonly getPackageForModule: (modulePath: string) => PackageInfo | null;
+    readonly dependency?: any;
+    readonly mainFields: string[];
+    readonly originModulePath: string;
+    readonly nodeModulesPaths: string[];
+    readonly preferNativePlatform: boolean;
+    readonly resolveAsset: ResolveAsset;
+    readonly redirectModulePath: (modulePath: string) => string | false;
+    readonly resolveHasteModule: (name: string) => string | undefined;
+    readonly resolveHastePackage: (name: string) => string | undefined;
+    readonly resolveRequest?: CustomResolver;
+    readonly sourceExts: string[];
+    readonly unstable_conditionsByPlatform: {
+        [platform: string]: string[];
+    };
+    unstable_conditionNames: string[];
+    unstable_enablePackageExports: boolean;
+    unstable_getRealPath?: any;
+    unstable_logWarning: (message: string) => void;
+}
+export interface CustomResolutionContext extends ResolutionContext {
+    readonly resolveRequest: CustomResolver;
+}
+type CustomResolver = (context: CustomResolutionContext, moduleName: string, platform: string | null) => any;
+interface ResolverConfig {
+    assetExts: string[];
+    assetResolutions: string[];
+    blacklistRE?: RegExp | RegExp[];
+    blockList: RegExp | RegExp[];
+    dependencyExtractor?: string;
+    disableHierarchicalLookup: boolean;
+    extraNodeModules: {
+        [name: string]: string;
+    };
+    emptyModulePath: string;
+    enableGlobalPackages: boolean;
+    hasteImplModulePath?: string;
+    nodeModulesPaths: string[];
+    platforms: string[];
+    resolveRequest?: CustomResolver;
+    resolverMainFields: string[];
+    sourceExts: string[];
+    unstable_enableSymlinks: boolean;
+    unstable_conditionNames: string[];
+    unstable_conditionsByPlatform: Readonly<{
+        [platform: string]: string[];
+    }>;
+    unstable_enablePackageExports: boolean;
+    useWatchman: boolean;
+    requireCycleIgnorePatterns: ReadonlyArray<RegExp>;
+}
+/**
+ * 패키지에서 타입 정의 파일이 export 되어있지 않아 별도로 타입을 정의합니다.
+ */
+export interface MetroConfig {
+    readonly watchFolders?: string[];
+    readonly cacheStores?: any;
+    readonly resolver?: Partial<ResolverConfig>;
+    readonly server?: any;
+    readonly serializer?: object & {
+        getPolyfills?: () => string[];
+    };
+    readonly symbolicator?: any;
+    readonly transformer?: any;
+    readonly watcher?: any;
+}
+export {};