@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/vendors/metro-config/src/loadConfig.js

@@ -0,0 +1,188 @@
+"use strict";
+const getDefaultConfig = require("./defaults");
+const validConfig = require("./defaults/validConfig");
+const { cosmiconfig, defaultLoaders } = require("cosmiconfig");
+const fs = require("fs");
+const { validate } = require("jest-validate");
+const MetroCache = require("metro-cache");
+const path = require("path");
+const { dirname, join } = require("path");
+function overrideArgument(arg) {
+  if (arg == null) {
+    return arg;
+  }
+  if (Array.isArray(arg)) {
+    return arg[arg.length - 1];
+  }
+  return arg;
+}
+const explorer = cosmiconfig("metro", {
+  searchPlaces: ["metro.config.js", "metro.config.json", "package.json"],
+  loaders: {
+    // MARK: - GRANITE
+    ...defaultLoaders,
+    ".es6": defaultLoaders[".js"],
+    noExt: cosmiconfig.loadYaml
+  }
+});
+const isFile = (filePath) => fs.existsSync(filePath) && !fs.lstatSync(filePath).isDirectory();
+const resolve = (filePath) => {
+  try {
+    return require.resolve(filePath);
+  } catch (error) {
+    if (path.isAbsolute(filePath) || error.code !== "MODULE_NOT_FOUND") {
+      throw error;
+    }
+  }
+  const possiblePath = path.resolve(process.cwd(), filePath);
+  return isFile(possiblePath) ? possiblePath : filePath;
+};
+async function resolveConfig(filePath, cwd) {
+  if (filePath) {
+    return explorer.load(resolve(filePath));
+  }
+  const result = await explorer.search(cwd);
+  if (result == null) {
+    return {
+      isEmpty: true,
+      filepath: join(cwd || process.cwd(), "metro.config.stub.js"),
+      config: {}
+    };
+  }
+  return result;
+}
+function mergeConfig(defaultConfig, ...configs) {
+  return configs.reduce(
+    (totalConfig, nextConfig) => ({
+      ...totalConfig,
+      ...nextConfig,
+      cacheStores: nextConfig.cacheStores != null ? typeof nextConfig.cacheStores === "function" ? nextConfig.cacheStores(MetroCache) : nextConfig.cacheStores : totalConfig.cacheStores,
+      resolver: {
+        /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+         * an error found when Flow v0.111 was deployed. To see the error,
+         * delete this comment and run Flow. */
+        ...totalConfig.resolver,
+        ...nextConfig.resolver || {},
+        dependencyExtractor: nextConfig.resolver && nextConfig.resolver.dependencyExtractor != null ? resolve(nextConfig.resolver.dependencyExtractor) : totalConfig.resolver.dependencyExtractor,
+        hasteImplModulePath: nextConfig.resolver && nextConfig.resolver.hasteImplModulePath != null ? resolve(nextConfig.resolver.hasteImplModulePath) : totalConfig.resolver.hasteImplModulePath
+      },
+      serializer: {
+        /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+         * an error found when Flow v0.111 was deployed. To see the error,
+         * delete this comment and run Flow. */
+        ...totalConfig.serializer,
+        ...nextConfig.serializer || {}
+      },
+      transformer: {
+        /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+         * an error found when Flow v0.111 was deployed. To see the error,
+         * delete this comment and run Flow. */
+        ...totalConfig.transformer,
+        ...nextConfig.transformer || {},
+        babelTransformerPath: nextConfig.transformer && nextConfig.transformer.babelTransformerPath != null ? resolve(nextConfig.transformer.babelTransformerPath) : totalConfig.transformer.babelTransformerPath
+      },
+      server: {
+        /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+         * an error found when Flow v0.111 was deployed. To see the error,
+         * delete this comment and run Flow. */
+        ...totalConfig.server,
+        ...nextConfig.server || {}
+      },
+      symbolicator: {
+        /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+         * an error found when Flow v0.111 was deployed. To see the error,
+         * delete this comment and run Flow. */
+        ...totalConfig.symbolicator,
+        ...nextConfig.symbolicator || {}
+      },
+      watcher: {
+        ...totalConfig.watcher,
+        ...nextConfig.watcher,
+        watchman: {
+          ...totalConfig.watcher?.watchman,
+          ...nextConfig.watcher?.watchman
+        }
+      }
+    }),
+    defaultConfig
+  );
+}
+async function loadMetroConfigFromDisk(path2, cwd, defaultConfigOverrides) {
+  const resolvedConfigResults = await resolveConfig(path2, cwd);
+  const { config: configModule, filepath } = resolvedConfigResults;
+  const rootPath = dirname(filepath);
+  const defaults = await getDefaultConfig(rootPath);
+  const defaultConfig = mergeConfig(defaults, defaultConfigOverrides);
+  if (typeof configModule === "function") {
+    const resultedConfig = await configModule(defaultConfig);
+    return mergeConfig(defaultConfig, resultedConfig);
+  }
+  return mergeConfig(defaultConfig, configModule);
+}
+function overrideConfigWithArguments(config, argv) {
+  const output = {
+    resolver: {},
+    serializer: {},
+    server: {},
+    transformer: {}
+  };
+  if (argv.port != null) {
+    output.server.port = Number(argv.port);
+  }
+  if (argv.runInspectorProxy != null) {
+    output.server.runInspectorProxy = Boolean(argv.runInspectorProxy);
+  }
+  if (argv.projectRoot != null) {
+    output.projectRoot = argv.projectRoot;
+  }
+  if (argv.watchFolders != null) {
+    output.watchFolders = argv.watchFolders;
+  }
+  if (argv.assetExts != null) {
+    output.resolver.assetExts = argv.assetExts;
+  }
+  if (argv.sourceExts != null) {
+    output.resolver.sourceExts = argv.sourceExts;
+  }
+  if (argv.platforms != null) {
+    output.resolver.platforms = argv.platforms;
+  }
+  if (argv["max-workers"] != null || argv.maxWorkers != null) {
+    output.maxWorkers = Number(argv["max-workers"] || argv.maxWorkers);
+  }
+  if (argv.transformer != null) {
+    output.transformer.babelTransformerPath = argv.transformer;
+  }
+  if (argv["reset-cache"] != null) {
+    output.resetCache = argv["reset-cache"];
+  }
+  if (argv.resetCache != null) {
+    output.resetCache = argv.resetCache;
+  }
+  if (argv.verbose === false) {
+    output.reporter = { update: () => {
+    } };
+  }
+  return mergeConfig(config, output);
+}
+async function loadConfig(argv = {}, defaultConfigOverrides = {}) {
+  argv.config = overrideArgument(argv.config);
+  const configuration = await loadMetroConfigFromDisk(argv.config, argv.cwd, defaultConfigOverrides);
+  validate(configuration, {
+    exampleConfig: await validConfig(),
+    recursiveBlacklist: ["reporter", "resolver", "transformer"],
+    deprecatedConfig: {
+      blacklistRE: () => `Warning: Metro config option \`blacklistRE\` is deprecated.
+         Please use \`blockList\` instead.`
+    }
+  });
+  const configWithArgs = overrideConfigWithArguments(configuration, argv);
+  const overriddenConfig = {};
+  overriddenConfig.watchFolders = [configWithArgs.projectRoot, ...configWithArgs.watchFolders];
+  return mergeConfig(configWithArgs, overriddenConfig);
+}
+module.exports = {
+  loadConfig,
+  resolveConfig,
+  mergeConfig
+};

package/dist/vendors/metro-core/src/Logger.js

@@ -0,0 +1,62 @@
+"use strict";
+const VERSION = "0.0.0";
+const { EventEmitter } = require("events");
+const os = require("os");
+const path = require("path");
+const log_session = `${os.hostname()}-${Date.now()}`;
+const eventEmitter = new EventEmitter();
+function on(event, handler) {
+  eventEmitter.on(event, handler);
+}
+function createEntry(data) {
+  const logEntry = typeof data === "string" ? { log_entry_label: data } : data;
+  const entryPoint = logEntry.entry_point;
+  if (entryPoint) {
+    logEntry.entry_point = path.relative(process.cwd(), entryPoint);
+  }
+  return {
+    ...logEntry,
+    log_session,
+    metro_bundler_version: VERSION
+  };
+}
+function createActionStartEntry(data) {
+  const logEntry = typeof data === "string" ? { action_name: data } : data;
+  const { action_name } = logEntry;
+  return createEntry({
+    ...logEntry,
+    action_name,
+    action_phase: "start",
+    log_entry_label: action_name,
+    start_timestamp: process.hrtime()
+  });
+}
+function createActionEndEntry(logEntry) {
+  const { action_name, action_phase, start_timestamp } = logEntry;
+  if (action_phase !== "start" || !Array.isArray(start_timestamp)) {
+    throw new Error("Action has not started or has already ended");
+  }
+  const timeDelta = process.hrtime(start_timestamp);
+  const duration_ms = Math.round((timeDelta[0] * 1e9 + timeDelta[1]) / 1e6);
+  return createEntry({
+    ...logEntry,
+    action_name,
+    action_phase: "end",
+    duration_ms,
+    /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses an
+     * error found when Flow v0.111 was deployed. To see the error, delete this
+     * comment and run Flow. */
+    log_entry_label: action_name
+  });
+}
+function log(logEntry) {
+  eventEmitter.emit("log", logEntry);
+  return logEntry;
+}
+module.exports = {
+  on,
+  createEntry,
+  createActionStartEntry,
+  createActionEndEntry,
+  log
+};

package/dist/vendors/metro-core/src/Terminal.d.ts

@@ -0,0 +1,30 @@
+import type * as net from 'net';
+import type * as stream from 'stream';
+
+type UnderlyingStream = net.Socket | stream.Writable;
+
+declare class Terminal {
+  constructor(stream: UnderlyingStream);
+  /**
+   * Shows some text that is meant to be overriden later. Return the previous
+   * status that was shown and is no more. Calling `status()` with no argument
+   * removes the status altogether. The status is never shown in a
+   * non-interactive terminal: for example, if the output is redirected to a
+   * file, then we don't care too much about having a progress bar.
+   */
+  status(format: string, ...args: unknown[]): string;
+  /**
+   * Similar to `console.log`, except it moves the status/progress text out of
+   * the way correctly. In non-interactive terminals this is the same as
+   * `console.log`.
+   */
+  log(format: string, ...args: unknown[]): void;
+  /**
+   * Log the current status and start from scratch. This is useful if the last
+   * status was the last one of a series of updates.
+   */
+  persistStatus(): void;
+  flush(): void;
+}
+
+export default Terminal;

package/dist/vendors/metro-core/src/Terminal.js

@@ -0,0 +1,100 @@
+"use strict";
+const throttle = require("lodash.throttle");
+const readline = require("readline");
+const tty = require("tty");
+const util = require("util");
+function clearStringBackwards(stream, str) {
+  readline.moveCursor(stream, -stream.columns, 0);
+  readline.clearLine(stream, 0);
+  let lineCount = (str.match(/\n/g) || []).length;
+  while (lineCount > 0) {
+    readline.moveCursor(stream, 0, -1);
+    readline.clearLine(stream, 0);
+    --lineCount;
+  }
+}
+function chunkString(str, size) {
+  const ANSI_COLOR = "\x1B\\[([0-9]{1,2}(;[0-9]{1,2})?)?m";
+  const SKIP_ANSI = `(?:${ANSI_COLOR})*`;
+  return str.match(new RegExp(`(?:${SKIP_ANSI}.){1,${size}}`, "g")) || [];
+}
+function getTTYStream(stream) {
+  if (stream instanceof tty.WriteStream && stream.isTTY && stream.columns >= 1) {
+    return stream;
+  }
+  return null;
+}
+class Terminal {
+  _logLines;
+  _nextStatusStr;
+  _scheduleUpdate;
+  _statusStr;
+  _stream;
+  constructor(stream) {
+    this._logLines = [];
+    this._nextStatusStr = "";
+    this._scheduleUpdate = throttle(this._update, 33);
+    this._statusStr = "";
+    this._stream = stream;
+  }
+  /**
+   * Clear and write the new status, logging in bulk in-between. Doing this in a
+   * throttled way (in a different tick than the calls to `log()` and
+   * `status()`) prevents us from repeatedly rewriting the status in case
+   * `terminal.log()` is called several times.
+   */
+  _update() {
+    const { _statusStr, _stream } = this;
+    const ttyStream = getTTYStream(_stream);
+    if (_statusStr === this._nextStatusStr && this._logLines.length === 0) {
+      return;
+    }
+    if (ttyStream != null) {
+      clearStringBackwards(ttyStream, _statusStr);
+    }
+    this._logLines.forEach((line) => {
+      _stream.write(line);
+      _stream.write("\n");
+    });
+    this._logLines = [];
+    if (ttyStream != null) {
+      this._nextStatusStr = chunkString(this._nextStatusStr, ttyStream.columns).join("\n");
+      _stream.write(this._nextStatusStr);
+    }
+    this._statusStr = this._nextStatusStr;
+  }
+  /**
+   * Shows some text that is meant to be overriden later. Return the previous
+   * status that was shown and is no more. Calling `status()` with no argument
+   * removes the status altogether. The status is never shown in a
+   * non-interactive terminal: for example, if the output is redirected to a
+   * file, then we don't care too much about having a progress bar.
+   */
+  status(format, ...args) {
+    const { _nextStatusStr } = this;
+    this._nextStatusStr = util.format(format, ...args);
+    this._scheduleUpdate();
+    return _nextStatusStr;
+  }
+  /**
+   * Similar to `console.log`, except it moves the status/progress text out of
+   * the way correctly. In non-interactive terminals this is the same as
+   * `console.log`.
+   */
+  log(format, ...args) {
+    this._logLines.push(util.format(format, ...args));
+    this._scheduleUpdate();
+  }
+  /**
+   * Log the current status and start from scratch. This is useful if the last
+   * status was the last one of a series of updates.
+   */
+  persistStatus() {
+    this.log(this._nextStatusStr);
+    this._nextStatusStr = "";
+  }
+  flush() {
+    this._scheduleUpdate.flush();
+  }
+}
+module.exports = Terminal;

package/dist/vendors/metro-core/src/canonicalize.js

@@ -0,0 +1,17 @@
+"use strict";
+function canonicalize(key, value) {
+  if (
+    // eslint-disable-next-line lint/strictly-null
+    value === null || typeof value !== "object" || Array.isArray(value)
+  ) {
+    return value;
+  }
+  const keys = Object.keys(value).sort();
+  const length = keys.length;
+  const object = {};
+  for (let i = 0; i < length; i++) {
+    object[keys[i]] = value[keys[i]];
+  }
+  return object;
+}
+module.exports = canonicalize;

package/dist/vendors/metro-core/src/errors/AmbiguousModuleResolutionError.js

@@ -0,0 +1,11 @@
+"use strict";
+class AmbiguousModuleResolutionError extends Error {
+  fromModulePath;
+  hasteError;
+  constructor(fromModulePath, hasteError) {
+    super(`Ambiguous module resolution from \`${fromModulePath}\`: ` + hasteError.message);
+    this.fromModulePath = fromModulePath;
+    this.hasteError = hasteError;
+  }
+}
+module.exports = AmbiguousModuleResolutionError;

package/dist/vendors/metro-core/src/errors/PackageResolutionError.js

@@ -0,0 +1,18 @@
+"use strict";
+const { formatFileCandidates } = require("metro-resolver");
+class PackageResolutionError extends Error {
+  originModulePath;
+  packageError;
+  targetModuleName;
+  constructor(opts) {
+    const perr = opts.packageError;
+    super(
+      `While trying to resolve module \`${opts.targetModuleName}\` from file \`${opts.originModulePath}\`, the package \`${perr.packageJsonPath}\` was successfully found. However, this package itself specifies a \`main\` module field that could not be resolved (\`${perr.mainPrefixPath}\`. Indeed, none of these files exist:
+
+  * ${formatFileCandidates(perr.fileCandidates)}
+  * ${formatFileCandidates(perr.indexCandidates)}`
+    );
+    Object.assign(this, opts);
+  }
+}
+module.exports = PackageResolutionError;

package/dist/vendors/metro-core/src/errors.js

@@ -0,0 +1,7 @@
+"use strict";
+const AmbiguousModuleResolutionError = require("./errors/AmbiguousModuleResolutionError");
+const PackageResolutionError = require("./errors/PackageResolutionError");
+module.exports = {
+  AmbiguousModuleResolutionError,
+  PackageResolutionError
+};

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

@@ -0,0 +1,11 @@
+"use strict";
+const AmbiguousModuleResolutionError = require("./errors/AmbiguousModuleResolutionError");
+const PackageResolutionError = require("./errors/PackageResolutionError");
+const Logger = require("./Logger");
+const Terminal = require("./Terminal");
+module.exports = {
+  AmbiguousModuleResolutionError,
+  Logger,
+  PackageResolutionError,
+  Terminal
+};