@granite-js/mpack 0.0.1

package/dist/operations/runServer.d.ts

@@ -0,0 +1,15 @@
+import type { HandleFunction } from 'connect';
+import { Config } from '..';
+import { type AdditionalMetroConfig } from '../metro/getMetroConfig';
+interface RunServerConfig {
+    host?: string;
+    port?: number;
+    middlewares?: HandleFunction[];
+    enableEmbeddedReactDevTools?: boolean;
+    onServerReady?: () => Promise<void> | void;
+    cwd?: string;
+    config?: Config;
+    additionalConfig?: AdditionalMetroConfig;
+}
+export declare function runServer({ host, port, middlewares, enableEmbeddedReactDevTools, onServerReady, cwd, config: $config, additionalConfig, }: RunServerConfig): Promise<void>;
+export {};

package/dist/operations/runServer.js

@@ -0,0 +1,134 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runServer_exports = {};
+__export(runServer_exports, {
+  runServer: () => runServer
+});
+module.exports = __toCommonJS(runServer_exports);
+var import_cli_server_api = require("@react-native-community/cli-server-api");
+var import_debug = __toESM(require("debug"));
+var import_backend = require("react-native-devtools-standalone/backend");
+var import_createDebuggerMiddleware = require("./createDebuggerMiddleware");
+var import_constants = require("../constants");
+var import_getMetroConfig = require("../metro/getMetroConfig");
+var import_loadConfig = require("../utils/loadConfig");
+var import_printLogo = require("../utils/printLogo");
+var import_vendors = require("../vendors");
+const debug = (0, import_debug.default)("cli:start");
+const { Metro, TerminalReporter } = (0, import_vendors.getModule)("metro");
+const { Terminal } = (0, import_vendors.getModule)("metro-core");
+const { mergeConfig } = (0, import_vendors.getModule)("metro-config");
+async function runServer({
+  host,
+  port = import_constants.DEV_SERVER_DEFAULT_PORT,
+  middlewares = [],
+  enableEmbeddedReactDevTools = true,
+  onServerReady,
+  cwd = process.cwd(),
+  config: $config,
+  additionalConfig
+}) {
+  const config = $config ?? await (0, import_loadConfig.loadConfig)({ rootDir: cwd });
+  const ref = {};
+  const terminal = new Terminal(process.stdout);
+  const terminalReporter = new TerminalReporter(terminal);
+  const reporter = {
+    async update(event) {
+      debug("Reporter event", event);
+      terminalReporter.update(event);
+      ref.reportEvent?.(event);
+      switch (event.type) {
+        case "initialize_started":
+          (0, import_printLogo.printLogo)();
+          break;
+        case "initialize_done":
+          enableStdinWatchMode();
+          await onServerReady?.();
+          break;
+        default:
+          break;
+      }
+    }
+  };
+  const baseConfig = await (0, import_getMetroConfig.getMetroConfig)(
+    { rootPath: cwd, appName: config?.appName ?? "", scheme: config?.scheme ?? "" },
+    additionalConfig
+  );
+  const metroConfig = mergeConfig(baseConfig, {
+    server: { port },
+    reporter
+  });
+  const { middleware, websocketEndpoints, messageSocketEndpoint, eventsSocketEndpoint } = (0, import_cli_server_api.createDevServerMiddleware)({
+    host,
+    port,
+    watchFolders: metroConfig.watchFolders
+  });
+  const { middleware: debuggerMiddleware, enableStdinWatchMode } = (0, import_createDebuggerMiddleware.createDebuggerMiddleware)({
+    host,
+    port,
+    broadcastMessage: messageSocketEndpoint.broadcast
+  });
+  middleware.use(debuggerMiddleware);
+  middleware.use(import_cli_server_api.indexPageMiddleware);
+  const customEnhanceMiddleware = metroConfig.server.enhanceMiddleware;
+  metroConfig.server.enhanceMiddleware = (metroMiddleware, server) => {
+    if (customEnhanceMiddleware) {
+      metroMiddleware = customEnhanceMiddleware(metroMiddleware, server);
+    }
+    for (const item of middlewares) {
+      middleware.use(item);
+    }
+    return middleware.use(metroMiddleware);
+  };
+  if (enableEmbeddedReactDevTools) {
+    await (0, import_backend.setupDevToolsProxy)({
+      client: {
+        delegate: {
+          onError: (error) => console.error("React DevTools client error", error)
+        }
+      },
+      devtools: {
+        delegate: {
+          onError: (error) => console.error("React DevTools frontend error", error)
+        }
+      }
+    });
+  }
+  ref.reportEvent = eventsSocketEndpoint.reportEvent;
+  ref.enableStdinWatchMode = enableStdinWatchMode;
+  const serverInstance = await Metro.runServer(metroConfig, {
+    host,
+    websocketEndpoints
+  });
+  serverInstance.keepAliveTimeout = 3e4;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runServer
+});

package/dist/performance/Performance.d.ts

@@ -0,0 +1,23 @@
+import { type PerformanceMeasure, type MarkOptions } from 'perf_hooks';
+export interface PerfStatic {
+    trace: (name: string, options?: MarkOptions) => Perf;
+    withTrace: <T>(task: () => T | Promise<T>, config: {
+        name: string;
+        startOptions?: MarkOptions;
+        stopOptions?: (result: Awaited<T>) => MarkOptions;
+    }) => Promise<T>;
+    getSummary: () => Record<string, {
+        averageDuration: number;
+        records: PerfResult[];
+    }> | null;
+}
+export interface Perf {
+    stop: (options?: MarkOptions) => void;
+}
+export interface PerfResult {
+    sequence: number;
+    startTime: number;
+    duration: number;
+    detail?: PerformanceMeasure['detail'];
+}
+export declare const Performance: PerfStatic;

package/dist/performance/Performance.js

@@ -0,0 +1,121 @@
+"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 Performance_exports = {};
+__export(Performance_exports, {
+  Performance: () => Performance
+});
+module.exports = __toCommonJS(Performance_exports);
+var import_perf_hooks = require("perf_hooks");
+var import_es_toolkit = require("es-toolkit");
+var TracePhase = /* @__PURE__ */ ((TracePhase2) => {
+  TracePhase2["Start"] = "start";
+  TracePhase2["End"] = "end";
+  TracePhase2["Measure"] = "measure";
+  return TracePhase2;
+})(TracePhase || {});
+const sequences = {};
+const records = {};
+function getName(name, phase, sequence) {
+  return `${name}.${phase}#${sequence}`;
+}
+function parseName(name) {
+  const [traceName] = name.split(".");
+  return traceName ?? "";
+}
+const PerformanceImpl = {
+  trace(name, options) {
+    const sequence = typeof sequences[name] === "number" ? ++sequences[name] : sequences[name] = 0;
+    const startName = getName(name, "start" /* Start */, sequence);
+    const endName = getName(name, "end" /* End */, sequence);
+    const measureName = getName(name, "measure" /* Measure */, sequence);
+    const startMark = import_perf_hooks.performance.mark(startName, options);
+    return {
+      stop: (options2) => {
+        const endMark = import_perf_hooks.performance.mark(endName, options2);
+        const measureResult = import_perf_hooks.performance.measure(measureName, startName, endName);
+        records[measureName] = {
+          sequence,
+          duration: measureResult.duration,
+          name: measureResult.name,
+          startTime: measureResult.startTime,
+          detail: {
+            ...startMark.detail ?? {},
+            ...endMark.detail ?? {}
+          }
+        };
+        import_perf_hooks.performance.clearMarks(startName);
+        import_perf_hooks.performance.clearMarks(endName);
+        import_perf_hooks.performance.clearMeasures(measureName);
+      }
+    };
+  },
+  async withTrace(task, config) {
+    const trace = PerformanceImpl.trace(config.name, config.startOptions);
+    try {
+      const result = await task();
+      const stopMarkOptions = config.stopOptions?.(result);
+      trace.stop(stopMarkOptions);
+      return result;
+    } catch (error) {
+      trace.stop({ detail: { error } });
+      throw error;
+    }
+  },
+  getSummary() {
+    const results = {};
+    Object.entries(records).map(([measureName, performanceMeasure]) => {
+      const name = parseName(measureName);
+      const result = {
+        sequence: performanceMeasure.sequence,
+        startTime: performanceMeasure.startTime,
+        duration: performanceMeasure.duration,
+        ...Object.keys(performanceMeasure.detail).length > 0 ? { detail: performanceMeasure.detail } : null
+      };
+      if (results[name] === void 0) {
+        results[name] = { averageDuration: 0, records: [result] };
+      } else {
+        results[name].records.push(result);
+      }
+    });
+    Object.values(results).forEach((result) => {
+      result.averageDuration = result.records.reduce((acc, curr) => acc + curr.duration, 0) / result.records.length;
+    });
+    return results;
+  }
+};
+const PerformanceShim = {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  trace(_name) {
+    return { stop: import_es_toolkit.noop };
+  },
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async withTrace(task, _config) {
+    const result = await task();
+    return result;
+  },
+  getSummary() {
+    return null;
+  }
+};
+const perfTraceEnabled = process.env.MPACK_TRACE === "1";
+const Performance = perfTraceEnabled ? PerformanceImpl : PerformanceShim;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Performance
+});

package/dist/performance/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Performance';
+export { printSummary } from './printSummary';

package/dist/performance/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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var performance_exports = {};
+__export(performance_exports, {
+  printSummary: () => import_printSummary.printSummary
+});
+module.exports = __toCommonJS(performance_exports);
+__reExport(performance_exports, require("./Performance"), module.exports);
+var import_printSummary = require("./printSummary");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  printSummary,
+  ...require("./Performance")
+});

package/dist/performance/printSummary.d.ts

@@ -0,0 +1,5 @@
+import { PerfStatic } from './Performance';
+export interface PrintSummaryOptions {
+    limit?: number;
+}
+export declare function printSummary(summary: NonNullable<ReturnType<PerfStatic['getSummary']>>, options?: PrintSummaryOptions): void;

package/dist/performance/printSummary.js

@@ -0,0 +1,58 @@
+"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 printSummary_exports = {};
+__export(printSummary_exports, {
+  printSummary: () => printSummary
+});
+module.exports = __toCommonJS(printSummary_exports);
+var import_chalk = __toESM(require("chalk"));
+function printSummary(summary, options) {
+  const { limit = 30 } = options ?? {};
+  Object.entries(summary).forEach(([category, result]) => {
+    const records = result.records.sort((a, b) => b.duration - a.duration).slice(0, limit);
+    console.log(
+      `\u256D\u2500 Performance mark: ${import_chalk.default.blue.bold(category)} ${import_chalk.default.gray(`(Average duration: ${normalizeDuration(result.averageDuration)}ms)`)}`
+    );
+    records.forEach(({ sequence, duration, detail }, index) => {
+      console.log(`\u2502 ${import_chalk.default.cyan(`Record #${index + 1}`)} (Duration: ${normalizeDuration(duration)}ms)`);
+      Object.entries(detail ?? {}).forEach(([key, value]) => {
+        console.log(`\u2502 \u251C\u2500 ${import_chalk.default.gray(`${key}: ${value}`)}`);
+      });
+      console.log(`\u2502 \u2570\u2500 Sequence: ${sequence}`);
+    });
+    console.log(`\u2570\u2500 Total records: ${result.records.length}`);
+  });
+}
+function normalizeDuration(duration) {
+  return duration.toFixed(8);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  printSummary
+});

package/dist/plugins/index.d.ts

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

package/dist/plugins/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 plugins_exports = {};
+module.exports = __toCommonJS(plugins_exports);
+__reExport(plugins_exports, require("./statusPlugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./statusPlugin")
+});

package/dist/plugins/statusPlugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin, PluginHandlers } from '../types';
+export declare function statusPlugin(handlers?: PluginHandlers): Plugin;

package/dist/plugins/statusPlugin.js

@@ -0,0 +1,64 @@
+"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 statusPlugin_exports = {};
+__export(statusPlugin_exports, {
+  statusPlugin: () => statusPlugin
+});
+module.exports = __toCommonJS(statusPlugin_exports);
+var import_es_toolkit = require("es-toolkit");
+var import_PersistentStorage = require("../shared/PersistentStorage");
+var import_printSummary = require("../utils/printSummary");
+var import_progressBar = require("../utils/progressBar");
+function statusPlugin(handlers) {
+  let progressBar;
+  let totalModuleCount;
+  return {
+    name: "dev-server-status-plugin",
+    prepare(config) {
+      if (progressBar != null) {
+        return;
+      }
+      progressBar = (0, import_progressBar.createProgressBar)(`${config.appName}:${config.buildConfig.platform}`);
+      totalModuleCount = import_PersistentStorage.persistentStorage.getData()[this.id]?.totalModuleCount;
+    },
+    buildStart() {
+      progressBar?.start(0, totalModuleCount ?? 1);
+      handlers?.onStart?.();
+    },
+    buildEnd(result) {
+      progressBar.update(result.totalModuleCount);
+      progressBar.hide();
+      progressBar.remove();
+      if (result.errors.length === 0) {
+        totalModuleCount = result.totalModuleCount;
+        import_PersistentStorage.persistentStorage.setData({ [this.id]: { totalModuleCount: result.totalModuleCount } });
+        import_PersistentStorage.persistentStorage.saveData();
+        handlers?.onEnd?.();
+      }
+      (0, import_es_toolkit.delay)(100).then(() => (0, import_printSummary.printSummary)(result));
+    },
+    load: (moduleCount) => {
+      progressBar.update(moduleCount, totalModuleCount);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  statusPlugin
+});

package/dist/server/DevServer.d.ts

@@ -0,0 +1,23 @@
+import type { BroadcastCommand, DevServerOptions } from './types';
+import { InspectorProxy } from '../vendors/@react-native/dev-middleware';
+export declare class DevServer {
+    private devServerOptions;
+    host: string;
+    port: number;
+    private app;
+    private context;
+    private inspectorProxy?;
+    private wssDelegate?;
+    constructor(devServerOptions: DevServerOptions);
+    initialize(): Promise<void>;
+    listen(): Promise<void>;
+    close(): Promise<undefined>;
+    getInspectorProxy(): InspectorProxy | undefined;
+    getBaseUrl(): string;
+    broadcastCommand(command: BroadcastCommand): void;
+    private getContext;
+    private setup;
+    private setCommonHeaders;
+    private createDevServerContext;
+    private getBundle;
+}