@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/vendors/metro/src/DeltaBundler/types.flow.js

@@ -0,0 +1,24 @@
+"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 __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 import_CountingSet = __toESM(require("../lib/CountingSet"));

package/dist/vendors/metro/src/DeltaBundler.js

@@ -0,0 +1,56 @@
+"use strict";
+const DeltaCalculator = require("./DeltaBundler/DeltaCalculator");
+class DeltaBundler {
+  _changeEventSource;
+  _deltaCalculators = /* @__PURE__ */ new Map();
+  constructor(changeEventSource) {
+    this._changeEventSource = changeEventSource;
+  }
+  end() {
+    this._deltaCalculators.forEach((deltaCalculator) => deltaCalculator.end());
+    this._deltaCalculators = /* @__PURE__ */ new Map();
+  }
+  async getDependencies(entryPoints, options) {
+    const deltaCalculator = new DeltaCalculator(new Set(entryPoints), this._changeEventSource, options);
+    await deltaCalculator.getDelta({ reset: true, shallow: options.shallow });
+    const graph = deltaCalculator.getGraph();
+    deltaCalculator.end();
+    return graph.dependencies;
+  }
+  // Note: the graph returned by this function needs to be ended when finished
+  // so that we don't leak graphs that are not reachable.
+  // To get just the dependencies, use getDependencies which will not leak graphs.
+  async buildGraph(entryPoints, options) {
+    const deltaCalculator = new DeltaCalculator(new Set(entryPoints), this._changeEventSource, options);
+    await deltaCalculator.getDelta({ reset: true, shallow: options.shallow });
+    const graph = deltaCalculator.getGraph();
+    this._deltaCalculators.set(graph, deltaCalculator);
+    return graph;
+  }
+  async getDelta(graph, { reset, shallow }) {
+    const deltaCalculator = this._deltaCalculators.get(graph);
+    if (!deltaCalculator) {
+      throw new Error("Graph not found");
+    }
+    return await deltaCalculator.getDelta({ reset, shallow });
+  }
+  listen(graph, callback) {
+    const deltaCalculator = this._deltaCalculators.get(graph);
+    if (!deltaCalculator) {
+      throw new Error("Graph not found");
+    }
+    deltaCalculator.on("change", callback);
+    return () => {
+      deltaCalculator.removeListener("change", callback);
+    };
+  }
+  endGraph(graph) {
+    const deltaCalculator = this._deltaCalculators.get(graph);
+    if (!deltaCalculator) {
+      throw new Error("Graph not found");
+    }
+    deltaCalculator.end();
+    this._deltaCalculators.delete(graph);
+  }
+}
+module.exports = DeltaBundler;

package/dist/vendors/metro/src/HmrServer.js

@@ -0,0 +1,224 @@
+"use strict";
+const hmrJSBundle = require("./DeltaBundler/Serializers/hmrJSBundle");
+const GraphNotFoundError = require("./IncrementalBundler/GraphNotFoundError");
+const RevisionNotFoundError = require("./IncrementalBundler/RevisionNotFoundError");
+const debounceAsyncQueue = require("./lib/debounceAsyncQueue");
+const formatBundlingError = require("./lib/formatBundlingError");
+const getGraphId = require("./lib/getGraphId");
+const parseOptionsFromUrl = require("./lib/parseOptionsFromUrl");
+const splitBundleOptions = require("./lib/splitBundleOptions");
+const transformHelpers = require("./lib/transformHelpers");
+const {
+  Logger: { createActionStartEntry, createActionEndEntry, log }
+} = require("../../metro-core/src");
+const nullthrows = require("nullthrows");
+const url = require("url");
+function getBytecodeVersion() {
+  return require("metro-hermes-compiler").VERSION;
+}
+function send(sendFns, message) {
+  const strMessage = JSON.stringify(message);
+  sendFns.forEach((sendFn) => sendFn(strMessage));
+}
+class HmrServer {
+  _config;
+  _bundler;
+  _createModuleId;
+  _clientGroups;
+  constructor(bundler, createModuleId, config) {
+    this._config = config;
+    this._bundler = bundler;
+    this._createModuleId = createModuleId;
+    this._clientGroups = /* @__PURE__ */ new Map();
+  }
+  onClientConnect = async (requestUrl, sendFn) => {
+    return {
+      sendFn,
+      revisionIds: [],
+      optedIntoHMR: false
+    };
+  };
+  async _registerEntryPoint(client, requestUrl, sendFn) {
+    requestUrl = this._config.server.rewriteRequestUrl(requestUrl);
+    const clientUrl = nullthrows(url.parse(requestUrl, true));
+    const options = parseOptionsFromUrl(requestUrl, new Set(this._config.resolver.platforms), getBytecodeVersion());
+    const { entryFile, resolverOptions, transformOptions, graphOptions } = splitBundleOptions(options);
+    const resolutionFn = await transformHelpers.getResolveDependencyFn(
+      this._bundler.getBundler(),
+      transformOptions.platform,
+      resolverOptions
+    );
+    const resolvedEntryFilePath = resolutionFn(
+      (this._config.server.unstable_serverRoot ?? this._config.projectRoot) + "/.",
+      entryFile
+    );
+    const graphId = getGraphId(resolvedEntryFilePath, transformOptions, {
+      resolverOptions,
+      shallow: graphOptions.shallow,
+      experimentalImportBundleSupport: this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext: this._config.transformer.unstable_allowRequireContext
+    });
+    const revPromise = this._bundler.getRevisionByGraphId(graphId);
+    if (!revPromise) {
+      send([sendFn], {
+        type: "error",
+        body: formatBundlingError(new GraphNotFoundError(graphId))
+      });
+      return;
+    }
+    const { graph, id } = await revPromise;
+    client.revisionIds.push(id);
+    let clientGroup = this._clientGroups.get(id);
+    if (clientGroup != null) {
+      clientGroup.clients.add(client);
+    } else {
+      clientUrl.protocol = "http";
+      const { dev, minify, runModule, bundleEntry: _bundleEntry, ...query } = clientUrl.query || {};
+      clientUrl.query = {
+        ...query,
+        dev: dev || "true",
+        minify: minify || "false",
+        modulesOnly: "true",
+        runModule: runModule || "false",
+        shallow: "true"
+      };
+      clientUrl.search = "";
+      clientGroup = {
+        clients: /* @__PURE__ */ new Set([client]),
+        clientUrl,
+        revisionId: id,
+        unlisten: () => unlisten()
+      };
+      this._clientGroups.set(id, clientGroup);
+      const unlisten = this._bundler.getDeltaBundler().listen(
+        graph,
+        debounceAsyncQueue(
+          // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+          this._handleFileChange.bind(this, clientGroup, {
+            isInitialUpdate: false
+          }),
+          50
+        )
+      );
+    }
+    await this._handleFileChange(clientGroup, { isInitialUpdate: true });
+    send([sendFn], { type: "bundle-registered" });
+  }
+  onClientMessage = async (client, message, sendFn) => {
+    let data;
+    try {
+      data = JSON.parse(message);
+    } catch (error) {
+      send([sendFn], {
+        type: "error",
+        body: formatBundlingError(error)
+      });
+      return Promise.resolve();
+    }
+    if (data && data.type) {
+      switch (data.type) {
+        case "register-entrypoints":
+          return Promise.all(
+            data.entryPoints.map((entryPoint) => this._registerEntryPoint(client, entryPoint, sendFn))
+          );
+        case "log":
+          this._config.reporter.update({
+            type: "client_log",
+            level: data.level,
+            data: data.data,
+            mode: data.mode
+          });
+          break;
+        case "log-opt-in":
+          client.optedIntoHMR = true;
+          break;
+        default:
+          break;
+      }
+    }
+    return Promise.resolve();
+  };
+  onClientError = (client, e) => {
+    this._config.reporter.update({
+      type: "hmr_client_error",
+      error: e.error
+    });
+    this.onClientDisconnect(client);
+  };
+  onClientDisconnect = (client) => {
+    client.revisionIds.forEach((revisionId) => {
+      const group = this._clientGroups.get(revisionId);
+      if (group != null) {
+        if (group.clients.size === 1) {
+          this._clientGroups.delete(revisionId);
+          group.unlisten();
+        } else {
+          group.clients.delete(client);
+        }
+      }
+    });
+  };
+  async _handleFileChange(group, options) {
+    const optedIntoHMR = [...group.clients].some((client) => client.optedIntoHMR);
+    const processingHmrChange = log(
+      createActionStartEntry({
+        // Even when HMR is disabled on the client, this function still
+        // runs so we can stash updates while it's off and apply them later.
+        // However, this would mess up our internal analytics because we track
+        // HMR as being used even for people who have it disabled.
+        // As a workaround, we use a different event name for clients
+        // that didn't explicitly opt into HMR.
+        action_name: optedIntoHMR ? "Processing HMR change" : "Processing HMR change (no client opt-in)"
+      })
+    );
+    const sendFns = [...group.clients].map((client) => client.sendFn);
+    send(sendFns, {
+      type: "update-start",
+      body: options
+    });
+    const message = await this._prepareMessage(group, options);
+    send(sendFns, message);
+    send(sendFns, { type: "update-done" });
+    log({
+      ...createActionEndEntry(processingHmrChange),
+      outdated_modules: message.type === "update" ? message.body.added.length + message.body.modified.length : void 0
+    });
+  }
+  async _prepareMessage(group, options) {
+    try {
+      const revPromise = this._bundler.getRevision(group.revisionId);
+      if (!revPromise) {
+        return {
+          type: "error",
+          body: formatBundlingError(new RevisionNotFoundError(group.revisionId))
+        };
+      }
+      const { revision, delta } = await this._bundler.updateGraph(await revPromise, false);
+      this._clientGroups.delete(group.revisionId);
+      group.revisionId = revision.id;
+      for (const client of group.clients) {
+        client.revisionIds = client.revisionIds.filter((revisionId) => revisionId !== group.revisionId);
+        client.revisionIds.push(revision.id);
+      }
+      this._clientGroups.set(group.revisionId, group);
+      const hmrUpdate = hmrJSBundle(delta, revision.graph, {
+        createModuleId: this._createModuleId,
+        projectRoot: this._config.server.unstable_serverRoot ?? this._config.projectRoot,
+        clientUrl: group.clientUrl
+      });
+      return {
+        type: "update",
+        body: {
+          revisionId: revision.id,
+          isInitialUpdate: options.isInitialUpdate,
+          ...hmrUpdate
+        }
+      };
+    } catch (error) {
+      const formattedError = formatBundlingError(error);
+      this._config.reporter.update({ type: "bundling_error", error });
+      return { type: "error", body: formattedError };
+    }
+  }
+}
+module.exports = HmrServer;

package/dist/vendors/metro/src/IncrementalBundler/GraphNotFoundError.js

@@ -0,0 +1,9 @@
+"use strict";
+class GraphNotFoundError extends Error {
+  graphId;
+  constructor(graphId) {
+    super(`The graph \`${graphId}\` was not found.`);
+    this.graphId = graphId;
+  }
+}
+module.exports = GraphNotFoundError;

package/dist/vendors/metro/src/IncrementalBundler/ResourceNotFoundError.js

@@ -0,0 +1,9 @@
+"use strict";
+class ResourceNotFoundError extends Error {
+  resourcePath;
+  constructor(resourcePath) {
+    super(`The resource \`${resourcePath}\` was not found.`);
+    this.resourcePath = resourcePath;
+  }
+}
+module.exports = ResourceNotFoundError;

package/dist/vendors/metro/src/IncrementalBundler/RevisionNotFoundError.js

@@ -0,0 +1,9 @@
+"use strict";
+class RevisionNotFoundError extends Error {
+  revisionId;
+  constructor(revisionId) {
+    super(`The revision \`${revisionId}\` was not found.`);
+    this.revisionId = revisionId;
+  }
+}
+module.exports = RevisionNotFoundError;

package/dist/vendors/metro/src/IncrementalBundler.js

@@ -0,0 +1,213 @@
+"use strict";
+const Bundler = require("./Bundler");
+const DeltaBundler = require("./DeltaBundler");
+const ResourceNotFoundError = require("./IncrementalBundler/ResourceNotFoundError");
+const getGraphId = require("./lib/getGraphId");
+const getPrependedScripts = require("./lib/getPrependedScripts");
+const transformHelpers = require("./lib/transformHelpers");
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+function createRevisionId() {
+  return crypto.randomBytes(8).toString("hex");
+}
+function revisionIdFromString(str) {
+  return str;
+}
+class IncrementalBundler {
+  _config;
+  _bundler;
+  _deltaBundler;
+  _revisionsById = /* @__PURE__ */ new Map();
+  _revisionsByGraphId = /* @__PURE__ */ new Map();
+  static revisionIdFromString = revisionIdFromString;
+  constructor(config, options) {
+    this._config = config;
+    this._bundler = new Bundler(config, options);
+    this._deltaBundler = new DeltaBundler(this._bundler.getWatcher());
+  }
+  end() {
+    this._deltaBundler.end();
+    this._bundler.end();
+  }
+  getBundler() {
+    return this._bundler;
+  }
+  getDeltaBundler() {
+    return this._deltaBundler;
+  }
+  getRevision(revisionId) {
+    return this._revisionsById.get(revisionId);
+  }
+  getRevisionByGraphId(graphId) {
+    return this._revisionsByGraphId.get(graphId);
+  }
+  async buildGraphForEntries(entryFiles, transformOptions, resolverOptions, otherOptions = {
+    onProgress: null,
+    shallow: false
+  }) {
+    const absoluteEntryFiles = await this._getAbsoluteEntryFiles(entryFiles);
+    const graph = await this._deltaBundler.buildGraph(absoluteEntryFiles, {
+      resolve: await transformHelpers.getResolveDependencyFn(this._bundler, transformOptions.platform, resolverOptions),
+      transform: await transformHelpers.getTransformFn(
+        absoluteEntryFiles,
+        this._bundler,
+        this._deltaBundler,
+        this._config,
+        transformOptions,
+        resolverOptions
+      ),
+      transformOptions,
+      onProgress: otherOptions.onProgress,
+      experimentalImportBundleSupport: this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext: this._config.transformer.unstable_allowRequireContext,
+      shallow: otherOptions.shallow
+    });
+    this._config.serializer.experimentalSerializerHook(graph, {
+      added: graph.dependencies,
+      modified: /* @__PURE__ */ new Map(),
+      deleted: /* @__PURE__ */ new Set(),
+      reset: true
+    });
+    return graph;
+  }
+  async getDependencies(entryFiles, transformOptions, resolverOptions, otherOptions = {
+    onProgress: null,
+    shallow: false
+  }) {
+    const absoluteEntryFiles = await this._getAbsoluteEntryFiles(entryFiles);
+    const dependencies = await this._deltaBundler.getDependencies(absoluteEntryFiles, {
+      resolve: await transformHelpers.getResolveDependencyFn(this._bundler, transformOptions.platform, resolverOptions),
+      transform: await transformHelpers.getTransformFn(
+        absoluteEntryFiles,
+        this._bundler,
+        this._deltaBundler,
+        this._config,
+        transformOptions,
+        resolverOptions
+      ),
+      transformOptions,
+      onProgress: otherOptions.onProgress,
+      experimentalImportBundleSupport: this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext: this._config.transformer.unstable_allowRequireContext,
+      shallow: otherOptions.shallow
+    });
+    return dependencies;
+  }
+  async buildGraph(entryFile, transformOptions, resolverOptions, otherOptions = {
+    onProgress: null,
+    shallow: false
+  }) {
+    const graph = await this.buildGraphForEntries([entryFile], transformOptions, resolverOptions, otherOptions);
+    const { type: _, ...transformOptionsWithoutType } = transformOptions;
+    const prepend = await getPrependedScripts(
+      this._config,
+      transformOptionsWithoutType,
+      resolverOptions,
+      this._bundler,
+      this._deltaBundler
+    );
+    return {
+      prepend,
+      graph
+    };
+  }
+  // TODO T34760750 (alexkirsz) Eventually, I'd like to get to a point where
+  // this class exposes only initializeGraph and updateGraph.
+  async initializeGraph(entryFile, transformOptions, resolverOptions, otherOptions = {
+    onProgress: null,
+    shallow: false
+  }) {
+    const graphId = getGraphId(entryFile, transformOptions, {
+      resolverOptions,
+      shallow: otherOptions.shallow,
+      experimentalImportBundleSupport: this._config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext: this._config.transformer.unstable_allowRequireContext
+    });
+    const revisionId = createRevisionId();
+    const revisionPromise = (async () => {
+      const { graph, prepend } = await this.buildGraph(entryFile, transformOptions, resolverOptions, otherOptions);
+      return {
+        id: revisionId,
+        date: /* @__PURE__ */ new Date(),
+        graphId,
+        graph,
+        prepend
+      };
+    })();
+    this._revisionsById.set(revisionId, revisionPromise);
+    this._revisionsByGraphId.set(graphId, revisionPromise);
+    try {
+      const revision = await revisionPromise;
+      const delta = {
+        added: revision.graph.dependencies,
+        modified: /* @__PURE__ */ new Map(),
+        deleted: /* @__PURE__ */ new Set(),
+        reset: true
+      };
+      return {
+        revision,
+        delta
+      };
+    } catch (err) {
+      this._revisionsById.delete(revisionId);
+      this._revisionsByGraphId.delete(graphId);
+      throw err;
+    }
+  }
+  async updateGraph(revision, reset) {
+    const delta = await this._deltaBundler.getDelta(revision.graph, {
+      reset,
+      shallow: false
+    });
+    this._config.serializer.experimentalSerializerHook(revision.graph, delta);
+    if (delta.added.size > 0 || delta.modified.size > 0 || delta.deleted.size > 0) {
+      this._revisionsById.delete(revision.id);
+      revision = {
+        ...revision,
+        // Generate a new revision id, to be used to verify the next incremental
+        // request.
+        id: crypto.randomBytes(8).toString("hex"),
+        date: /* @__PURE__ */ new Date()
+      };
+      const revisionPromise = Promise.resolve(revision);
+      this._revisionsById.set(revision.id, revisionPromise);
+      this._revisionsByGraphId.set(revision.graphId, revisionPromise);
+    }
+    return { revision, delta };
+  }
+  async endGraph(graphId) {
+    const revPromise = this._revisionsByGraphId.get(graphId);
+    if (!revPromise) {
+      return;
+    }
+    const revision = await revPromise;
+    this._deltaBundler.endGraph(revision.graph);
+    this._revisionsByGraphId.delete(graphId);
+    this._revisionsById.delete(revision.id);
+  }
+  async _getAbsoluteEntryFiles(entryFiles) {
+    const absoluteEntryFiles = entryFiles.map(
+      (entryFile) => path.resolve(this._config.server.unstable_serverRoot ?? this._config.projectRoot, entryFile)
+    );
+    await Promise.all(
+      absoluteEntryFiles.map(
+        (entryFile) => new Promise((resolve, reject) => {
+          fs.realpath(entryFile, (err) => {
+            if (err) {
+              reject(new ResourceNotFoundError(entryFile));
+            } else {
+              resolve();
+            }
+          });
+        })
+      )
+    );
+    return absoluteEntryFiles;
+  }
+  // Wait for the bundler to become ready.
+  async ready() {
+    await this._bundler.ready();
+  }
+}
+module.exports = IncrementalBundler;

package/dist/vendors/metro/src/ModuleGraph/module.js

@@ -0,0 +1,14 @@
+"use strict";
+exports.empty = () => virtual("", "/<generated>/empty.js");
+const virtual = (code, filePath) => ({
+  dependencies: [],
+  file: {
+    code,
+    map: null,
+    functionMap: null,
+    path: filePath,
+    type: "script",
+    libraryIdx: null
+  }
+});
+exports.virtual = virtual;

package/dist/vendors/metro/src/ModuleGraph/node-haste/HasteFS.js

@@ -0,0 +1,66 @@
+"use strict";
+const { dirname, join, parse } = require("path");
+module.exports = class HasteFS {
+  directories;
+  directoryEntries;
+  files;
+  constructor(files) {
+    this.directories = buildDirectorySet(files);
+    this.directoryEntries = buildDirectoryEntries(files.map(parse));
+    this.files = new Set(files);
+  }
+  closest(path, fileName) {
+    const parsedPath = parse(path);
+    const root = parsedPath.root;
+    let dir = parsedPath.dir;
+    do {
+      const candidate = join(dir, fileName);
+      if (this.files.has(candidate)) {
+        return candidate;
+      }
+      dir = dirname(dir);
+    } while (dir !== "." && dir !== root);
+    return null;
+  }
+  dirExists(path) {
+    return this.directories.has(path);
+  }
+  exists(path) {
+    return this.files.has(path);
+  }
+  getAllFiles() {
+    return Array.from(this.files.keys());
+  }
+  matchFiles() {
+    throw new Error("HasteFS.matchFiles is not implemented yet.");
+  }
+  matches(directory, pattern) {
+    const entries = this.directoryEntries.get(directory);
+    return entries ? entries.filter(pattern.test, pattern) : [];
+  }
+};
+function buildDirectorySet(files) {
+  const directories = /* @__PURE__ */ new Set();
+  files.forEach((path) => {
+    const parsedPath = parse(path);
+    const root = parsedPath.root;
+    let dir = parsedPath.dir;
+    while (dir !== "." && dir !== root && !directories.has(dir)) {
+      directories.add(dir);
+      dir = dirname(dir);
+    }
+  });
+  return directories;
+}
+function buildDirectoryEntries(files) {
+  const directoryEntries = /* @__PURE__ */ new Map();
+  files.forEach(({ base, dir }) => {
+    const entries = directoryEntries.get(dir);
+    if (entries) {
+      entries.push(base);
+    } else {
+      directoryEntries.set(dir, [base]);
+    }
+  });
+  return directoryEntries;
+}

package/dist/vendors/metro/src/ModuleGraph/node-haste/Module.js

@@ -0,0 +1,22 @@
+"use strict";
+module.exports = class Module {
+  hasteID;
+  moduleCache;
+  name;
+  path;
+  constructor(path, moduleCache, info) {
+    this.hasteID = info.hasteID;
+    this.moduleCache = moduleCache;
+    this.name = this.hasteID || getName(path);
+    this.path = path;
+  }
+  getPackage() {
+    return this.moduleCache.getPackageOf(this.path);
+  }
+  isHaste() {
+    return Boolean(this.hasteID);
+  }
+};
+function getName(path) {
+  return path.replace(/^.*[\/\\]node_modules[\///]/, "");
+}