@granite-js/mpack 0.0.1

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[\///]/, "");
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+const Module = require("./Module");
+const Package = require("./Package");
+module.exports = class ModuleCache {
+  _getClosestPackage;
+  getTransformedFile;
+  modules;
+  packages;
+  constructor(getClosestPackage, getTransformedFile) {
+    this._getClosestPackage = getClosestPackage;
+    this.getTransformedFile = getTransformedFile;
+    this.modules = /* @__PURE__ */ new Map();
+    this.packages = /* @__PURE__ */ new Map();
+  }
+  getModule(path) {
+    const normalizedPath = path.startsWith("//") ? path.substr(1) : path;
+    let m = this.modules.get(normalizedPath);
+    if (!m) {
+      m = new Module(normalizedPath, this, this.getTransformedFile(normalizedPath));
+      this.modules.set(normalizedPath, m);
+    }
+    return m;
+  }
+  getPackage(path) {
+    let p = this.packages.get(path);
+    if (!p) {
+      p = new Package(path, this.getPackageData(path));
+      this.packages.set(path, p);
+    }
+    return p;
+  }
+  getPackageData(path) {
+    const pkg = this.getTransformedFile(path).package;
+    if (!pkg) {
+      throw new Error(`"${path}" does not exist`);
+    }
+    return pkg;
+  }
+  getPackageOf(filePath) {
+    const candidate = this._getClosestPackage(filePath);
+    return candidate != null ? this.getPackage(candidate) : null;
+  }
+};

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

@@ -0,0 +1,81 @@
+"use strict";
+const nullthrows = require("nullthrows");
+const path = require("path");
+module.exports = class Package {
+  data;
+  path;
+  root;
+  type;
+  constructor(packagePath, data) {
+    this.data = data;
+    this.path = packagePath;
+    this.root = path.dirname(packagePath);
+    this.type = "Package";
+  }
+  getMain() {
+    const replacements = getReplacements(this.data);
+    if (typeof replacements === "string") {
+      return path.join(this.root, replacements);
+    }
+    let main = getMain(this.data);
+    if (replacements && typeof replacements === "object") {
+      main = replacements[main] || replacements[main + ".js"] || replacements[main + ".json"] || replacements[main.replace(/(\.js|\.json)$/, "")] || main;
+    }
+    return path.join(this.root, main);
+  }
+  getName() {
+    return nullthrows(this.data.name);
+  }
+  isHaste() {
+    return !!this.data.name;
+  }
+  redirectRequire(name) {
+    const replacements = getReplacements(this.data);
+    if (!replacements || typeof replacements !== "object") {
+      return name;
+    }
+    if (!path.isAbsolute(name)) {
+      const replacement = replacements[name];
+      return replacement === false ? false : replacement || name;
+    }
+    let relPath = "./" + path.relative(this.root, name);
+    if (path.sep !== "/") {
+      relPath = relPath.replace(new RegExp("\\" + path.sep, "g"), "/");
+    }
+    let redirect = replacements[relPath];
+    if (redirect == null) {
+      redirect = replacements[relPath + ".js"];
+      if (redirect == null) {
+        redirect = replacements[relPath + ".json"];
+      }
+    }
+    if (redirect === false) {
+      return false;
+    }
+    if (redirect) {
+      return path.join(this.root, redirect);
+    }
+    return name;
+  }
+};
+function getMain(pkg) {
+  return pkg.main || "index";
+}
+function getReplacements(pkg) {
+  let rn = pkg["react-native"];
+  let browser = pkg.browser;
+  if (rn == null) {
+    return browser;
+  }
+  if (browser == null) {
+    return rn;
+  }
+  const main = getMain(pkg);
+  if (typeof rn !== "object") {
+    rn = { [main]: rn };
+  }
+  if (typeof browser !== "object") {
+    browser = { [main]: browser };
+  }
+  return { ...browser, ...rn };
+}

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

@@ -0,0 +1 @@
+"use strict";