@granite-js/mpack 0.0.0-dev-20250725013859

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

@@ -0,0 +1,46 @@
+"use strict";
+const chalk = require("chalk");
+const util = require("util");
+const groupStack = [];
+let collapsedGuardTimer;
+module.exports = (terminal, level, mode, ...data) => {
+  const logFunction = console[level] && level !== "trace" ? level : "log";
+  const color = level === "error" ? chalk.inverse.red : level === "warn" ? chalk.inverse.yellow : chalk.inverse.white;
+  if (level === "group") {
+    groupStack.push(level);
+  } else if (level === "groupCollapsed") {
+    groupStack.push(level);
+    clearTimeout(collapsedGuardTimer);
+    collapsedGuardTimer = setTimeout(() => {
+      if (groupStack.includes("groupCollapsed")) {
+        terminal.log(
+          chalk.inverse.yellow.bold(" WARN "),
+          "Expected `console.groupEnd` to be called after `console.groupCollapsed`."
+        );
+        groupStack.length = 0;
+      }
+    }, 3e3);
+    return;
+  } else if (level === "groupEnd") {
+    groupStack.pop();
+    if (!groupStack.length) {
+      clearTimeout(collapsedGuardTimer);
+    }
+    return;
+  }
+  if (!groupStack.includes("groupCollapsed")) {
+    const lastItem = data[data.length - 1];
+    if (typeof lastItem === "string") {
+      data[data.length - 1] = lastItem.trimEnd();
+    }
+    const modePrefix = !mode || mode == "BRIDGE" ? "" : `(${mode.toUpperCase()}) `;
+    terminal.log(
+      color.bold(` ${modePrefix}${logFunction.toUpperCase()} `) + "".padEnd(groupStack.length * 2, " "),
+      // `util.format` actually accepts any arguments.
+      // If the first argument is a string, it tries to format it.
+      // Otherwise, it just concatenates all arguments.
+      // $FlowIssue[incompatible-call] util.format expected the first argument to be a string
+      util.format(...data)
+    );
+  }
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+const nullthrows = require("nullthrows");
+const PREFIX = "resolver.";
+module.exports = function parseCustomResolverOptions(urlObj) {
+  const customResolverOptions = /* @__PURE__ */ Object.create(null);
+  const query = nullthrows(urlObj.query);
+  Object.keys(query).forEach((key) => {
+    if (key.startsWith(PREFIX)) {
+      customResolverOptions[key.substr(PREFIX.length)] = query[key];
+    }
+  });
+  return customResolverOptions;
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+const nullthrows = require("nullthrows");
+const PREFIX = "transform.";
+module.exports = function parseCustomTransformOptions(urlObj) {
+  const customTransformOptions = /* @__PURE__ */ Object.create(null);
+  const query = nullthrows(urlObj.query);
+  Object.keys(query).forEach((key) => {
+    if (key.startsWith(PREFIX)) {
+      customTransformOptions[key.substr(PREFIX.length)] = query[key];
+    }
+  });
+  return customTransformOptions;
+};

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

@@ -0,0 +1,50 @@
+"use strict";
+const parsePlatformFilePath = require("../node-haste/lib/parsePlatformFilePath");
+const parseCustomResolverOptions = require("./parseCustomResolverOptions");
+const parseCustomTransformOptions = require("./parseCustomTransformOptions");
+const nullthrows = require("nullthrows");
+const path = require("path");
+const url = require("url");
+const getBoolean = (query, opt, defaultValue) => query[opt] == null ? defaultValue : query[opt] === "true" || query[opt] === "1";
+const getNumber = (query, opt, defaultValue) => {
+  const number = parseInt(query[opt], 10);
+  return Number.isNaN(number) ? defaultValue : number;
+};
+const getBundleType = (bundleType) => bundleType === "map" ? bundleType : "bundle";
+const getTransformProfile = (transformProfile) => transformProfile === "hermes-stable" || transformProfile === "hermes-canary" ? transformProfile : "default";
+module.exports = function parseOptionsFromUrl(requestUrl, platforms, bytecodeVersion) {
+  const parsedURL = nullthrows(url.parse(requestUrl, true));
+  const query = nullthrows(parsedURL.query);
+  const pathname = query.bundleEntry || (parsedURL.pathname != null ? decodeURIComponent(parsedURL.pathname) : "");
+  const platform = query.platform || parsePlatformFilePath(pathname, platforms).platform;
+  const bundleType = getBundleType(path.extname(pathname).substr(1));
+  const runtimeBytecodeVersion = getNumber(query, "runtimeBytecodeVersion", null);
+  return {
+    bundleType,
+    runtimeBytecodeVersion: bytecodeVersion === runtimeBytecodeVersion ? bytecodeVersion : null,
+    customResolverOptions: parseCustomResolverOptions(parsedURL),
+    customTransformOptions: parseCustomTransformOptions(parsedURL),
+    dev: getBoolean(query, "dev", true),
+    entryFile: pathname.replace(/^(?:\.?\/)?/, "./").replace(/\.[^/.]+$/, ""),
+    excludeSource: getBoolean(query, "excludeSource", false),
+    hot: true,
+    inlineSourceMap: getBoolean(query, "inlineSourceMap", false),
+    minify: getBoolean(query, "minify", false),
+    modulesOnly: getBoolean(query, "modulesOnly", false),
+    onProgress: null,
+    platform,
+    runModule: getBoolean(query, "runModule", true),
+    shallow: getBoolean(query, "shallow", false),
+    sourceMapUrl: url.format({
+      ...parsedURL,
+      // The Chrome Debugger loads bundles via Blob urls, whose
+      // protocol is blob:http. This breaks loading source maps through
+      // protocol-relative URLs, which is why we must force the HTTP protocol
+      // when loading the bundle for either Android or iOS.
+      protocol: platform != null && platform.match(/^(android|ios)$/) ? "http" : "",
+      pathname: pathname.replace(/\.(bundle|delta)$/, ".map")
+    }),
+    sourceUrl: requestUrl,
+    unstable_transformProfile: getTransformProfile(query.unstable_transformProfile)
+  };
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+const path = require("path");
+function relativizeSourceMapInline(sourceMap, sourcesRoot) {
+  if (sourceMap.mappings === void 0) {
+    for (let i = 0; i < sourceMap.sections.length; i++) {
+      relativizeSourceMapInline(sourceMap.sections[i].map, sourcesRoot);
+    }
+  } else {
+    for (let i = 0; i < sourceMap.sources.length; i++) {
+      sourceMap.sources[i] = path.relative(sourcesRoot, sourceMap.sources[i]);
+    }
+  }
+}
+module.exports = relativizeSourceMapInline;

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

@@ -0,0 +1,26 @@
+"use strict";
+const chalk = require("chalk");
+const stripAnsi = require("strip-ansi");
+const util = require("util");
+function logWarning(terminal, format, ...args) {
+  const str = util.format(format, ...args);
+  terminal.log("%s: %s", chalk.yellow("warning"), str);
+}
+function logError(terminal, format, ...args) {
+  terminal.log(
+    "%s: %s",
+    chalk.red("error"),
+    // Syntax errors may have colors applied for displaying code frames
+    // in various places outside of where Metro is currently running.
+    // If the current terminal does not support color, we'll strip the colors
+    // here.
+    util.format(chalk.supportsColor ? format : stripAnsi(format), ...args)
+  );
+}
+const nullReporter = { update() {
+} };
+module.exports = {
+  logWarning,
+  logError,
+  nullReporter
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+function splitBundleOptions(options) {
+  return {
+    entryFile: options.entryFile,
+    resolverOptions: {
+      customResolverOptions: options.customResolverOptions
+    },
+    transformOptions: {
+      customTransformOptions: options.customTransformOptions,
+      dev: options.dev,
+      hot: options.hot,
+      minify: options.minify,
+      platform: options.platform,
+      runtimeBytecodeVersion: options.runtimeBytecodeVersion,
+      type: "module",
+      unstable_transformProfile: options.unstable_transformProfile
+    },
+    serializerOptions: {
+      excludeSource: options.excludeSource,
+      inlineSourceMap: options.inlineSourceMap,
+      modulesOnly: options.modulesOnly,
+      runModule: options.runModule,
+      sourceMapUrl: options.sourceMapUrl,
+      sourceUrl: options.sourceUrl
+    },
+    graphOptions: {
+      shallow: options.shallow
+    },
+    onProgress: options.onProgress
+  };
+}
+module.exports = splitBundleOptions;

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

@@ -0,0 +1,112 @@
+"use strict";
+var import_contextModuleTemplates = require("./contextModuleTemplates");
+const path = require("path");
+const baseIgnoredInlineRequires = ["React", "react", "react-native"];
+async function calcTransformerOptions(entryFiles, bundler, deltaBundler, config, options, resolverOptions) {
+  const baseOptions = {
+    customTransformOptions: options.customTransformOptions,
+    dev: options.dev,
+    hot: options.hot,
+    inlineRequires: false,
+    inlinePlatform: true,
+    minify: options.minify,
+    platform: options.platform,
+    runtimeBytecodeVersion: options.runtimeBytecodeVersion,
+    unstable_transformProfile: options.unstable_transformProfile
+  };
+  if (options.type === "script") {
+    return {
+      ...baseOptions,
+      type: "script"
+    };
+  }
+  const getDependencies = async (path2) => {
+    const dependencies = await deltaBundler.getDependencies([path2], {
+      resolve: await getResolveDependencyFn(bundler, options.platform, resolverOptions),
+      transform: await getTransformFn(
+        [path2],
+        bundler,
+        deltaBundler,
+        config,
+        {
+          ...options,
+          minify: false
+        },
+        resolverOptions
+      ),
+      transformOptions: options,
+      onProgress: null,
+      experimentalImportBundleSupport: config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext: config.transformer.unstable_allowRequireContext,
+      shallow: false
+    });
+    return Array.from(dependencies.keys());
+  };
+  const { transform } = await config.transformer.getTransformOptions(
+    entryFiles,
+    { dev: options.dev, hot: options.hot, platform: options.platform },
+    getDependencies
+  );
+  return {
+    ...baseOptions,
+    inlineRequires: transform.inlineRequires || false,
+    experimentalImportSupport: transform.experimentalImportSupport || false,
+    unstable_disableES6Transforms: transform.unstable_disableES6Transforms || false,
+    nonInlinedRequires: transform.nonInlinedRequires || baseIgnoredInlineRequires,
+    type: "module"
+  };
+}
+function removeInlineRequiresBlockListFromOptions(path2, inlineRequires) {
+  if (typeof inlineRequires === "object") {
+    return !(path2 in inlineRequires.blockList);
+  }
+  return inlineRequires;
+}
+async function getTransformFn(entryFiles, bundler, deltaBundler, config, options, resolverOptions) {
+  const { inlineRequires, ...transformOptions } = await calcTransformerOptions(
+    entryFiles,
+    bundler,
+    deltaBundler,
+    config,
+    options,
+    resolverOptions
+  );
+  return async (modulePath, requireContext) => {
+    let templateBuffer;
+    if (requireContext) {
+      const graph = await bundler.getDependencyGraph();
+      const files = graph.matchFilesWithContext(requireContext.from, {
+        filter: requireContext.filter,
+        recursive: requireContext.recursive
+      });
+      const template = (0, import_contextModuleTemplates.getContextModuleTemplate)(requireContext.mode, requireContext.from, files);
+      templateBuffer = Buffer.from(template);
+    }
+    return await bundler.transformFile(
+      modulePath,
+      {
+        ...transformOptions,
+        type: getType(transformOptions.type, modulePath, config.resolver.assetExts),
+        inlineRequires: removeInlineRequiresBlockListFromOptions(modulePath, inlineRequires)
+      },
+      templateBuffer
+    );
+  };
+}
+function getType(type, filePath, assetExts) {
+  if (type === "script") {
+    return type;
+  }
+  if (assetExts.indexOf(path.extname(filePath).slice(1)) !== -1) {
+    return "asset";
+  }
+  return "module";
+}
+async function getResolveDependencyFn(bundler, platform, resolverOptions) {
+  const dependencyGraph = await await bundler.getDependencyGraph();
+  return (from, to) => dependencyGraph.resolveDependency(from, to, platform ?? null, resolverOptions);
+}
+module.exports = {
+  getTransformFn,
+  getResolveDependencyFn
+};

package/dist/vendors/metro/src/node-haste/DependencyGraph/ModuleResolution.js

@@ -0,0 +1,221 @@
+"use strict";
+const { codeFrameColumns } = require("@babel/code-frame");
+const fs = require("fs");
+const invariant = require("invariant");
+const Resolver = require("metro-resolver");
+const path = require("path");
+const util = require("util");
+class ModuleResolver {
+  _options;
+  // A module representing the project root, used as the origin when resolving `emptyModulePath`.
+  _projectRootFakeModule;
+  // An empty module, the result of resolving `emptyModulePath` from the project root.
+  _cachedEmptyModule;
+  // $FlowFixMe[missing-local-annot]
+  constructor(options) {
+    this._options = options;
+    const { projectRoot, moduleCache } = this._options;
+    this._projectRootFakeModule = {
+      path: path.join(projectRoot, "_"),
+      getPackage: () => moduleCache.getPackageOf(this._projectRootFakeModule.path),
+      isHaste() {
+        throw new Error("not implemented");
+      },
+      getName() {
+        throw new Error("not implemented");
+      }
+    };
+  }
+  _getEmptyModule() {
+    let emptyModule = this._cachedEmptyModule;
+    if (!emptyModule) {
+      emptyModule = this.resolveDependency(
+        this._projectRootFakeModule,
+        this._options.emptyModulePath,
+        false,
+        null,
+        /* resolverOptions */
+        {}
+      );
+      this._cachedEmptyModule = emptyModule;
+    }
+    return emptyModule;
+  }
+  _redirectRequire(fromModule, modulePath) {
+    const moduleCache = this._options.moduleCache;
+    try {
+      if (modulePath.startsWith(".")) {
+        const fromPackage = fromModule.getPackage();
+        if (fromPackage) {
+          const fromPackagePath = "./" + path.relative(path.dirname(fromPackage.path), path.resolve(path.dirname(fromModule.path), modulePath));
+          let redirectedPath = fromPackage.redirectRequire(fromPackagePath, this._options.mainFields);
+          if (redirectedPath !== false) {
+            redirectedPath = "./" + path.relative(
+              path.dirname(fromModule.path),
+              path.resolve(path.dirname(fromPackage.path), redirectedPath)
+            );
+          }
+          return redirectedPath;
+        }
+      } else {
+        const pck = path.isAbsolute(modulePath) ? moduleCache.getPackageOf(modulePath) : fromModule.getPackage();
+        if (pck) {
+          return pck.redirectRequire(modulePath, this._options.mainFields);
+        }
+      }
+    } catch (err) {
+    }
+    return modulePath;
+  }
+  resolveDependency(fromModule, moduleName, allowHaste, platform, resolverOptions) {
+    try {
+      const result = Resolver.resolve(
+        {
+          ...this._options,
+          customResolverOptions: resolverOptions.customResolverOptions ?? {},
+          originModulePath: fromModule.path,
+          redirectModulePath: (modulePath) => this._redirectRequire(fromModule, modulePath),
+          allowHaste,
+          platform,
+          resolveHasteModule: (name) => this._options.moduleMap.getModule(name, platform, true),
+          resolveHastePackage: (name) => this._options.moduleMap.getPackage(name, platform, true),
+          getPackageMainPath: this._getPackageMainPath
+        },
+        moduleName,
+        platform
+      );
+      return this._getFileResolvedModule(result);
+    } catch (error) {
+      if (error instanceof Resolver.FailedToResolvePathError) {
+        const { candidates } = error;
+        throw new UnableToResolveError(
+          fromModule.path,
+          moduleName,
+          [
+            "\n\nNone of these files exist:",
+            `  * ${Resolver.formatFileCandidates(this._removeRoot(candidates.file))}`,
+            `  * ${Resolver.formatFileCandidates(this._removeRoot(candidates.dir))}`
+          ].join("\n"),
+          {
+            cause: error
+          }
+        );
+      }
+      if (error instanceof Resolver.FailedToResolveNameError) {
+        const dirPaths = error.dirPaths;
+        const extraPaths = error.extraPaths;
+        const displayDirPaths = dirPaths.filter((dirPath) => this._options.dirExists(dirPath)).map((dirPath) => path.relative(this._options.projectRoot, dirPath)).concat(extraPaths);
+        const hint = displayDirPaths.length ? " or in these directories:" : "";
+        throw new UnableToResolveError(
+          fromModule.path,
+          moduleName,
+          [
+            `${moduleName} could not be found within the project${hint || "."}`,
+            ...displayDirPaths.map((dirPath) => `  ${dirPath}`)
+          ].join("\n"),
+          {
+            cause: error
+          }
+        );
+      }
+      throw error;
+    }
+  }
+  _getPackageMainPath = (packageJsonPath) => {
+    const package_ = this._options.moduleCache.getPackage(packageJsonPath);
+    return package_.getMain(this._options.mainFields);
+  };
+  /**
+   * FIXME: get rid of this function and of the reliance on `TModule`
+   * altogether, return strongly typed resolutions at the top-level instead.
+   */
+  _getFileResolvedModule(resolution) {
+    switch (resolution.type) {
+      case "sourceFile":
+        return this._options.moduleCache.getModule(resolution.filePath);
+      case "assetFiles":
+        const arbitrary = getArrayLowestItem(resolution.filePaths);
+        invariant(arbitrary != null, "invalid asset resolution");
+        return this._options.moduleCache.getModule(arbitrary);
+      case "empty":
+        return this._getEmptyModule();
+      default:
+        resolution.type;
+        throw new Error("invalid type");
+    }
+  }
+  _removeRoot(candidates) {
+    if (candidates.filePathPrefix) {
+      candidates.filePathPrefix = path.relative(this._options.projectRoot, candidates.filePathPrefix);
+    }
+    return candidates;
+  }
+}
+function getArrayLowestItem(a) {
+  if (a.length === 0) {
+    return void 0;
+  }
+  let lowest = a[0];
+  for (let i = 1; i < a.length; ++i) {
+    if (a[i] < lowest) {
+      lowest = a[i];
+    }
+  }
+  return lowest;
+}
+class UnableToResolveError extends Error {
+  /**
+   * File path of the module that tried to require a module, ex. `/js/foo.js`.
+   */
+  originModulePath;
+  /**
+   * The name of the module that was required, no necessarily a path,
+   * ex. `./bar`, or `invariant`.
+   */
+  targetModuleName;
+  /**
+   * Original error that causes this error
+   */
+  cause;
+  constructor(originModulePath, targetModuleName, message, options) {
+    super();
+    this.originModulePath = originModulePath;
+    this.targetModuleName = targetModuleName;
+    const codeFrameMessage = this.buildCodeFrameMessage();
+    this.message = util.format("Unable to resolve module %s from %s: %s", targetModuleName, originModulePath, message) + (codeFrameMessage ? "\n" + codeFrameMessage : "");
+    this.cause = options?.cause;
+  }
+  buildCodeFrameMessage() {
+    let file;
+    try {
+      file = fs.readFileSync(this.originModulePath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT" || error.code === "EISDIR") {
+        return null;
+      }
+      throw error;
+    }
+    const lines = file.split("\n");
+    let lineNumber = 0;
+    let column = -1;
+    for (let line = 0; line < lines.length; line++) {
+      const columnLocation = lines[line].lastIndexOf(this.targetModuleName);
+      if (columnLocation >= 0) {
+        lineNumber = line;
+        column = columnLocation;
+        break;
+      }
+    }
+    return codeFrameColumns(
+      fs.readFileSync(this.originModulePath, "utf8"),
+      {
+        start: { column: column + 1, line: lineNumber + 1 }
+      },
+      { forceColor: process.env.NODE_ENV !== "test" }
+    );
+  }
+}
+module.exports = {
+  ModuleResolver,
+  UnableToResolveError
+};

package/dist/vendors/metro/src/node-haste/DependencyGraph/createHasteMap.js

@@ -0,0 +1,71 @@
+"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_metro_file_map = __toESM(require("metro-file-map"));
+const ci = require("ci-info");
+const path = require("path");
+function getIgnorePattern(config) {
+  const { blockList, blacklistRE } = config.resolver;
+  const ignorePattern = blacklistRE || blockList;
+  if (!ignorePattern) {
+    return / ^/;
+  }
+  const combine = (regexes) => new RegExp(regexes.map((regex) => "(" + regex.source.replace(/\//g, path.sep) + ")").join("|"));
+  if (Array.isArray(ignorePattern)) {
+    return combine(ignorePattern);
+  }
+  return ignorePattern;
+}
+function createHasteMap(config, options) {
+  const dependencyExtractor = options?.extractDependencies === false ? null : config.resolver.dependencyExtractor;
+  const computeDependencies = dependencyExtractor != null;
+  return import_metro_file_map.default.create({
+    cacheManagerFactory: config?.unstable_fileMapCacheManagerFactory ?? ((buildParameters) => new import_metro_file_map.DiskCacheManager({
+      buildParameters,
+      cacheDirectory: config.fileMapCacheDirectory ?? config.hasteMapCacheDirectory,
+      cacheFilePrefix: options?.cacheFilePrefix
+    })),
+    perfLogger: config.unstable_perfLogger?.subSpan("hasteMap") ?? null,
+    computeDependencies,
+    computeSha1: true,
+    dependencyExtractor: config.resolver.dependencyExtractor,
+    extensions: Array.from(
+      /* @__PURE__ */ new Set([...config.resolver.sourceExts, ...config.resolver.assetExts, ...config.watcher.additionalExts])
+    ),
+    forceNodeFilesystemAPI: !config.resolver.useWatchman,
+    hasteImplModulePath: config.resolver.hasteImplModulePath,
+    ignorePattern: getIgnorePattern(config),
+    maxWorkers: config.maxWorkers,
+    mocksPattern: "",
+    platforms: config.resolver.platforms,
+    retainAllFiles: true,
+    resetCache: config.resetCache,
+    rootDir: config.projectRoot,
+    roots: config.watchFolders,
+    throwOnModuleCollision: options?.throwOnModuleCollision ?? true,
+    useWatchman: config.resolver.useWatchman,
+    watch: options?.watch == null ? !ci.isCI : options.watch,
+    watchmanDeferStates: config.watcher.watchman.deferStates
+  });
+}
+module.exports = createHasteMap;