@granite-js/mpack 0.0.1

package/dist/vendors/metro/src/cli-utils.js

@@ -0,0 +1,14 @@
+"use strict";
+const fs = require("fs-extra");
+exports.watchFile = async function(filename, callback) {
+  fs.watchFile(filename, () => {
+    callback();
+  });
+  await callback();
+};
+exports.makeAsyncCommand = (command) => (argv) => {
+  Promise.resolve(command(argv)).catch((error) => {
+    console.error(error.stack);
+    process.exitCode = 1;
+  });
+};

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

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+"use strict";
+try {
+  require("metro-babel-register").unstable_registerForMetroMonorepo();
+} catch {
+}
+const { attachMetroCli } = require("./index");
+const yargs = require("yargs");
+attachMetroCli(yargs.demandCommand(1)).argv;

package/dist/vendors/metro/src/commands/build.js

@@ -0,0 +1,67 @@
+"use strict";
+const { makeAsyncCommand } = require("../cli-utils");
+const TerminalReporter = require("../lib/TerminalReporter");
+const { loadConfig } = require("../../../metro-config/src");
+const { Terminal } = require("../../../metro-core/src");
+const term = new Terminal(process.stdout);
+const updateReporter = new TerminalReporter(term);
+module.exports = () => ({
+  command: "build <entry>",
+  desc: "Generates a JavaScript bundle containing the specified entrypoint and its descendants",
+  builder: (yargs) => {
+    yargs.option("project-roots", {
+      alias: "P",
+      type: "string",
+      array: true
+    });
+    yargs.option("out", { alias: "O", type: "string", demandOption: true });
+    yargs.option("platform", { alias: "p", type: "string" });
+    yargs.option("output-type", { alias: "t", type: "string" });
+    yargs.option("max-workers", { alias: "j", type: "number" });
+    yargs.option("minify", { alias: "z", type: "boolean" });
+    yargs.option("dev", { alias: "g", type: "boolean" });
+    yargs.option("source-map", { type: "boolean" });
+    yargs.option("source-map-url", { type: "string" });
+    yargs.option("legacy-bundler", { type: "boolean" });
+    yargs.option("config", { alias: "c", type: "string" });
+    yargs.option("reset-cache", { type: "boolean" });
+  },
+  handler: makeAsyncCommand(async (argv) => {
+    const config = await loadConfig(argv);
+    const options = argv;
+    const MetroApi = require("../index");
+    await MetroApi.runBuild(config, {
+      ...options,
+      onBegin: () => {
+        updateReporter.update({
+          buildID: "$",
+          type: "bundle_build_started",
+          bundleDetails: {
+            bundleType: "Bundle",
+            dev: !!options.dev,
+            entryFile: options.entry,
+            minify: !!options.minify,
+            platform: options.platform,
+            // Bytecode bundles in Metro are not meant for production use. Instead,
+            // the Hermes Bytecode Compiler should be invoked on the resulting JS bundle from Metro.
+            runtimeBytecodeVersion: null
+          }
+        });
+      },
+      onProgress: (transformedFileCount, totalFileCount) => {
+        updateReporter.update({
+          buildID: "$",
+          type: "bundle_transform_progressed",
+          transformedFileCount,
+          totalFileCount
+        });
+      },
+      onComplete: () => {
+        updateReporter.update({
+          buildID: "$",
+          type: "bundle_build_done"
+        });
+      }
+    });
+  })
+});

package/dist/vendors/metro/src/commands/dependencies.js

@@ -0,0 +1,75 @@
+"use strict";
+const { makeAsyncCommand } = require("../cli-utils");
+const Server = require("../Server");
+const denodeify = require("denodeify");
+const fs = require("fs");
+const { loadConfig } = require("../../../metro-config/src");
+const path = require("path");
+async function dependencies(args, config) {
+  const rootModuleAbsolutePath = args.entryFile;
+  if (!fs.existsSync(rootModuleAbsolutePath)) {
+    return Promise.reject(new Error(`File ${rootModuleAbsolutePath} does not exist`));
+  }
+  config.cacheStores = [];
+  const relativePath = path.relative(config.server.unstable_serverRoot ?? config.projectRoot, rootModuleAbsolutePath);
+  const options = {
+    platform: args.platform,
+    entryFile: relativePath,
+    dev: args.dev,
+    minify: false,
+    generateSourceMaps: !args.dev
+  };
+  const writeToFile = args.output;
+  const outStream = writeToFile ? fs.createWriteStream(args.output) : process.stdout;
+  const server = new Server(config);
+  const deps = await server.getOrderedDependencyPaths(options);
+  deps.forEach((modulePath) => {
+    const isInsideProjectRoots = config.watchFolders.filter((root) => modulePath.startsWith(root)).length > 0;
+    if (isInsideProjectRoots) {
+      outStream.write(modulePath + "\n");
+    }
+  });
+  server.end();
+  return writeToFile ? denodeify(outStream.end).bind(outStream)() : Promise.resolve();
+}
+module.exports = () => ({
+  command: "get-dependencies",
+  desc: "List dependencies",
+  builder: (yargs) => {
+    yargs.option("entry-file", {
+      type: "string",
+      demandOption: true,
+      describe: "Absolute path to the root JS file"
+    });
+    yargs.option("output", {
+      type: "string",
+      describe: "File name where to store the output, ex. /tmp/dependencies.txt"
+    });
+    yargs.option("platform", {
+      type: "string",
+      describe: "The platform extension used for selecting modules"
+    });
+    yargs.option("transformer", {
+      type: "string",
+      describe: "Specify a custom transformer to be used"
+    });
+    yargs.option("max-workers", {
+      type: "number",
+      describe: "Specifies the maximum number of workers the worker-pool will spawn for transforming files. This defaults to the number of the cores available on your machine."
+    });
+    yargs.option("dev", {
+      type: "boolean",
+      default: true,
+      describe: "If false, skip all dev-only code path"
+    });
+    yargs.option("verbose", {
+      type: "boolean",
+      default: false,
+      description: "Enables logging"
+    });
+  },
+  handler: makeAsyncCommand(async (argv) => {
+    const config = await loadConfig(argv);
+    await dependencies(argv, config);
+  })
+});

package/dist/vendors/metro/src/commands/serve.js

@@ -0,0 +1,56 @@
+"use strict";
+const { makeAsyncCommand, watchFile } = require("../cli-utils");
+const { loadConfig, resolveConfig } = require("../../../metro-config/src");
+const { promisify } = require("util");
+module.exports = () => ({
+  command: "serve",
+  aliases: ["start"],
+  desc: "Starts Metro on the given port, building bundles on the fly",
+  builder: (yargs) => {
+    yargs.option("project-roots", {
+      alias: "P",
+      type: "string",
+      array: true
+    });
+    yargs.option("host", { alias: "h", type: "string", default: "localhost" });
+    yargs.option("port", { alias: "p", type: "number", default: 8080 });
+    yargs.option("max-workers", { alias: "j", type: "number" });
+    yargs.option("secure", { type: "boolean", describe: "(deprecated)" });
+    yargs.option("secure-key", { type: "string", describe: "(deprecated)" });
+    yargs.option("secure-cert", { type: "string", describe: "(deprecated)" });
+    yargs.option("secure-server-options", {
+      alias: "s",
+      type: "string",
+      describe: "Use dot notation for object path"
+    });
+    yargs.option("hmr-enabled", { alias: "hmr", type: "boolean" });
+    yargs.option("config", { alias: "c", type: "string" });
+    yargs.option("reset-cache", { type: "boolean" });
+    yargs.example("secure-server-options", '-s.cert="$(cat path/to/cert)" -s.key="$(cat path/to/key")');
+  },
+  handler: makeAsyncCommand(async (argv) => {
+    let server = null;
+    let restarting = false;
+    async function restart() {
+      if (restarting) {
+        return;
+      } else {
+        restarting = true;
+      }
+      if (server) {
+        console.log("Configuration changed. Restarting the server...");
+        await promisify(server.close).call(server);
+      }
+      const config = await loadConfig(argv);
+      const MetroApi = require("../index");
+      server = await MetroApi.runServer(config, argv);
+      restarting = false;
+    }
+    const foundConfig = await resolveConfig(argv.config, argv.cwd);
+    if (foundConfig) {
+      await watchFile(foundConfig.filepath, restart);
+    } else {
+      await restart();
+    }
+  })
+});

package/dist/vendors/metro/src/index.d.ts

@@ -0,0 +1,8 @@
+// MARK: - GRANITE
+
+declare const Metro: {
+  runServer(config: any, options: any): Promise<any>;
+  runBuild(config: any, options: any): Promise<any>;
+};
+
+export default Metro;

package/dist/vendors/metro/src/index.flow.js

@@ -0,0 +1,279 @@
+"use strict";
+const makeBuildCommand = require("./commands/build");
+const makeDependenciesCommand = require("./commands/dependencies");
+const makeServeCommand = require("./commands/serve");
+const MetroHmrServer = require("./HmrServer");
+const IncrementalBundler = require("./IncrementalBundler");
+const createWebsocketServer = require("./lib/createWebsocketServer");
+const MetroServer = require("./Server");
+const outputBundle = require("./shared/output/bundle");
+const chalk = require("chalk");
+const fs = require("fs");
+const http = require("http");
+const https = require("https");
+const { getDefaultConfig, loadConfig, mergeConfig } = require("../../metro-config/src");
+const { InspectorProxy } = require("../../metro-inspector-proxy/src/index");
+const net = require("net");
+const { parse } = require("url");
+const ws = require("ws");
+async function getConfig(config) {
+  const defaultConfig = await getDefaultConfig(config.projectRoot);
+  return mergeConfig(defaultConfig, config);
+}
+async function runMetro(config, options) {
+  const mergedConfig = await getConfig(config);
+  const {
+    reporter,
+    server: { port }
+  } = mergedConfig;
+  reporter.update({
+    hasReducedPerformance: options ? Boolean(options.hasReducedPerformance) : false,
+    port,
+    type: "initialize_started"
+  });
+  const { waitForBundler = false, ...serverOptions } = options ?? {};
+  const server = new MetroServer(mergedConfig, serverOptions);
+  const readyPromise = server.ready().then(() => {
+    reporter.update({
+      type: "initialize_done",
+      port
+    });
+  }).catch((error) => {
+    reporter.update({
+      type: "initialize_failed",
+      port,
+      error
+    });
+  });
+  if (waitForBundler) {
+    await readyPromise;
+  }
+  return server;
+}
+exports.runMetro = runMetro;
+exports.loadConfig = loadConfig;
+const createConnectMiddleware = async function(config, options) {
+  const metroServer = await runMetro(config, options);
+  let enhancedMiddleware = metroServer.processRequest;
+  if (config.server.enhanceMiddleware) {
+    enhancedMiddleware = config.server.enhanceMiddleware(enhancedMiddleware, metroServer);
+  }
+  return {
+    attachHmrServer(httpServer) {
+      const wss = createWebsocketServer({
+        websocketServer: new MetroHmrServer(metroServer.getBundler(), metroServer.getCreateModuleId(), config)
+      });
+      httpServer.on("upgrade", (request, socket, head) => {
+        const { pathname } = parse(request.url);
+        if (pathname === "/hot") {
+          wss.handleUpgrade(request, socket, head, (ws2) => {
+            wss.emit("connection", ws2, request);
+          });
+        } else {
+          socket.destroy();
+        }
+      });
+    },
+    metroServer,
+    middleware: enhancedMiddleware,
+    end() {
+      metroServer.end();
+    }
+  };
+};
+exports.createConnectMiddleware = createConnectMiddleware;
+exports.runServer = async (config, {
+  hasReducedPerformance = false,
+  host,
+  onError,
+  onReady,
+  secureServerOptions,
+  secure,
+  //deprecated
+  secureCert,
+  // deprecated
+  secureKey,
+  // deprecated
+  waitForBundler = false,
+  websocketEndpoints = {}
+}) => {
+  await earlyPortCheck(host, config.server.port);
+  if (secure != null || secureCert != null || secureKey != null) {
+    console.warn(
+      chalk.inverse.yellow.bold(" DEPRECATED "),
+      "The `secure`, `secureCert`, and `secureKey` options are now deprecated. Please use the `secureServerOptions` object instead to pass options to Metro's https development server."
+    );
+  }
+  const connect = require("connect");
+  const serverApp = connect();
+  const { middleware, end, metroServer } = await createConnectMiddleware(config, {
+    hasReducedPerformance,
+    waitForBundler
+  });
+  serverApp.use(middleware);
+  let inspectorProxy = null;
+  if (config.server.runInspectorProxy) {
+    inspectorProxy = new InspectorProxy(config.projectRoot);
+  }
+  let httpServer;
+  if (secure || secureServerOptions != null) {
+    let options = secureServerOptions;
+    if (typeof secureKey === "string" && typeof secureCert === "string") {
+      options = {
+        key: fs.readFileSync(secureKey),
+        cert: fs.readFileSync(secureCert),
+        ...secureServerOptions
+      };
+    }
+    httpServer = https.createServer(options, serverApp);
+  } else {
+    httpServer = http.createServer(serverApp);
+  }
+  return new Promise((resolve, reject) => {
+    httpServer.on("error", (error) => {
+      if (onError) {
+        onError(error);
+      }
+      reject(error);
+      end();
+    });
+    httpServer.listen(config.server.port, host, () => {
+      if (onReady) {
+        onReady(httpServer);
+      }
+      Object.assign(websocketEndpoints, {
+        ...inspectorProxy ? { ...inspectorProxy.createWebSocketListeners(httpServer) } : {},
+        "/hot": createWebsocketServer({
+          websocketServer: new MetroHmrServer(metroServer.getBundler(), metroServer.getCreateModuleId(), config)
+        })
+      });
+      httpServer.on("upgrade", (request, socket, head) => {
+        const { pathname } = parse(request.url);
+        if (pathname != null && websocketEndpoints[pathname]) {
+          websocketEndpoints[pathname].handleUpgrade(request, socket, head, (ws2) => {
+            websocketEndpoints[pathname].emit("connection", ws2, request);
+          });
+        } else {
+          socket.destroy();
+        }
+      });
+      if (inspectorProxy) {
+        serverApp.use(inspectorProxy.processRequest.bind(inspectorProxy));
+      }
+      resolve(httpServer);
+    });
+    httpServer.timeout = 0;
+    httpServer.on("close", () => {
+      end();
+    });
+  });
+};
+exports.runBuild = async (config, {
+  dev = false,
+  entry,
+  onBegin,
+  onComplete,
+  onProgress,
+  minify = true,
+  output = outputBundle,
+  out,
+  platform = "web",
+  sourceMap = false,
+  sourceMapUrl
+}) => {
+  const metroServer = await runMetro(config, {
+    watch: false
+  });
+  try {
+    const requestOptions = {
+      dev,
+      entryFile: entry,
+      inlineSourceMap: sourceMap && !sourceMapUrl,
+      minify,
+      platform,
+      sourceMapUrl: sourceMap === false ? void 0 : sourceMapUrl,
+      createModuleIdFactory: config.serializer.createModuleIdFactory,
+      onProgress
+    };
+    if (onBegin) {
+      onBegin();
+    }
+    const metroBundle = await output.build(metroServer, requestOptions);
+    if (onComplete) {
+      onComplete();
+    }
+    if (out) {
+      const bundleOutput = out.replace(/(\.js)?$/, ".js");
+      const sourcemapOutput = sourceMap === false ? void 0 : out.replace(/(\.js)?$/, ".map");
+      const outputOptions = {
+        bundleOutput,
+        sourcemapOutput,
+        dev,
+        platform
+      };
+      await output.save(metroBundle, outputOptions, console.log);
+    }
+    return metroBundle;
+  } finally {
+    await metroServer.end();
+  }
+};
+exports.buildGraph = async function(config, {
+  customTransformOptions = /* @__PURE__ */ Object.create(null),
+  dev = false,
+  entries,
+  minify = false,
+  onProgress,
+  platform = "web",
+  type = "module"
+}) {
+  const mergedConfig = await getConfig(config);
+  const bundler = new IncrementalBundler(mergedConfig);
+  try {
+    const { customResolverOptions, ...defaultTransformInputOptions } = MetroServer.DEFAULT_GRAPH_OPTIONS;
+    return await bundler.buildGraphForEntries(
+      entries,
+      {
+        ...defaultTransformInputOptions,
+        customTransformOptions,
+        dev,
+        minify,
+        platform,
+        type
+      },
+      { customResolverOptions }
+    );
+  } finally {
+    bundler.end();
+  }
+};
+exports.attachMetroCli = function(yargs, {
+  build = {},
+  serve = {},
+  dependencies = {}
+} = {}) {
+  yargs.strict();
+  if (build) {
+    yargs.command(makeBuildCommand());
+  }
+  if (serve) {
+    yargs.command(makeServeCommand());
+  }
+  if (dependencies) {
+    yargs.command(makeDependenciesCommand());
+  }
+  return yargs;
+};
+async function earlyPortCheck(host, port) {
+  const server = net.createServer((c) => c.end());
+  try {
+    await new Promise((resolve, reject) => {
+      server.on("error", (err) => {
+        reject(err);
+      });
+      server.listen(port, host, void 0, () => resolve());
+    });
+  } finally {
+    await new Promise((resolve) => server.close(() => resolve()));
+  }
+}

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

@@ -0,0 +1,6 @@
+"use strict";
+try {
+  require("metro-babel-register").unstable_registerForMetroMonorepo();
+} catch {
+}
+module.exports = require("./index.flow");

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

@@ -0,0 +1,13 @@
+"use strict";
+let cachedResult = null;
+module.exports = function isPnP() {
+  if (cachedResult !== null) {
+    return cachedResult;
+  }
+  try {
+    require("pnpapi");
+    return cachedResult = true;
+  } catch {
+    return cachedResult = false;
+  }
+};

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

@@ -0,0 +1,69 @@
+"use strict";
+const invariant = require("invariant");
+class BatchProcessor {
+  _currentProcessCount;
+  _options;
+  _processBatch;
+  _queue;
+  _timeoutHandle;
+  constructor(options, processBatch) {
+    this._options = options;
+    this._processBatch = processBatch;
+    this._queue = [];
+    this._timeoutHandle = null;
+    this._currentProcessCount = 0;
+    this._processQueue = this._processQueue.bind(this);
+  }
+  _onBatchFinished() {
+    this._currentProcessCount--;
+    this._processQueueOnceReady();
+  }
+  _onBatchResults(jobs, results) {
+    invariant(results.length === jobs.length, "Not enough results returned.");
+    for (let i = 0; i < jobs.length; ++i) {
+      jobs[i].resolve(results[i]);
+    }
+    this._onBatchFinished();
+  }
+  _onBatchError(jobs, error) {
+    for (let i = 0; i < jobs.length; ++i) {
+      jobs[i].reject(error);
+    }
+    this._onBatchFinished();
+  }
+  _processQueue() {
+    this._timeoutHandle = null;
+    const { concurrency } = this._options;
+    while (this._queue.length > 0 && this._currentProcessCount < concurrency) {
+      this._currentProcessCount++;
+      const jobs = this._queue.splice(0, this._options.maximumItems);
+      this._processBatch(jobs.map((job) => job.item)).then(
+        // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+        this._onBatchResults.bind(this, jobs),
+        // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+        this._onBatchError.bind(this, jobs)
+      );
+    }
+  }
+  _processQueueOnceReady() {
+    if (this._queue.length >= this._options.maximumItems) {
+      clearTimeout(this._timeoutHandle);
+      process.nextTick(this._processQueue);
+      return;
+    }
+    if (this._timeoutHandle == null) {
+      this._timeoutHandle = setTimeout(
+        // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+        this._processQueue,
+        this._options.maximumDelayMs
+      );
+    }
+  }
+  queue(item) {
+    return new Promise((resolve, reject) => {
+      this._queue.push({ item, resolve, reject });
+      this._processQueueOnceReady();
+    });
+  }
+}
+module.exports = BatchProcessor;