@granite-js/mpack 0.0.1

package/dist/bundler/types.d.ts

@@ -0,0 +1,17 @@
+import * as esbuild from 'esbuild';
+import type { BuildConfig } from '..';
+export type BuildResult = esbuild.BuildResult & {
+    tag: string;
+    bundle: BundleData;
+    outfile: BuildConfig['outfile'];
+    sourcemapOutfile: NonNullable<BuildConfig['sourcemapOutfile']>;
+    platform: BuildConfig['platform'];
+    extra: BuildConfig['extra'];
+    totalModuleCount: number;
+    duration: number;
+    size: number;
+};
+export interface BundleData {
+    source: esbuild.OutputFile;
+    sourcemap: esbuild.OutputFile;
+}

package/dist/bundler/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/cache/Cache.d.ts

@@ -0,0 +1,25 @@
+interface CacheConfig<T> {
+    /**
+     * 파일 시스템에 저장되는 데이터는 string 타입이기에, 데이터를 로드한 후 T 타입으로 변환하기 위한 함수가 필요함.
+     */
+    parse: (data: string) => T;
+    /**
+     * 파일 시스템에 저장되는 데이터는 string 타입이기에, stringify 함수가 필요함.
+     */
+    stringify: (value: T) => string;
+}
+export declare class Cache<T> {
+    private config;
+    static BASE_CACHE_DIR: string;
+    private cache;
+    private cachePath;
+    constructor(cacheDirectoryName: string, config: CacheConfig<T>);
+    getDir(): string;
+    getMemoryCache(): Record<string, T>;
+    read(key: string): Promise<T | null>;
+    write(key: string, value: T): Promise<void>;
+    protected readFromFileSystem(key: string): Promise<string>;
+    protected writeToMemory(key: string, value: T): void;
+    protected writeToFileSystem(key: string, value: T): Promise<void>;
+}
+export {};

package/dist/cache/Cache.js

@@ -0,0 +1,87 @@
+"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 Cache_exports = {};
+__export(Cache_exports, {
+  Cache: () => Cache
+});
+module.exports = __toCommonJS(Cache_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_constants = require("../constants");
+class Cache {
+  constructor(cacheDirectoryName, config) {
+    this.config = config;
+    this.cachePath = path.join(Cache.BASE_CACHE_DIR, cacheDirectoryName);
+    try {
+      fs.accessSync(this.cachePath, fs.constants.R_OK | fs.constants.W_OK);
+    } catch {
+      fs.mkdirSync(this.cachePath, { recursive: true });
+    }
+  }
+  static BASE_CACHE_DIR = import_constants.MPACK_CACHE_DIR;
+  cache = {};
+  cachePath;
+  getDir() {
+    return this.cachePath;
+  }
+  getMemoryCache() {
+    return this.cache;
+  }
+  async read(key) {
+    const cache = this.cache[key];
+    try {
+      if (cache) {
+        return cache;
+      }
+      const fsCache = await this.readFromFileSystem(key);
+      const parsedCache = this.config.parse(fsCache);
+      this.writeToMemory(key, parsedCache);
+      return parsedCache;
+    } catch {
+      return null;
+    }
+  }
+  async write(key, value) {
+    this.writeToMemory(key, value);
+    await this.writeToFileSystem(key, value);
+  }
+  readFromFileSystem(key) {
+    return fs.promises.readFile(path.join(this.getDir(), key), "utf-8");
+  }
+  writeToMemory(key, value) {
+    this.cache[key] = value;
+  }
+  writeToFileSystem(key, value) {
+    return fs.promises.writeFile(path.join(this.getDir(), key), this.config.stringify(value), "utf-8");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cache
+});

package/dist/cache/index.d.ts

@@ -0,0 +1 @@
+export * from './Cache';

package/dist/cache/index.js

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

package/dist/constants/index.d.ts

@@ -0,0 +1,20 @@
+export declare const VERSION: any;
+export declare const REQUIRE_CONTEXT_PROTOCOL = "require-context:";
+export declare const PRELUDE_PROTOCOL = "prelude:";
+export declare const MPACK_DATA_DIR: string;
+export declare const MPACK_CACHE_DIR: string;
+export declare const SOURCE_EXTENSIONS: readonly [".tsx", ".ts", ".jsx", ".js", ".json"];
+export declare const ASSET_EXTENSIONS: readonly [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"];
+export declare const DEV_SERVER_DEFAULT_HOST = "localhost";
+export declare const DEV_SERVER_DEFAULT_PORT = 8081;
+/**
+ * 제거 필요: `SHARED_BUNDLE_NAME`, `SERVICE_BUNDLE_NAME` -> `BUNDLE_NAME`
+ */
+export declare const SHARED_BUNDLE_NAME: `${string}.bundle`;
+export declare const SERVICE_BUNDLE_NAME: `${string}.bundle`;
+export declare const BUNDLE_NAME: `${string}.bundle`;
+export declare const DEBUGGER_FRONTEND_PATH = "/debugger-frontend";
+export declare const RESOLVER_MAIN_FIELDS: string[];
+export declare const RESOLVER_EXPORTS_MAP_CONDITIONS: string[];
+export declare const INTERNAL_NAMESPACE_IDENTIFIER = "__mpackInternal";
+export declare const INTERNAL_EVALUATE_MAIN_BUNDLE_IDENTIFIER = "evaluateMainBundle";

package/dist/constants/index.js

@@ -0,0 +1,91 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  ASSET_EXTENSIONS: () => ASSET_EXTENSIONS,
+  BUNDLE_NAME: () => BUNDLE_NAME,
+  DEBUGGER_FRONTEND_PATH: () => DEBUGGER_FRONTEND_PATH,
+  DEV_SERVER_DEFAULT_HOST: () => DEV_SERVER_DEFAULT_HOST,
+  DEV_SERVER_DEFAULT_PORT: () => DEV_SERVER_DEFAULT_PORT,
+  INTERNAL_EVALUATE_MAIN_BUNDLE_IDENTIFIER: () => INTERNAL_EVALUATE_MAIN_BUNDLE_IDENTIFIER,
+  INTERNAL_NAMESPACE_IDENTIFIER: () => INTERNAL_NAMESPACE_IDENTIFIER,
+  MPACK_CACHE_DIR: () => MPACK_CACHE_DIR,
+  MPACK_DATA_DIR: () => MPACK_DATA_DIR,
+  PRELUDE_PROTOCOL: () => PRELUDE_PROTOCOL,
+  REQUIRE_CONTEXT_PROTOCOL: () => REQUIRE_CONTEXT_PROTOCOL,
+  RESOLVER_EXPORTS_MAP_CONDITIONS: () => RESOLVER_EXPORTS_MAP_CONDITIONS,
+  RESOLVER_MAIN_FIELDS: () => RESOLVER_MAIN_FIELDS,
+  SERVICE_BUNDLE_NAME: () => SERVICE_BUNDLE_NAME,
+  SHARED_BUNDLE_NAME: () => SHARED_BUNDLE_NAME,
+  SOURCE_EXTENSIONS: () => SOURCE_EXTENSIONS,
+  VERSION: () => VERSION
+});
+module.exports = __toCommonJS(constants_exports);
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var import_getBundleName = require("../utils/getBundleName");
+const TEMP_DIR = path.join(os.tmpdir(), "mpack");
+const VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, "../../package.json"), "utf-8")).version;
+const REQUIRE_CONTEXT_PROTOCOL = "require-context:";
+const PRELUDE_PROTOCOL = "prelude:";
+const MPACK_DATA_DIR = path.join(TEMP_DIR, "data");
+const MPACK_CACHE_DIR = path.join(TEMP_DIR, "cache");
+const SOURCE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".json"];
+const ASSET_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"];
+const DEV_SERVER_DEFAULT_HOST = "localhost";
+const DEV_SERVER_DEFAULT_PORT = 8081;
+const SHARED_BUNDLE_NAME = (0, import_getBundleName.getBundleName)("index");
+const SERVICE_BUNDLE_NAME = (0, import_getBundleName.getBundleName)("service");
+const BUNDLE_NAME = (0, import_getBundleName.getBundleName)("index");
+const DEBUGGER_FRONTEND_PATH = "/debugger-frontend";
+const RESOLVER_MAIN_FIELDS = ["react-native", "browser", "main"];
+const RESOLVER_EXPORTS_MAP_CONDITIONS = ["react-native"];
+const INTERNAL_NAMESPACE_IDENTIFIER = "__mpackInternal";
+const INTERNAL_EVALUATE_MAIN_BUNDLE_IDENTIFIER = "evaluateMainBundle";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ASSET_EXTENSIONS,
+  BUNDLE_NAME,
+  DEBUGGER_FRONTEND_PATH,
+  DEV_SERVER_DEFAULT_HOST,
+  DEV_SERVER_DEFAULT_PORT,
+  INTERNAL_EVALUATE_MAIN_BUNDLE_IDENTIFIER,
+  INTERNAL_NAMESPACE_IDENTIFIER,
+  MPACK_CACHE_DIR,
+  MPACK_DATA_DIR,
+  PRELUDE_PROTOCOL,
+  REQUIRE_CONTEXT_PROTOCOL,
+  RESOLVER_EXPORTS_MAP_CONDITIONS,
+  RESOLVER_MAIN_FIELDS,
+  SERVICE_BUNDLE_NAME,
+  SHARED_BUNDLE_NAME,
+  SOURCE_EXTENSIONS,
+  VERSION
+});

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { Bundler } from './bundler';
+export { DevServer } from './server';
+export { loadConfig } from './utils/loadConfig';
+export { loadPresets } from './utils/loadPresets';
+export { getMetroConfig, runBuild as metroBuild, type MetroConfig } from './metro';
+export { DEV_SERVER_DEFAULT_HOST, DEV_SERVER_DEFAULT_PORT, SHARED_BUNDLE_NAME, SERVICE_BUNDLE_NAME, BUNDLE_NAME, } from './constants';
+export * from './operations';
+export * from './types/schemas';
+export * from './types';
+export type { AdditionalMetroConfig } from './metro/getMetroConfig';
+export type { BuildResult } from './bundler/types';

package/dist/index.js

@@ -0,0 +1,60 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  BUNDLE_NAME: () => import_constants.BUNDLE_NAME,
+  Bundler: () => import_bundler.Bundler,
+  DEV_SERVER_DEFAULT_HOST: () => import_constants.DEV_SERVER_DEFAULT_HOST,
+  DEV_SERVER_DEFAULT_PORT: () => import_constants.DEV_SERVER_DEFAULT_PORT,
+  DevServer: () => import_server.DevServer,
+  SERVICE_BUNDLE_NAME: () => import_constants.SERVICE_BUNDLE_NAME,
+  SHARED_BUNDLE_NAME: () => import_constants.SHARED_BUNDLE_NAME,
+  getMetroConfig: () => import_metro.getMetroConfig,
+  loadConfig: () => import_loadConfig.loadConfig,
+  loadPresets: () => import_loadPresets.loadPresets,
+  metroBuild: () => import_metro.runBuild
+});
+module.exports = __toCommonJS(index_exports);
+var import_bundler = require("./bundler");
+var import_server = require("./server");
+var import_loadConfig = require("./utils/loadConfig");
+var import_loadPresets = require("./utils/loadPresets");
+var import_metro = require("./metro");
+var import_constants = require("./constants");
+__reExport(index_exports, require("./operations"), module.exports);
+__reExport(index_exports, require("./types/schemas"), module.exports);
+__reExport(index_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUNDLE_NAME,
+  Bundler,
+  DEV_SERVER_DEFAULT_HOST,
+  DEV_SERVER_DEFAULT_PORT,
+  DevServer,
+  SERVICE_BUNDLE_NAME,
+  SHARED_BUNDLE_NAME,
+  getMetroConfig,
+  loadConfig,
+  loadPresets,
+  metroBuild,
+  ...require("./operations"),
+  ...require("./types/schemas"),
+  ...require("./types")
+});

package/dist/logger/Logger.d.ts

@@ -0,0 +1,17 @@
+type SerializableType = string | number | boolean | object | null | undefined;
+declare class Logger {
+    private static LEVEL_COLOR;
+    trace(...messages: SerializableType[]): void;
+    debug(...messages: SerializableType[]): void;
+    info(...messages: SerializableType[]): void;
+    log(...messages: SerializableType[]): void;
+    warn(...messages: SerializableType[]): void;
+    error(...messages: SerializableType[]): void;
+    getTimestamp(): string;
+    private stdout;
+    private stderr;
+    private stringify;
+    private createLogString;
+}
+export declare const logger: Logger;
+export {};

package/dist/logger/Logger.js

@@ -0,0 +1,115 @@
+"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 Logger_exports = {};
+__export(Logger_exports, {
+  logger: () => logger
+});
+module.exports = __toCommonJS(Logger_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_es_toolkit = require("es-toolkit");
+var import_isDebugMode = require("../utils/isDebugMode");
+class Logger {
+  static LEVEL_COLOR = {
+    trace: import_chalk.default.gray,
+    debug: import_chalk.default.gray,
+    info: import_chalk.default.cyan,
+    log: import_chalk.default.green,
+    warn: import_chalk.default.yellow,
+    error: import_chalk.default.red
+  };
+  trace(...messages) {
+    if ((0, import_isDebugMode.isDebugMode)("mpack")) {
+      this.stdout(this.createLogString("trace", ...messages));
+    }
+  }
+  debug(...messages) {
+    if ((0, import_isDebugMode.isDebugMode)("mpack")) {
+      this.stdout(this.createLogString("debug", ...messages));
+    }
+  }
+  info(...messages) {
+    this.stdout(this.createLogString("info", ...messages));
+  }
+  log(...messages) {
+    this.stdout(this.createLogString("log", ...messages));
+  }
+  warn(...messages) {
+    this.stderr(this.createLogString("warn", ...messages));
+  }
+  error(...messages) {
+    this.stderr(this.createLogString("error", ...messages));
+  }
+  getTimestamp() {
+    const date = /* @__PURE__ */ new Date();
+    const yyyy = date.getFullYear();
+    const MM = (date.getMonth() + 1).toString().padStart(2, "0");
+    const dd = date.getDate().toString().padStart(2, "0");
+    const hh = date.getHours().toString().padStart(2, "0");
+    const mm = date.getMinutes().toString().padStart(2, "0");
+    const ss = date.getSeconds().toString().padStart(2, "0");
+    const sss = date.getMilliseconds().toString().padStart(3, "0");
+    return `${yyyy}-${MM}-${dd} ${hh}:${mm}:${ss}.${sss}`;
+  }
+  stdout(buffer) {
+    process.stdout.write(buffer);
+  }
+  stderr(buffer) {
+    process.stderr.write(buffer);
+  }
+  stringify(value) {
+    if (value instanceof Error) {
+      return value.toString();
+    }
+    switch (typeof value) {
+      case "string":
+        return value;
+      case "number":
+      case "boolean":
+        return value.toString();
+      case "undefined":
+        return "undefined";
+      case "object":
+        return JSON.stringify(value, null, 2);
+      default:
+        return null;
+    }
+  }
+  createLogString(level, ...messages) {
+    const timestamp = import_chalk.default.gray(this.getTimestamp());
+    const coloredLevel = Logger.LEVEL_COLOR[level](import_chalk.default.bold(level));
+    const message = messages.map(this.stringify).filter(import_es_toolkit.isNotNil).join(" ");
+    return `${timestamp} ${coloredLevel} ${message}
+`;
+  }
+}
+const logger = new Logger();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  logger
+});

package/dist/logger/clientLogger.d.ts

@@ -0,0 +1,2 @@
+import type { ClientLogEvent } from '../server/types';
+export declare const clientLogger: (level: ClientLogEvent["level"], data: any[]) => void;

package/dist/logger/clientLogger.js

@@ -0,0 +1,49 @@
+"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 clientLogger_exports = {};
+__export(clientLogger_exports, {
+  clientLogger: () => clientLogger
+});
+module.exports = __toCommonJS(clientLogger_exports);
+var import_Logger = require("./Logger");
+const clientLogger = (level, data) => {
+  switch (level) {
+    case "trace":
+      import_Logger.logger.trace(...data);
+      break;
+    case "debug":
+      import_Logger.logger.debug(...data);
+      break;
+    case "info":
+      import_Logger.logger.info(...data);
+      break;
+    case "warn":
+      import_Logger.logger.warn(...data);
+      break;
+    case "error":
+      import_Logger.logger.error(...data);
+      break;
+    default:
+      import_Logger.logger.log(...data);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clientLogger
+});

package/dist/logger/index.d.ts

@@ -0,0 +1,3 @@
+import { logger } from './Logger';
+import { clientLogger } from './clientLogger';
+export { logger, clientLogger };

package/dist/logger/index.js

@@ -0,0 +1,31 @@
+"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 logger_exports = {};
+__export(logger_exports, {
+  clientLogger: () => import_clientLogger.clientLogger,
+  logger: () => import_Logger.logger
+});
+module.exports = __toCommonJS(logger_exports);
+var import_Logger = require("./Logger");
+var import_clientLogger = require("./clientLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clientLogger,
+  logger
+});

package/dist/metro/assetRegistry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @see https://github.com/facebook/react-native/blob/v0.72.6/packages/assets/registry.js#L13-L24
+ */
+interface Asset {
+    httpServerLocation: string;
+    hash: string;
+    name: string;
+    type: string;
+}
+declare function registerAsset(asset: Asset): void;
+declare function noop(): void;
+export { registerAsset, noop as getAssetByID };

package/dist/metro/assetRegistry.js

@@ -0,0 +1,57 @@
+"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 assetRegistry_exports = {};
+__export(assetRegistry_exports, {
+  getAssetByID: () => noop,
+  registerAsset: () => registerAsset
+});
+module.exports = __toCommonJS(assetRegistry_exports);
+const IGNORE_PATH_PATTERN = [/react-native\/Libraries\/LogBox\/UI/, /@react-navigation\/elements/];
+const assets = /* @__PURE__ */ new Set();
+function registerAsset(asset) {
+  const key = getUniqueKey(asset);
+  if (assets.has(key)) {
+    return;
+  }
+  assets.add(key);
+  warnUnableToUseLocalResources(asset);
+}
+function warnUnableToUseLocalResources(asset) {
+  const localPath = asset.httpServerLocation.replace(/^\/assets\//, "");
+  const fileName = `${asset.name}.${asset.type}`;
+  const shouldIgnore = IGNORE_PATH_PATTERN.some((pattern) => pattern.test(localPath));
+  if (__DEV__ && !shouldIgnore) {
+    console.warn(
+      [
+        "(DEV) \uB85C\uCEEC \uB9AC\uC18C\uC2A4\uB294 \uC9C0\uC6D0\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. URI \uBC29\uC2DD\uC758 \uC6D0\uACA9 \uB9AC\uC18C\uC2A4\uB97C \uC0AC\uC6A9\uD574\uC8FC\uC138\uC694.",
+        `Resource: ${localPath}/${fileName}`
+      ].join("\n")
+    );
+  }
+}
+function getUniqueKey(asset) {
+  return `${asset.name}#${asset.hash}`;
+}
+function noop() {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAssetByID,
+  registerAsset
+});

package/dist/metro/enhancedResolver.d.ts

@@ -0,0 +1,7 @@
+interface CustomResolutionContext {
+    sourceExts: string[];
+    originModulePath: string;
+    preferNativePlatform?: boolean;
+}
+export declare function createResolver(rootPath: string): (context: CustomResolutionContext, request: string, platform: string | null) => any;
+export {};