@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/bundler/plugins/transformPlugin/transformPlugin.js

@@ -0,0 +1,88 @@
+"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 transformPlugin_exports = {};
+__export(transformPlugin_exports, {
+  transformPlugin: () => transformPlugin
+});
+module.exports = __toCommonJS(transformPlugin_exports);
+var import_assert = __toESM(require("assert"));
+var fs = __toESM(require("fs/promises"));
+var preludeScript = __toESM(require("./helpers/preludeScript"));
+var import_createCacheSteps = require("./steps/createCacheSteps");
+var import_createFullyTransformStep = require("./steps/createFullyTransformStep");
+var import_createStripFlowStep = require("./steps/createStripFlowStep");
+var import_createTransformToHermesSyntaxStep = require("./steps/createTransformToHermesSyntaxStep");
+var import_performance = require("../../../performance");
+var import_transformer = require("../../../transformer");
+const sourceRegExp = /\.([mc]js|[tj]sx?)$/;
+function transformPlugin({ context, ...options }) {
+  return {
+    name: "transform-plugin",
+    setup(build) {
+      const { id, config } = context;
+      const { dev, cache, buildConfig } = config;
+      const { esbuild, swc, babel } = buildConfig;
+      (0, import_assert.default)(id, "id \uAC12\uC774 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+      (0, import_assert.default)(typeof dev === "boolean", "dev \uAC12\uC774 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+      (0, import_assert.default)(typeof cache === "boolean", "cache \uAC12\uC774 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+      const cacheSteps = (0, import_createCacheSteps.createCacheSteps)({ id, enabled: cache });
+      const transformPipeline = new import_transformer.AsyncTransformPipeline().beforeStep(cacheSteps.beforeTransform).addStep(async (code, args) => {
+        if (options.transformSync) {
+          code = options.transformSync(args.path, code);
+        }
+        if (options.transformAsync) {
+          code = await options.transformAsync(args.path, code);
+        }
+        return { code };
+      }).addStep((0, import_createFullyTransformStep.createFullyTransformStep)({ dev, additionalBabelOptions: babel }), {
+        conditions: babel?.conditions,
+        skipOtherSteps: true
+      }).addStep((0, import_createStripFlowStep.createStripFlowStep)({ dev })).addStep((0, import_createTransformToHermesSyntaxStep.createTransformToHermesSyntaxStep)({ dev, additionalSwcOptions: swc })).afterStep(cacheSteps.afterTransform);
+      preludeScript.registerEntryPointMarker(build);
+      preludeScript.registerPreludeScriptResolver(build);
+      build.onLoad({ filter: sourceRegExp }, async (args) => {
+        let code = await fs.readFile(args.path, "utf-8");
+        if (preludeScript.isEntryPoint(args)) {
+          code = preludeScript.injectPreludeScript(code, {
+            preludeScriptPaths: esbuild?.prelude ?? []
+          });
+        }
+        const result = await import_performance.Performance.withTrace(() => transformPipeline.transform(code, args), {
+          name: "transform",
+          startOptions: { detail: { file: args.path } }
+        });
+        return { contents: result.code, loader: "js" };
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformPlugin
+});

package/dist/bundler/plugins/types.d.ts

@@ -0,0 +1,7 @@
+import type { BundlerConfig, INTERNAL__Id } from '../../types';
+export type PluginOptions<T = object> = T & {
+    context: {
+        id: INTERNAL__Id;
+        config: BundlerConfig;
+    };
+};

package/dist/bundler/plugins/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/bundler/types.d.ts

@@ -0,0 +1,16 @@
+import * as esbuild from 'esbuild';
+import type { BuildConfig } from '..';
+export type BuildResult = esbuild.BuildResult & {
+    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_LOAD_REMOTE_IDENTIFIER = "loadRemote";

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_LOAD_REMOTE_IDENTIFIER: () => INTERNAL_LOAD_REMOTE_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_LOAD_REMOTE_IDENTIFIER = "loadRemote";
+// 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_LOAD_REMOTE_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,10 @@
+export { Bundler } from './bundler';
+export { DevServer } from './server';
+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 * from './utils';
+export type { AdditionalMetroConfig } from './metro/getMetroConfig';
+export type { BuildResult } from './bundler/types';

package/dist/index.js

@@ -0,0 +1,56 @@
+"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,
+  metroBuild: () => import_metro.runBuild
+});
+module.exports = __toCommonJS(index_exports);
+var import_bundler = require("./bundler");
+var import_server = require("./server");
+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);
+__reExport(index_exports, require("./utils"), 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,
+  metroBuild,
+  ...require("./operations"),
+  ...require("./types/schemas"),
+  ...require("./types"),
+  ...require("./utils")
+});

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 };