@granite-js/mpack 0.0.1

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/getSourceMapInfo.js

@@ -0,0 +1,16 @@
+"use strict";
+const { getJsOutput } = require("./js");
+function getSourceMapInfo(module2, options) {
+  return {
+    ...getJsOutput(module2).data,
+    path: module2.path,
+    source: options.excludeSource ? "" : getModuleSource(module2)
+  };
+}
+function getModuleSource(module2) {
+  if (getJsOutput(module2).type === "js/module/asset") {
+    return "";
+  }
+  return module2.getSource().toString();
+}
+module.exports = getSourceMapInfo;

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/getTransitiveDependencies.js

@@ -0,0 +1,21 @@
+"use strict";
+function getTransitiveDependencies(path, graph) {
+  const dependencies = _getDeps(path, graph, /* @__PURE__ */ new Set());
+  dependencies.delete(path);
+  return dependencies;
+}
+function _getDeps(path, graph, deps) {
+  if (deps.has(path)) {
+    return deps;
+  }
+  const module2 = graph.dependencies.get(path);
+  if (!module2) {
+    return deps;
+  }
+  deps.add(path);
+  for (const dependency of module2.dependencies.values()) {
+    _getDeps(dependency.absolutePath, graph, deps);
+  }
+  return deps;
+}
+module.exports = getTransitiveDependencies;

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

@@ -0,0 +1,43 @@
+"use strict";
+const invariant = require("invariant");
+const { addParamsToDefineCall } = require("metro-transform-plugins");
+const path = require("path");
+function wrapModule(module2, options) {
+  const output = getJsOutput(module2);
+  if (output.type.startsWith("js/script")) {
+    return output.data.code;
+  }
+  const moduleId = options.createModuleId(module2.path);
+  const params = [
+    moduleId,
+    Array.from(module2.dependencies.values()).map((dependency) => options.createModuleId(dependency.absolutePath))
+  ];
+  if (options.dev) {
+    params.push(path.relative(options.projectRoot, module2.path));
+  }
+  return addParamsToDefineCall(output.data.code, ...params);
+}
+function getJsOutput(module2) {
+  const jsModules = module2.output.filter(({ type }) => type.startsWith("js/"));
+  invariant(
+    jsModules.length === 1,
+    `Modules must have exactly one JS output, but ${module2.path ?? "unknown module"} has ${jsModules.length} JS outputs.`
+  );
+  const jsOutput = jsModules[0];
+  invariant(
+    Number.isFinite(jsOutput.data.lineCount),
+    `JS output must populate lineCount, but ${module2.path ?? "unknown module"} has ${jsOutput.type} output with lineCount '${jsOutput.data.lineCount}'`
+  );
+  return jsOutput;
+}
+function isJsModule(module2) {
+  return module2.output.filter(isJsOutput).length > 0;
+}
+function isJsOutput(output) {
+  return output.type.startsWith("js/");
+}
+module.exports = {
+  getJsOutput,
+  isJsModule,
+  wrapModule
+};

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/processBytecodeModules.js

@@ -0,0 +1,13 @@
+"use strict";
+const { isBytecodeModule, wrapModule } = require("./bytecode");
+function processBytecodeModules(modules, { filter = () => true, createModuleId, dev, projectRoot }) {
+  return [...modules].filter(isBytecodeModule).filter(filter).map((module2) => [
+    module2,
+    wrapModule(module2, {
+      createModuleId,
+      dev,
+      projectRoot
+    })
+  ]);
+}
+module.exports = processBytecodeModules;

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/processModules.js

@@ -0,0 +1,13 @@
+"use strict";
+const { isJsModule, wrapModule } = require("./js");
+function processModules(modules, { filter = () => true, createModuleId, dev, projectRoot }) {
+  return [...modules].filter(isJsModule).filter(filter).map((module2) => [
+    module2,
+    wrapModule(module2, {
+      createModuleId,
+      dev,
+      projectRoot
+    })
+  ]);
+}
+module.exports = processModules;

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

@@ -0,0 +1,66 @@
+"use strict";
+const { isJsModule, wrapModule } = require("./helpers/js");
+const { addParamsToDefineCall } = require("metro-transform-plugins");
+const path = require("path");
+const url = require("url");
+function generateModules(sourceModules, graph, options) {
+  const modules = [];
+  for (const module2 of sourceModules) {
+    if (isJsModule(module2)) {
+      const getURL = (extension) => {
+        options.clientUrl.pathname = path.relative(
+          options.projectRoot,
+          path.join(path.dirname(module2.path), path.basename(module2.path, path.extname(module2.path)) + "." + extension)
+        );
+        return url.format(options.clientUrl);
+      };
+      const sourceMappingURL = getURL("map");
+      const sourceURL = getURL("bundle");
+      const code = prepareModule(module2, graph, options) + `
+//# sourceMappingURL=${sourceMappingURL}
+//# sourceURL=${sourceURL}
+`;
+      modules.push({
+        module: [options.createModuleId(module2.path), code],
+        sourceMappingURL,
+        sourceURL
+      });
+    }
+  }
+  return modules;
+}
+function prepareModule(module2, graph, options) {
+  const code = wrapModule(module2, {
+    ...options,
+    dev: true
+  });
+  const inverseDependencies = getInverseDependencies(module2.path, graph);
+  const inverseDependenciesById = /* @__PURE__ */ Object.create(null);
+  Object.keys(inverseDependencies).forEach((path2) => {
+    inverseDependenciesById[options.createModuleId(path2)] = inverseDependencies[path2].map(options.createModuleId);
+  });
+  return addParamsToDefineCall(code, inverseDependenciesById);
+}
+function getInverseDependencies(path2, graph, inverseDependencies = {}) {
+  if (path2 in inverseDependencies) {
+    return inverseDependencies;
+  }
+  const module2 = graph.dependencies.get(path2);
+  if (!module2) {
+    return inverseDependencies;
+  }
+  inverseDependencies[path2] = [];
+  for (const inverse of module2.inverseDependencies) {
+    inverseDependencies[path2].push(inverse);
+    getInverseDependencies(inverse, graph, inverseDependencies);
+  }
+  return inverseDependencies;
+}
+function hmrJSBundle(delta, graph, options) {
+  return {
+    added: generateModules(delta.added.values(), graph, options),
+    modified: generateModules(delta.modified.values(), graph, options),
+    deleted: [...delta.deleted].map((path2) => options.createModuleId(path2))
+  };
+}
+module.exports = hmrJSBundle;

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

@@ -0,0 +1,63 @@
+"use strict";
+const getSourceMapInfo = require("./helpers/getSourceMapInfo");
+const { isJsModule } = require("./helpers/js");
+const { fromRawMappings, fromRawMappingsNonBlocking } = require("metro-source-map");
+function getSourceMapInfosImpl(isBlocking, onDone, modules, options) {
+  const sourceMapInfos = [];
+  const modulesToProcess = modules.filter(isJsModule).filter(options.processModuleFilter);
+  function processNextModule() {
+    if (modulesToProcess.length === 0) {
+      return true;
+    }
+    const mod = modulesToProcess.shift();
+    const info = getSourceMapInfo(mod, {
+      excludeSource: options.excludeSource
+    });
+    sourceMapInfos.push(info);
+    return false;
+  }
+  function workLoop() {
+    const time = process.hrtime();
+    while (true) {
+      const isDone = processNextModule();
+      if (isDone) {
+        onDone(sourceMapInfos);
+        break;
+      }
+      if (!isBlocking) {
+        const diff = process.hrtime(time);
+        const NS_IN_MS = 1e6;
+        if (diff[1] > 50 * NS_IN_MS) {
+          setImmediate(workLoop);
+          break;
+        }
+      }
+    }
+  }
+  workLoop();
+}
+function sourceMapGenerator(modules, options) {
+  let sourceMapInfos;
+  getSourceMapInfosImpl(
+    true,
+    (infos) => {
+      sourceMapInfos = infos;
+    },
+    modules,
+    options
+  );
+  if (sourceMapInfos == null) {
+    throw new Error("Expected getSourceMapInfosImpl() to finish synchronously.");
+  }
+  return fromRawMappings(sourceMapInfos);
+}
+async function sourceMapGeneratorNonBlocking(modules, options) {
+  const sourceMapInfos = await new Promise((resolve) => {
+    getSourceMapInfosImpl(false, resolve, modules, options);
+  });
+  return fromRawMappingsNonBlocking(sourceMapInfos);
+}
+module.exports = {
+  sourceMapGenerator,
+  sourceMapGeneratorNonBlocking
+};

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

@@ -0,0 +1,18 @@
+"use strict";
+const { sourceMapGenerator, sourceMapGeneratorNonBlocking } = require("./sourceMapGenerator");
+function sourceMapObject(modules, options) {
+  const generator = sourceMapGenerator(modules, options);
+  return generator.toMap(void 0, {
+    excludeSource: options.excludeSource
+  });
+}
+async function sourceMapObjectNonBlocking(modules, options) {
+  const generator = await sourceMapGeneratorNonBlocking(modules, options);
+  return generator.toMap(void 0, {
+    excludeSource: options.excludeSource
+  });
+}
+module.exports = {
+  sourceMapObject,
+  sourceMapObjectNonBlocking
+};

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

@@ -0,0 +1,8 @@
+"use strict";
+const { sourceMapGenerator } = require("./sourceMapGenerator");
+function sourceMapString(modules, options) {
+  return sourceMapGenerator(modules, options).toString(void 0, {
+    excludeSource: options.excludeSource
+  });
+}
+module.exports = sourceMapString;

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

@@ -0,0 +1,133 @@
+"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_crypto = __toESM(require("crypto"));
+const getTransformCacheKey = require("./getTransformCacheKey");
+const WorkerFarm = require("./WorkerFarm");
+const assert = require("assert");
+const fs = require("fs");
+const { Cache, stableHash } = require("metro-cache");
+const path = require("path");
+class Transformer {
+  _config;
+  _cache;
+  _baseHash;
+  _getSha1;
+  _workerFarm;
+  constructor(config, getSha1Fn) {
+    this._config = config;
+    this._config.watchFolders.forEach(verifyRootExists);
+    this._cache = new Cache(config.cacheStores);
+    this._getSha1 = getSha1Fn;
+    const {
+      getTransformOptions: _getTransformOptions,
+      transformVariants: _transformVariants,
+      workerPath: _workerPath,
+      ...transformerConfig
+    } = this._config.transformer;
+    const transformerOptions = {
+      transformerPath: this._config.transformerPath,
+      transformerConfig
+    };
+    this._workerFarm = new WorkerFarm(config, transformerOptions);
+    const globalCacheKey = this._cache.isDisabled ? "" : getTransformCacheKey({
+      cacheVersion: this._config.cacheVersion,
+      projectRoot: this._config.projectRoot,
+      transformerConfig: transformerOptions
+    });
+    this._baseHash = stableHash([globalCacheKey]).toString("binary");
+  }
+  async transformFile(filePath, transformerOptions, fileBuffer) {
+    const cache = this._cache;
+    const {
+      customTransformOptions,
+      dev,
+      experimentalImportSupport,
+      hot,
+      inlinePlatform,
+      inlineRequires,
+      minify,
+      nonInlinedRequires,
+      platform,
+      runtimeBytecodeVersion,
+      type,
+      unstable_disableES6Transforms,
+      unstable_transformProfile,
+      ...extra
+    } = transformerOptions;
+    for (const key in extra) {
+      if (hasOwnProperty.call(extra, key)) {
+        throw new Error("Extra keys detected: " + Object.keys(extra).join(", "));
+      }
+    }
+    const localPath = path.relative(this._config.projectRoot, filePath);
+    const partialKey = stableHash([
+      // This is the hash related to the global Bundler config.
+      this._baseHash,
+      // Path.
+      localPath,
+      customTransformOptions,
+      dev,
+      experimentalImportSupport,
+      hot,
+      inlinePlatform,
+      inlineRequires,
+      minify,
+      nonInlinedRequires,
+      platform,
+      runtimeBytecodeVersion,
+      type,
+      unstable_disableES6Transforms,
+      unstable_transformProfile
+    ]);
+    let sha1;
+    if (fileBuffer) {
+      sha1 = import_crypto.default.createHash("sha1").update(fileBuffer).digest("hex");
+    } else {
+      sha1 = this._getSha1(filePath);
+    }
+    let fullKey = Buffer.concat([partialKey, Buffer.from(sha1, "hex")]);
+    const result = await cache.get(fullKey);
+    const data = result ? { result, sha1 } : await this._workerFarm.transform(localPath, transformerOptions, fileBuffer);
+    if (sha1 !== data.sha1) {
+      fullKey = Buffer.concat([partialKey, Buffer.from(data.sha1, "hex")]);
+    }
+    cache.set(fullKey, data.result);
+    return {
+      ...data.result,
+      getSource() {
+        if (fileBuffer) {
+          return fileBuffer;
+        }
+        return fs.readFileSync(filePath);
+      }
+    };
+  }
+  end() {
+    this._workerFarm.kill();
+  }
+}
+function verifyRootExists(root) {
+  assert(fs.statSync(root).isDirectory(), "Root has to be a valid directory");
+}
+module.exports = Transformer;

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

@@ -0,0 +1,64 @@
+"use strict";
+const traverse = require("@babel/traverse").default;
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+function asDeserializedBuffer(value) {
+  if (Buffer.isBuffer(value)) {
+    return value;
+  }
+  if (value && value.type === "Buffer") {
+    return Buffer.from(value.data);
+  }
+  return null;
+}
+async function transform(filename, transformOptions, projectRoot, transformerConfig, fileBuffer) {
+  let data;
+  const fileBufferObject = asDeserializedBuffer(fileBuffer);
+  if (fileBufferObject) {
+    data = fileBufferObject;
+  } else {
+    data = fs.readFileSync(path.resolve(projectRoot, filename));
+  }
+  return transformFile(filename, data, transformOptions, projectRoot, transformerConfig);
+}
+async function transformFile(filename, data, transformOptions, projectRoot, transformerConfig) {
+  const Transformer = require.call(null, transformerConfig.transformerPath);
+  const transformFileStartLogEntry = {
+    action_name: "Transforming file",
+    action_phase: "start",
+    file_name: filename,
+    log_entry_label: "Transforming file",
+    start_timestamp: process.hrtime()
+  };
+  const sha1 = crypto.createHash("sha1").update(data).digest("hex");
+  const result = await Transformer.transform(
+    transformerConfig.transformerConfig,
+    projectRoot,
+    filename,
+    data,
+    transformOptions
+  );
+  traverse.cache.clear();
+  const transformFileEndLogEntry = getEndLogEntry(transformFileStartLogEntry, filename);
+  return {
+    result,
+    sha1,
+    transformFileStartLogEntry,
+    transformFileEndLogEntry
+  };
+}
+function getEndLogEntry(startLogEntry, filename) {
+  const timeDelta = process.hrtime(startLogEntry.start_timestamp);
+  const duration_ms = Math.round((timeDelta[0] * 1e9 + timeDelta[1]) / 1e6);
+  return {
+    action_name: "Transforming file",
+    action_phase: "end",
+    file_name: filename,
+    duration_ms,
+    log_entry_label: "Transforming file"
+  };
+}
+module.exports = {
+  transform
+};

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

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

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

@@ -0,0 +1,128 @@
+"use strict";
+const { Worker: JestWorker } = require("jest-worker");
+const fs = require("fs");
+const path = require("path");
+const { Logger } = require("../../../metro-core/src");
+class WorkerFarm {
+  _config;
+  _transformerConfig;
+  _worker;
+  constructor(config, transformerConfig) {
+    this._config = config;
+    this._transformerConfig = transformerConfig;
+    if (this._config.maxWorkers > 1) {
+      const worker = this._makeFarm(this._config.transformer.workerPath, ["transform"], this._config.maxWorkers);
+      worker.getStdout().on("data", (chunk) => {
+        this._config.reporter.update({
+          type: "worker_stdout_chunk",
+          chunk: chunk.toString("utf8")
+        });
+      });
+      worker.getStderr().on("data", (chunk) => {
+        this._config.reporter.update({
+          type: "worker_stderr_chunk",
+          chunk: chunk.toString("utf8")
+        });
+      });
+      this._worker = worker;
+    } else {
+      this._worker = require.call(null, this._config.transformer.workerPath);
+    }
+  }
+  async kill() {
+    if (this._worker && typeof this._worker.end === "function") {
+      await this._worker.end();
+    }
+  }
+  async transform(filename, options, fileBuffer) {
+    try {
+      const { INTERNAL__transformSync } = this._config.transformer;
+      const buffer = asDeserializedBuffer(fileBuffer);
+      if (buffer) {
+        fileBuffer = buffer;
+      } else {
+        fileBuffer = fs.readFileSync(path.resolve(this._config.projectRoot, filename));
+      }
+      if (typeof INTERNAL__transformSync === "function") {
+        fileBuffer = Buffer.from(INTERNAL__transformSync(filename, fileBuffer.toString("utf-8")));
+      }
+      const data = await this._worker.transform(
+        filename,
+        options,
+        this._config.projectRoot,
+        this._transformerConfig,
+        fileBuffer
+      );
+      Logger.log(data.transformFileStartLogEntry);
+      Logger.log(data.transformFileEndLogEntry);
+      return {
+        result: data.result,
+        sha1: data.sha1
+      };
+    } catch (err) {
+      if (err.loc) {
+        throw this._formatBabelError(err, filename);
+      } else {
+        throw this._formatGenericError(err, filename);
+      }
+    }
+  }
+  _makeFarm(workerPath, exposedMethods, numWorkers) {
+    const env = {
+      ...process.env,
+      // Force color to print syntax highlighted code frames.
+      FORCE_COLOR: 1
+    };
+    return new JestWorker(workerPath, {
+      computeWorkerKey: this._config.stickyWorkers ? (
+        // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+        this._computeWorkerKey
+      ) : void 0,
+      exposedMethods,
+      forkOptions: { env },
+      numWorkers
+    });
+  }
+  _computeWorkerKey(method, filename) {
+    if (method === "transform") {
+      return filename;
+    }
+    return null;
+  }
+  _formatGenericError(err, filename) {
+    const error = new TransformError(`${filename}: ${err.message}`);
+    return Object.assign(error, {
+      stack: (err.stack || "").split("\n").slice(0, -1).join("\n"),
+      lineNumber: 0
+    });
+  }
+  _formatBabelError(err, filename) {
+    const error = new TransformError(
+      `${err.type || "Error"}${err.message.includes(filename) ? "" : " in " + filename}: ${err.message}`
+    );
+    return Object.assign(error, {
+      stack: err.stack,
+      snippet: err.codeFrame,
+      lineNumber: err.loc.line,
+      column: err.loc.column,
+      filename
+    });
+  }
+}
+class TransformError extends SyntaxError {
+  type = "TransformError";
+  constructor(message) {
+    super(message);
+    Error.captureStackTrace && Error.captureStackTrace(this, TransformError);
+  }
+}
+function asDeserializedBuffer(value) {
+  if (Buffer.isBuffer(value)) {
+    return value;
+  }
+  if (value && value.type === "Buffer") {
+    return Buffer.from(value.data);
+  }
+  return null;
+}
+module.exports = WorkerFarm;

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

@@ -0,0 +1,20 @@
+"use strict";
+const VERSION = require("../../../../constants").VERSION;
+const crypto = require("crypto");
+const getCacheKey = require("metro-cache-key");
+function getTransformCacheKey(opts) {
+  const { transformerPath, transformerConfig } = opts.transformerConfig;
+  const Transformer = require.call(null, transformerPath);
+  const transformerKey = Transformer.getCacheKey ? Transformer.getCacheKey(transformerConfig) : "";
+  return crypto.createHash("sha1").update(
+    [
+      "metro-cache",
+      VERSION,
+      opts.cacheVersion,
+      getCacheKey([require.resolve(transformerPath)]),
+      transformerKey,
+      transformerConfig.globalPrefix
+    ].join("$")
+  ).digest("hex");
+}
+module.exports = getTransformCacheKey;