@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/vendors/metro/src/lib/CountingSet.js

@@ -0,0 +1,98 @@
+"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 CountingSet_exports = {};
+__export(CountingSet_exports, {
+  default: () => CountingSet
+});
+module.exports = __toCommonJS(CountingSet_exports);
+class CountingSet {
+  #map = /* @__PURE__ */ new Map();
+  constructor(items) {
+    if (items) {
+      if (items instanceof CountingSet) {
+        this.#map = new Map(items.#map);
+      } else {
+        for (const item of items) {
+          this.add(item);
+        }
+      }
+    }
+  }
+  has(item) {
+    return this.#map.has(item);
+  }
+  add(item) {
+    const newCount = this.count(item) + 1;
+    this.#map.set(item, newCount);
+  }
+  delete(item) {
+    const newCount = this.count(item) - 1;
+    if (newCount <= 0) {
+      this.#map.delete(item);
+    } else {
+      this.#map.set(item, newCount);
+    }
+  }
+  keys() {
+    return this.#map.keys();
+  }
+  values() {
+    return this.#map.keys();
+  }
+  *entries() {
+    for (const item of this) {
+      yield [item, item];
+    }
+  }
+  // Iterate over unique entries
+  // $FlowIssue[unsupported-syntax]
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  /*::
+  // For Flow's benefit
+  @@iterator(): Iterator<T> {
+    return this.values();
+  }
+  */
+  // Number of unique entries
+  // $FlowIssue[unsafe-getters-setters]
+  get size() {
+    return this.#map.size;
+  }
+  count(item) {
+    return this.#map.get(item) ?? 0;
+  }
+  clear() {
+    this.#map.clear();
+  }
+  forEach(callbackFn, thisArg) {
+    for (const item of this) {
+      callbackFn.call(thisArg, item, item, this);
+    }
+  }
+  // For Jest purposes. Ideally a custom serializer would be enough, but in
+  // practice there is hardcoded magic for Set in toEqual (etc) that we cannot
+  // extend to custom collection classes. Instead let's assume values are
+  // sortable ( = strings) and make this look like an array with some stable
+  // order.
+  toJSON() {
+    return [...this].sort();
+  }
+}

package/dist/vendors/metro/src/lib/JsonReporter.js

@@ -0,0 +1,21 @@
+"use strict";
+class JsonReporter {
+  _stream;
+  constructor(stream) {
+    this._stream = stream;
+  }
+  /**
+   * There is a special case for errors because they have non-enumerable fields.
+   * (Perhaps we should switch in favor of plain object?)
+   */
+  update(event) {
+    if (Object.prototype.toString.call(event.error) === "[object Error]") {
+      event = Object.assign(event, {
+        message: event.error.message,
+        stack: event.error.stack
+      });
+    }
+    this._stream.write(JSON.stringify(event) + "\n");
+  }
+}
+module.exports = JsonReporter;

package/dist/vendors/metro/src/lib/RamBundleParser.js

@@ -0,0 +1,36 @@
+"use strict";
+const MAGIC_NUMBER = require("../shared/output/RamBundle/magic-number");
+const SIZEOF_UINT32 = 4;
+const HEADER_SIZE = 3;
+class RamBundleParser {
+  _buffer;
+  _numModules;
+  _startupCodeLength;
+  _startOffset;
+  // $FlowFixMe[missing-local-annot]
+  constructor(buffer) {
+    this._buffer = buffer;
+    if (this._readPosition(0) !== MAGIC_NUMBER) {
+      throw new Error("File is not a RAM bundle file");
+    }
+    this._numModules = this._readPosition(1);
+    this._startupCodeLength = this._readPosition(2);
+    this._startOffset = (HEADER_SIZE + this._numModules * 2) * SIZEOF_UINT32;
+  }
+  _readPosition(pos) {
+    return this._buffer.readUInt32LE(pos * SIZEOF_UINT32);
+  }
+  getStartupCode() {
+    const start = this._startOffset;
+    const end = start + this._startupCodeLength - 1;
+    return this._buffer.toString("utf8", start, end);
+  }
+  getModule(id) {
+    const moduleOffset = this._readPosition(HEADER_SIZE + id * 2);
+    const moduleLength = this._readPosition(HEADER_SIZE + id * 2 + 1);
+    const start = this._startOffset + moduleOffset;
+    const end = start + moduleLength - 1;
+    return this._buffer.toString("utf8", start, end);
+  }
+}
+module.exports = RamBundleParser;

package/dist/vendors/metro/src/lib/ReportableEvent.d.ts

@@ -0,0 +1,152 @@
+interface BundleDetails {
+  bundleType: string;
+  dev: boolean;
+  entryFile: string;
+  minify: boolean;
+  platform?: string;
+  runtimeBytecodeVersion?: number;
+}
+
+type WatcherStatus =
+| {
+    type: 'watchman_slow_command';
+    timeElapsed: number;
+    command: 'watch-project' | 'query';
+}
+| {
+    type: 'watchman_slow_command_complete';
+    timeElapsed: number;
+    command: 'watch-project' | 'query';
+}
+| {
+    type: 'watchman_warning';
+    warning: unknown;
+    command: 'watch-project' | 'query';
+};
+
+type HealthCheckResult =
+  | {type: 'error'; timeout: number; error: Error; watcher: string | null}
+  | {
+      type: 'success';
+      timeout: number;
+      timeElapsed: number;
+      watcher: string | null;
+    }
+  | {
+      type: 'timeout';
+      timeout: number;
+      watcher: string | null;
+      pauseReason: string | null;
+    };
+
+export type ReportableEvent =
+  | {
+      port: number;
+      hasReducedPerformance: boolean;
+      type: 'initialize_started';
+    }
+  | {
+      type: 'initialize_failed';
+      port: number;
+      error: Error;
+    }
+  | {
+      type: 'initialize_done';
+      port: number;
+    }
+  | {
+      buildID: string;
+      type: 'bundle_build_done';
+    }
+  | {
+      buildID: string;
+      type: 'bundle_build_failed';
+    }
+  | {
+      type: 'bundle_save_log';
+      message: string;
+    }
+  | {
+      buildID: string;
+      bundleDetails: BundleDetails;
+      isPrefetch?: boolean;
+      type: 'bundle_build_started';
+    }
+  | {
+      error: Error;
+      type: 'bundling_error';
+    }
+  | {
+      type: 'dep_graph_loading';
+      hasReducedPerformance: boolean;
+    }
+  | {type: 'dep_graph_loaded'}
+  | {
+      buildID: string;
+      type: 'bundle_transform_progressed';
+      transformedFileCount: number;
+      totalFileCount: number;
+    }
+  | {
+      type: 'cache_read_error';
+      error: Error;
+    }
+  | {
+      type: 'cache_write_error';
+      error: Error;
+    }
+  | {type: 'transform_cache_reset'}
+  | {
+      type: 'worker_stdout_chunk';
+      chunk: string;
+    }
+  | {
+      type: 'worker_stderr_chunk';
+      chunk: string;
+    }
+  | {
+      type: 'hmr_client_error';
+      error: Error;
+    }
+  | {
+      type: 'client_log';
+      level:
+        | 'trace'
+        | 'info'
+        | 'warn'
+        | 'log'
+        | 'group'
+        | 'groupCollapsed'
+        | 'groupEnd'
+        | 'debug';
+      data: Array<unknown>;
+      mode: 'BRIDGE' | 'NOBRIDGE';
+    }
+  | {
+      type: 'resolver_warning';
+      message: string;
+    }
+  | {
+      type: 'server_listening';
+      port: number;
+      address: string;
+      family: string;
+    }
+  | {
+      type: 'transformer_load_started';
+    }
+  | {
+      type: 'transformer_load_done';
+    }
+  | {
+      type: 'transformer_load_failed';
+      error: Error;
+    }
+  | {
+      type: 'watcher_health_check_result';
+      result: HealthCheckResult;
+    }
+  | {
+      type: 'watcher_status';
+      status: WatcherStatus;
+    };

package/dist/vendors/metro/src/lib/TerminalReporter.d.ts

@@ -0,0 +1,18 @@
+import type { ReportableEvent } from "./ReportableEvent";
+type Terminal = any;
+type TerminalReportableEvent =
+  | ReportableEvent
+  | {
+      buildID: string;
+      type: 'bundle_transform_progressed_throttled';
+      transformedFileCount: number;
+      totalFileCount: number;
+    };
+
+declare class TerminalReporter {
+  readonly terminal: Terminal;
+  constructor(terminal: Terminal);
+  update(event: TerminalReportableEvent): void;
+}
+
+export default TerminalReporter;

package/dist/vendors/metro/src/lib/TerminalReporter.js

@@ -0,0 +1,258 @@
+"use strict";
+const logToConsole = require("./logToConsole");
+const reporting = require("./reporting");
+const chalk = require("chalk");
+const throttle = require("lodash.throttle");
+const { AmbiguousModuleResolutionError } = require("../../../metro-core/src");
+const path = require("path");
+const debug = require("debug")("metro");
+const GLOBAL_CACHE_DISABLED_MESSAGE_FORMAT = "The global cache is now disabled because %s";
+const DARK_BLOCK_CHAR = "\u2593";
+const LIGHT_BLOCK_CHAR = "\u2591";
+const MAX_PROGRESS_BAR_CHAR_WIDTH = 16;
+class TerminalReporter {
+  /**
+   * The bundle builds for which we are actively maintaining the status on the
+   * terminal, ie. showing a progress bar. There can be several bundles being
+   * built at the same time.
+   */
+  _activeBundles;
+  _scheduleUpdateBundleProgress;
+  terminal;
+  constructor(terminal) {
+    this._activeBundles = /* @__PURE__ */ new Map();
+    this._scheduleUpdateBundleProgress = throttle((data) => {
+      this.update({ ...data, type: "bundle_transform_progressed_throttled" });
+    }, 100);
+    this.terminal = terminal;
+  }
+  /**
+   * Construct a message that represents the progress of a
+   * single bundle build, for example:
+   *
+   *     BUNDLE path/to/bundle.js ▓▓▓▓▓░░░░░░░░░░░ 36.6% (4790/7922)
+   */
+  _getBundleStatusMessage({ bundleDetails: { entryFile, bundleType, runtimeBytecodeVersion }, transformedFileCount, totalFileCount, ratio }, phase) {
+    if (runtimeBytecodeVersion) {
+      bundleType = "bytecodebundle";
+    }
+    const localPath = path.relative(".", entryFile);
+    const filledBar = Math.floor(ratio * MAX_PROGRESS_BAR_CHAR_WIDTH);
+    const bundleTypeColor = phase === "done" ? chalk.green : phase === "failed" ? chalk.red : chalk.yellow;
+    const progress = phase === "in_progress" ? chalk.green.bgGreen(DARK_BLOCK_CHAR.repeat(filledBar)) + chalk.bgWhite.white(LIGHT_BLOCK_CHAR.repeat(MAX_PROGRESS_BAR_CHAR_WIDTH - filledBar)) + chalk.bold(` ${(100 * ratio).toFixed(1)}% `) + chalk.dim(`(${transformedFileCount}/${totalFileCount})`) : "";
+    return bundleTypeColor.inverse.bold(` ${bundleType.toUpperCase()} `) + chalk.reset.dim(` ${path.dirname(localPath)}/`) + chalk.bold(path.basename(localPath)) + " " + progress + "\n";
+  }
+  _logCacheDisabled(reason) {
+    const format = GLOBAL_CACHE_DISABLED_MESSAGE_FORMAT;
+    switch (reason) {
+      case "too_many_errors":
+        reporting.logWarning(this.terminal, format, "it has been failing too many times.");
+        break;
+      case "too_many_misses":
+        reporting.logWarning(this.terminal, format, "it has been missing too many consecutive keys.");
+        break;
+    }
+  }
+  _logBundleBuildDone(buildID) {
+    const progress = this._activeBundles.get(buildID);
+    if (progress != null) {
+      const msg = this._getBundleStatusMessage(
+        {
+          ...progress,
+          ratio: 1,
+          transformedFileCount: progress.totalFileCount
+        },
+        "done"
+      );
+      this.terminal.log(msg);
+      this._activeBundles.delete(buildID);
+    }
+  }
+  _logBundleBuildFailed(buildID) {
+    const progress = this._activeBundles.get(buildID);
+    if (progress != null) {
+      const msg = this._getBundleStatusMessage(progress, "failed");
+      this.terminal.log(msg);
+    }
+  }
+  _logInitializing(port, hasReducedPerformance) {
+  }
+  _logInitializingFailed(port, error) {
+    if (error.code === "EADDRINUSE") {
+      this.terminal.log(chalk.bgRed.bold(" ERROR "), chalk.red("Metro can't listen on port", chalk.bold(String(port))));
+      this.terminal.log("Most likely another process is already using this port");
+      this.terminal.log("Run the following command to find out which process:");
+      this.terminal.log("\n  ", chalk.bold("lsof -i :" + port), "\n");
+      this.terminal.log("Then, you can either shut down the other process:");
+      this.terminal.log("\n  ", chalk.bold("kill -9 <PID>"), "\n");
+      this.terminal.log("or run Metro on different port.");
+    } else {
+      this.terminal.log(chalk.bgRed.bold(" ERROR "), chalk.red(error.message));
+      const errorAttributes = JSON.stringify(error);
+      if (errorAttributes !== "{}") {
+        this.terminal.log(chalk.red(errorAttributes));
+      }
+      this.terminal.log(chalk.red(error.stack));
+    }
+  }
+  /**
+   * This function is only concerned with logging and should not do state
+   * or terminal status updates.
+   */
+  _log(event) {
+    switch (event.type) {
+      case "initialize_started":
+        this._logInitializing(event.port, event.hasReducedPerformance);
+        break;
+      case "initialize_failed":
+        this._logInitializingFailed(event.port, event.error);
+        break;
+      case "bundle_build_done":
+        this._logBundleBuildDone(event.buildID);
+        break;
+      case "bundle_build_failed":
+        this._logBundleBuildFailed(event.buildID);
+        break;
+      case "bundling_error":
+        this._logBundlingError(event.error);
+        break;
+      case "global_cache_disabled":
+        this._logCacheDisabled(event.reason);
+        break;
+      case "transform_cache_reset":
+        debug("the transform cache was reset.");
+        break;
+      case "worker_stdout_chunk":
+        this._logWorkerChunk("stdout", event.chunk);
+        break;
+      case "worker_stderr_chunk":
+        this._logWorkerChunk("stderr", event.chunk);
+        break;
+      case "hmr_client_error":
+        this._logHmrClientError(event.error);
+        break;
+      case "client_log":
+        logToConsole(this.terminal, event.level, event.mode, ...event.data);
+        break;
+      case "dep_graph_loading":
+        if (event.hasReducedPerformance) {
+          this.terminal.log(
+            chalk.red(
+              "Metro is operating with reduced performance.\nPlease fix the problem above and restart Metro.\n\n"
+            )
+          );
+        }
+        break;
+    }
+  }
+  /**
+   * We do not want to log the whole stacktrace for bundling error, because
+   * these are operational errors, not programming errors, and the stacktrace
+   * is not actionable to end users.
+   */
+  _logBundlingError(error) {
+    if (error instanceof AmbiguousModuleResolutionError) {
+      const he = error.hasteError;
+      const message2 = `ambiguous resolution: module \`${error.fromModulePath}\` tries to require \`${he.hasteName}\`, but there are several files providing this module. You can delete or fix them: 
+
+` + Object.keys(he.duplicatesSet).sort().map((dupFilePath) => `  * \`${dupFilePath}\`
+`).join("");
+      reporting.logError(this.terminal, message2);
+      return;
+    }
+    let { message } = error;
+    if (!(error instanceof SyntaxError)) {
+      if (error.snippet == null && error.stack != null) {
+        message = error.stack;
+      }
+    }
+    if (error.filename && !message.includes(error.filename)) {
+      message += ` [${error.filename}]`;
+    }
+    if (error.snippet != null) {
+      message += "\n" + error.snippet;
+    }
+    reporting.logError(this.terminal, message);
+  }
+  _logWorkerChunk(origin, chunk) {
+    const lines = chunk.split("\n");
+    if (lines.length >= 1 && lines[lines.length - 1] === "") {
+      lines.splice(lines.length - 1, 1);
+    }
+    lines.forEach((line) => {
+      this.terminal.log(`transform[${origin}]: ${line}`);
+    });
+  }
+  /**
+   * We use Math.pow(ratio, 2) to as a conservative measure of progress because
+   * we know the `totalCount` is going to progressively increase as well. We
+   * also prevent the ratio from going backwards.
+   */
+  _updateBundleProgress({ buildID, transformedFileCount, totalFileCount }) {
+    const currentProgress = this._activeBundles.get(buildID);
+    if (currentProgress == null) {
+      return;
+    }
+    const rawRatio = transformedFileCount / totalFileCount;
+    const conservativeRatio = Math.pow(rawRatio, 2);
+    const ratio = Math.max(conservativeRatio, currentProgress.ratio);
+    Object.assign(currentProgress, {
+      ratio,
+      transformedFileCount,
+      totalFileCount
+    });
+  }
+  /**
+   * This function is exclusively concerned with updating the internal state.
+   * No logging or status updates should be done at this point.
+   */
+  _updateState(event) {
+    switch (event.type) {
+      case "bundle_build_done":
+      case "bundle_build_failed":
+        this._activeBundles.delete(event.buildID);
+        break;
+      case "bundle_build_started":
+        const bundleProgress = {
+          bundleDetails: event.bundleDetails,
+          transformedFileCount: 0,
+          totalFileCount: 1,
+          ratio: 0
+        };
+        this._activeBundles.set(event.buildID, bundleProgress);
+        break;
+      case "bundle_transform_progressed_throttled":
+        this._updateBundleProgress(event);
+        break;
+    }
+  }
+  /**
+   * Return a status message that is always consistent with the current state
+   * of the application. Having this single function ensures we don't have
+   * different callsites overriding each other status messages.
+   */
+  _getStatusMessage() {
+    return Array.from(this._activeBundles.entries()).map(([_, progress]) => this._getBundleStatusMessage(progress, "in_progress")).filter((str) => str != null).join("\n");
+  }
+  _logHmrClientError(e) {
+    reporting.logError(
+      this.terminal,
+      "A WebSocket client got a connection error. Please reload your device to get HMR working again: %s",
+      e
+    );
+  }
+  /**
+   * Single entry point for reporting events. That allows us to implement the
+   * corresponding JSON reporter easily and have a consistent repor∏ting.
+   */
+  update(event) {
+    if (event.type === "bundle_transform_progressed") {
+      this._scheduleUpdateBundleProgress(event);
+      return;
+    }
+    this._log(event);
+    this._updateState(event);
+    this.terminal.status(this._getStatusMessage());
+  }
+}
+module.exports = TerminalReporter;

package/dist/vendors/metro/src/lib/bundleToBytecode.js

@@ -0,0 +1,40 @@
+"use strict";
+const MAGIC_NUMBER = 4293379011;
+function getFileHeader(moduleCount) {
+  const buffer = Buffer.alloc(8);
+  buffer.writeUInt32LE(MAGIC_NUMBER, 0);
+  buffer.writeUInt32LE(moduleCount, 4);
+  return buffer;
+}
+function addModuleHeader(buffer) {
+  const { getFileLength } = require("metro-hermes-compiler");
+  const fileLength = getFileLength(buffer, 0);
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(fileLength, 0);
+  return [header, buffer];
+}
+function bundleToBytecode(bundle) {
+  const buffers = [];
+  if (bundle.pre.length) {
+    buffers.push(...bundle.pre);
+  }
+  const modules = [];
+  const sortedModules = bundle.modules.slice().sort((a, b) => a[0] - b[0]);
+  for (const [id, bytecodeBundle] of sortedModules) {
+    buffers.push(...bytecodeBundle);
+    modules.push([id, bytecodeBundle[bytecodeBundle.length - 1].length]);
+  }
+  if (bundle.post.length) {
+    buffers.push(...bundle.post);
+  }
+  return {
+    bytecode: Buffer.concat([getFileHeader(buffers.length), ...buffers.flatMap(addModuleHeader)]),
+    metadata: {
+      pre: bundle.pre ? bundle.pre.length : 0,
+      post: bundle.post.length,
+      modules
+    }
+  };
+}
+module.exports = bundleToBytecode;
+module.exports.MAGIC_NUMBER = MAGIC_NUMBER;

package/dist/vendors/metro/src/lib/bundleToString.js

@@ -0,0 +1,22 @@
+"use strict";
+function bundleToString(bundle) {
+  let code = bundle.pre.length > 0 ? bundle.pre + "\n" : "";
+  const modules = [];
+  const sortedModules = bundle.modules.slice().sort((a, b) => a[0] - b[0]);
+  for (const [id, moduleCode] of sortedModules) {
+    if (moduleCode.length > 0) {
+      code += moduleCode + "\n";
+    }
+    modules.push([id, moduleCode.length]);
+  }
+  if (bundle.post.length > 0) {
+    code += bundle.post;
+  } else {
+    code = code.slice(0, -1);
+  }
+  return {
+    code,
+    metadata: { pre: bundle.pre.length, post: bundle.post.length, modules }
+  };
+}
+module.exports = bundleToString;