@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/vendors/@react-native-community/cli-server-api/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cli_server_api_exports = {};
+module.exports = __toCommonJS(cli_server_api_exports);
+__reExport(cli_server_api_exports, require("./createWebSocketEndpoints"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./createWebSocketEndpoints")
+});

package/dist/vendors/index.d.ts

@@ -0,0 +1,27 @@
+import TerminalReporter from './metro/src/lib/TerminalReporter';
+import { getDefaultValues } from './metro-config/src/defaults';
+import { loadConfig, mergeConfig } from './metro-config/src/loadConfig';
+import Terminal from './metro-core/src/Terminal';
+import InspectorProxy from './metro-inspector-proxy/src/InspectorProxy';
+declare const vendorModules: {
+    readonly metro: {
+        readonly Metro: {
+            runServer(config: any, options: any): Promise<any>;
+            runBuild(config: any, options: any): Promise<any>;
+        };
+        readonly TerminalReporter: typeof TerminalReporter;
+    };
+    readonly 'metro-config': {
+        readonly getDefaultValues: typeof getDefaultValues;
+        readonly loadConfig: typeof loadConfig;
+        readonly mergeConfig: typeof mergeConfig;
+    };
+    readonly 'metro-core': {
+        readonly Terminal: typeof Terminal;
+    };
+    readonly 'metro-inspector-proxy': {
+        readonly InspectorProxy: typeof InspectorProxy;
+    };
+};
+export declare function getModule<Source extends keyof typeof vendorModules>(source: Source): (typeof vendorModules)[Source];
+export {};

package/dist/vendors/index.js

@@ -0,0 +1,63 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vendors_exports = {};
+__export(vendors_exports, {
+  getModule: () => getModule
+});
+module.exports = __toCommonJS(vendors_exports);
+var import_src = __toESM(require("./metro/src"));
+var import_TerminalReporter = __toESM(require("./metro/src/lib/TerminalReporter"));
+var import_defaults = require("./metro-config/src/defaults");
+var import_loadConfig = require("./metro-config/src/loadConfig");
+var import_Terminal = __toESM(require("./metro-core/src/Terminal"));
+var import_InspectorProxy = __toESM(require("./metro-inspector-proxy/src/InspectorProxy"));
+const vendorModules = {
+  metro: {
+    Metro: import_src.default,
+    TerminalReporter: import_TerminalReporter.default
+  },
+  "metro-config": {
+    getDefaultValues: import_defaults.getDefaultValues,
+    loadConfig: import_loadConfig.loadConfig,
+    mergeConfig: import_loadConfig.mergeConfig
+  },
+  "metro-core": {
+    Terminal: import_Terminal.default
+  },
+  "metro-inspector-proxy": {
+    InspectorProxy: import_InspectorProxy.default
+  }
+};
+function getModule(source) {
+  return vendorModules[source];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getModule
+});

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

@@ -0,0 +1,159 @@
+"use strict";
+const { isAssetTypeAnImage } = require("./Bundler/util");
+const AssetPaths = require("./node-haste/lib/AssetPaths");
+const crypto = require("crypto");
+const denodeify = require("denodeify");
+const fs = require("fs");
+const imageSize = require("image-size");
+const path = require("path");
+const readDir = denodeify(fs.readdir);
+const readFile = denodeify(fs.readFile);
+const hashFiles = denodeify(function hashFilesCb(files, hash, callback) {
+  if (!files.length) {
+    callback(null);
+    return;
+  }
+  const file = files.shift();
+  fs.readFile(file, (err, data) => {
+    if (err) {
+      callback(err);
+      return;
+    } else {
+      hash.update(data);
+      hashFilesCb(files, hash, callback);
+    }
+  });
+});
+function buildAssetMap(dir, files, platform) {
+  const platforms = new Set(platform != null ? [platform] : []);
+  const assets = files.map((file) => AssetPaths.tryParse(file, platforms));
+  const map = /* @__PURE__ */ new Map();
+  assets.forEach(function(asset, i) {
+    if (asset == null) {
+      return;
+    }
+    const file = files[i];
+    const assetKey = getAssetKey(asset.assetName, asset.platform);
+    let record = map.get(assetKey);
+    if (!record) {
+      record = {
+        scales: [],
+        files: []
+      };
+      map.set(assetKey, record);
+    }
+    let insertIndex;
+    const length = record.scales.length;
+    for (insertIndex = 0; insertIndex < length; insertIndex++) {
+      if (asset.resolution < record.scales[insertIndex]) {
+        break;
+      }
+    }
+    record.scales.splice(insertIndex, 0, asset.resolution);
+    record.files.splice(insertIndex, 0, path.join(dir, file));
+  });
+  return map;
+}
+function getAssetKey(assetName, platform) {
+  if (platform != null) {
+    return `${assetName} : ${platform}`;
+  } else {
+    return assetName;
+  }
+}
+async function getAbsoluteAssetRecord(assetPath, platform = null) {
+  const filename = path.basename(assetPath);
+  const dir = path.dirname(assetPath);
+  const files = await readDir(dir);
+  const assetData = AssetPaths.parse(filename, new Set(platform != null ? [platform] : []));
+  const map = buildAssetMap(dir, files, platform);
+  let record;
+  if (platform != null) {
+    record = map.get(getAssetKey(assetData.assetName, platform)) || map.get(assetData.assetName);
+  } else {
+    record = map.get(assetData.assetName);
+  }
+  if (!record) {
+    throw new Error(`Asset not found: ${assetPath} for platform: ${platform ?? "(unspecified)"}`);
+  }
+  return record;
+}
+async function getAbsoluteAssetInfo(assetPath, platform = null) {
+  const nameData = AssetPaths.parse(assetPath, new Set(platform != null ? [platform] : []));
+  const { name, type } = nameData;
+  const { scales, files } = await getAbsoluteAssetRecord(assetPath, platform);
+  const hasher = crypto.createHash("md5");
+  if (files.length > 0) {
+    await hashFiles(Array.from(files), hasher);
+  }
+  return { files, hash: hasher.digest("hex"), name, scales, type };
+}
+async function getAssetData(assetPath, localPath, assetDataPlugins, platform = null, publicPath) {
+  let assetUrlPath = localPath.startsWith("..") ? publicPath.replace(/\/$/, "") + "/" + path.dirname(localPath) : path.join(publicPath, path.dirname(localPath));
+  if (path.sep === "\\") {
+    assetUrlPath = assetUrlPath.replace(/\\/g, "/");
+  }
+  const isImage = isAssetTypeAnImage(path.extname(assetPath).slice(1));
+  const assetInfo = await getAbsoluteAssetInfo(assetPath, platform);
+  const isImageInput = assetInfo.files[0].includes(".zip/") ? fs.readFileSync(assetInfo.files[0]) : assetInfo.files[0];
+  const dimensions = isImage ? imageSize(isImageInput) : null;
+  const scale = assetInfo.scales[0];
+  const assetData = {
+    __packager_asset: true,
+    fileSystemLocation: path.dirname(assetPath),
+    httpServerLocation: assetUrlPath,
+    width: dimensions ? dimensions.width / scale : void 0,
+    height: dimensions ? dimensions.height / scale : void 0,
+    scales: assetInfo.scales,
+    files: assetInfo.files,
+    hash: assetInfo.hash,
+    name: assetInfo.name,
+    type: assetInfo.type
+  };
+  return await applyAssetDataPlugins(assetDataPlugins, assetData);
+}
+async function applyAssetDataPlugins(assetDataPlugins, assetData) {
+  if (!assetDataPlugins.length) {
+    return assetData;
+  }
+  const [currentAssetPlugin, ...remainingAssetPlugins] = assetDataPlugins;
+  const assetPluginFunction = require(currentAssetPlugin);
+  const resultAssetData = await assetPluginFunction(assetData);
+  return await applyAssetDataPlugins(remainingAssetPlugins, resultAssetData);
+}
+async function getAssetFiles(assetPath, platform = null) {
+  const assetData = await getAbsoluteAssetRecord(assetPath, platform);
+  return assetData.files;
+}
+async function getAsset(relativePath, projectRoot, watchFolders, platform = null, assetExts) {
+  const assetData = AssetPaths.parse(relativePath, new Set(platform != null ? [platform] : []));
+  const absolutePath = path.resolve(projectRoot, relativePath);
+  if (!assetExts.includes(assetData.type)) {
+    throw new Error(`'${relativePath}' cannot be loaded as its extension is not registered in assetExts`);
+  }
+  if (!pathBelongsToRoots(absolutePath, [projectRoot, ...watchFolders])) {
+    throw new Error(
+      `'${relativePath}' could not be found, because it cannot be found in the project root or any watch folder`
+    );
+  }
+  const record = await getAbsoluteAssetRecord(absolutePath, platform);
+  for (let i = 0; i < record.scales.length; i++) {
+    if (record.scales[i] >= assetData.resolution) {
+      return readFile(record.files[i]);
+    }
+  }
+  return readFile(record.files[record.files.length - 1]);
+}
+function pathBelongsToRoots(pathToCheck, roots) {
+  for (const rootFolder of roots) {
+    if (pathToCheck.startsWith(path.resolve(rootFolder))) {
+      return true;
+    }
+  }
+  return false;
+}
+module.exports = {
+  getAsset,
+  getAssetData,
+  getAssetFiles
+};

package/dist/vendors/metro/src/Bundler/util.js

@@ -0,0 +1,131 @@
+"use strict";
+const babylon = require("@babel/parser");
+const template = require("@babel/template").default;
+const babelTypes = require("@babel/types");
+const nullthrows = require("nullthrows");
+const assetPropertyBlockList = /* @__PURE__ */ new Set(["files", "fileSystemLocation", "path"]);
+function generateAssetCodeFileAst(assetRegistryPath, assetDescriptor) {
+  const properDescriptor = filterObject(assetDescriptor, assetPropertyBlockList);
+  const descriptorAst = babylon.parseExpression(JSON.stringify(properDescriptor));
+  const t = babelTypes;
+  const buildRequire = template.statement(`
+    module.exports = require(ASSET_REGISTRY_PATH).registerAsset(DESCRIPTOR_AST)
+  `);
+  return t.file(
+    t.program([
+      buildRequire({
+        ASSET_REGISTRY_PATH: t.stringLiteral(assetRegistryPath),
+        DESCRIPTOR_AST: descriptorAst
+      })
+    ])
+  );
+}
+function generateRemoteAssetCodeFileAst(assetUtilsPath, assetDescriptor, remoteServer, remoteFileMap) {
+  const t = babelTypes;
+  const file = remoteFileMap[assetDescriptor.fileSystemLocation];
+  const descriptor = file && file[assetDescriptor.name];
+  const data = {};
+  if (!descriptor) {
+    return null;
+  }
+  for (const scale in descriptor) {
+    data[+scale] = descriptor[+scale].handle;
+  }
+  const astData = babylon.parseExpression(JSON.stringify(data));
+  const URI = t.stringLiteral(remoteServer);
+  const WIDTH = t.numericLiteral(nullthrows(assetDescriptor.width));
+  const HEIGHT = t.numericLiteral(nullthrows(assetDescriptor.height));
+  const buildRequire = template.program(`
+    const {pickScale, getUrlCacheBreaker}= require(ASSET_UTILS_PATH);
+    module.exports = {
+      "width": WIDTH,
+      "height": HEIGHT,
+      "uri": URI + OBJECT_AST[pickScale(SCALE_ARRAY)] + getUrlCacheBreaker()
+    };
+  `);
+  return t.file(
+    buildRequire({
+      WIDTH,
+      HEIGHT,
+      URI,
+      OBJECT_AST: astData,
+      ASSET_UTILS_PATH: t.stringLiteral(assetUtilsPath),
+      SCALE_ARRAY: t.arrayExpression(
+        Object.keys(descriptor).map(Number).sort((a, b) => a - b).map((scale) => t.numericLiteral(scale))
+      )
+    })
+  );
+}
+function isAssetTypeAnImage(type) {
+  return ["png", "jpg", "jpeg", "bmp", "gif", "webp", "psd", "svg", "tiff"].indexOf(type) !== -1;
+}
+function filterObject(object, blockList) {
+  const copied = { ...object };
+  for (const key of blockList) {
+    delete copied[key];
+  }
+  return copied;
+}
+function createRamBundleGroups(ramGroups, groupableModules, subtree) {
+  const byPath = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  groupableModules.forEach((m) => {
+    byPath.set(m.sourcePath, m);
+    byId.set(m.id, m.sourcePath);
+  });
+  const result = new Map(
+    ramGroups.map((modulePath) => {
+      const root = byPath.get(modulePath);
+      if (root == null) {
+        throw Error(`Group root ${modulePath} is not part of the bundle`);
+      }
+      return [
+        root.id,
+        // `subtree` yields the IDs of all transitive dependencies of a module
+        new Set(subtree(root, byPath))
+      ];
+    })
+  );
+  if (ramGroups.length > 1) {
+    const all = new ArrayMap();
+    for (const [parent, children] of result) {
+      for (const module2 of children) {
+        all.get(module2).push(parent);
+      }
+    }
+    const doubles = filter(all, ([, parents]) => parents.length > 1);
+    for (const [moduleId, parents] of doubles) {
+      const parentNames = parents.map(byId.get, byId);
+      const lastName = parentNames.pop();
+      throw new Error(
+        `Module ${byId.get(moduleId) || moduleId} belongs to groups ${parentNames.join(", ")}, and ${String(
+          lastName
+        )}. Ensure that each module is only part of one group.`
+      );
+    }
+  }
+  return result;
+}
+function* filter(iterator, predicate) {
+  for (const value of iterator) {
+    if (predicate(value)) {
+      yield value;
+    }
+  }
+}
+class ArrayMap extends Map {
+  get(key) {
+    let array = super.get(key);
+    if (!array) {
+      array = [];
+      this.set(key, array);
+    }
+    return array;
+  }
+}
+module.exports = {
+  createRamBundleGroups,
+  generateAssetCodeFileAst,
+  generateRemoteAssetCodeFileAst,
+  isAssetTypeAnImage
+};

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

@@ -0,0 +1,43 @@
+"use strict";
+const Transformer = require("./DeltaBundler/Transformer");
+const DependencyGraph = require("./node-haste/DependencyGraph");
+class Bundler {
+  _depGraph;
+  _readyPromise;
+  _transformer;
+  constructor(config, options) {
+    this._depGraph = new DependencyGraph(config, options);
+    this._readyPromise = this._depGraph.ready().then(() => {
+      config.reporter.update({ type: "transformer_load_started" });
+      this._transformer = new Transformer(config, (...args) => this._depGraph.getSha1(...args));
+      config.reporter.update({ type: "transformer_load_done" });
+    }).catch((error) => {
+      console.error("Failed to construct transformer: ", error);
+      config.reporter.update({
+        type: "transformer_load_failed",
+        error
+      });
+    });
+  }
+  getWatcher() {
+    return this._depGraph.getWatcher();
+  }
+  async end() {
+    await this._depGraph.ready();
+    this._transformer.end();
+    this._depGraph.end();
+  }
+  async getDependencyGraph() {
+    await this._depGraph.ready();
+    return this._depGraph;
+  }
+  async transformFile(filePath, transformOptions, fileBuffer) {
+    await this._depGraph.ready();
+    return this._transformer.transformFile(filePath, transformOptions, fileBuffer);
+  }
+  // Waits for the bundler to become ready.
+  async ready() {
+    await this._readyPromise;
+  }
+}
+module.exports = Bundler;

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

@@ -0,0 +1,176 @@
+"use strict";
+var import_graphOperations = require("./graphOperations");
+const { EventEmitter } = require("events");
+class DeltaCalculator extends EventEmitter {
+  _changeEventSource;
+  _options;
+  _currentBuildPromise;
+  _deletedFiles = /* @__PURE__ */ new Set();
+  _modifiedFiles = /* @__PURE__ */ new Set();
+  _addedFiles = /* @__PURE__ */ new Set();
+  _graph;
+  constructor(entryPoints, changeEventSource, options) {
+    super();
+    this._options = options;
+    this._changeEventSource = changeEventSource;
+    this._graph = (0, import_graphOperations.createGraph)({
+      entryPoints,
+      transformOptions: this._options.transformOptions
+    });
+    this._changeEventSource.on("change", this._handleMultipleFileChanges);
+  }
+  /**
+   * Stops listening for file changes and clears all the caches.
+   */
+  end() {
+    this._changeEventSource.removeListener("change", this._handleMultipleFileChanges);
+    this.removeAllListeners();
+    this._graph = (0, import_graphOperations.createGraph)({
+      entryPoints: this._graph.entryPoints,
+      transformOptions: this._options.transformOptions
+    });
+    this._modifiedFiles = /* @__PURE__ */ new Set();
+    this._deletedFiles = /* @__PURE__ */ new Set();
+    this._addedFiles = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Main method to calculate the delta of modules. It returns a DeltaResult,
+   * which contain the modified/added modules and the removed modules.
+   */
+  async getDelta({ reset, shallow }) {
+    if (this._currentBuildPromise) {
+      await this._currentBuildPromise;
+    }
+    const modifiedFiles = this._modifiedFiles;
+    this._modifiedFiles = /* @__PURE__ */ new Set();
+    const deletedFiles = this._deletedFiles;
+    this._deletedFiles = /* @__PURE__ */ new Set();
+    const addedFiles = this._addedFiles;
+    this._addedFiles = /* @__PURE__ */ new Set();
+    this._currentBuildPromise = this._getChangedDependencies(modifiedFiles, deletedFiles, addedFiles);
+    let result;
+    const numDependencies = this._graph.dependencies.size;
+    try {
+      result = await this._currentBuildPromise;
+    } catch (error) {
+      modifiedFiles.forEach((file) => this._modifiedFiles.add(file));
+      deletedFiles.forEach((file) => this._deletedFiles.add(file));
+      addedFiles.forEach((file) => this._addedFiles.add(file));
+      if (this._graph.dependencies.size !== numDependencies) {
+        this._graph.dependencies = /* @__PURE__ */ new Map();
+      }
+      throw error;
+    } finally {
+      this._currentBuildPromise = null;
+    }
+    if (reset) {
+      (0, import_graphOperations.reorderGraph)(this._graph, { shallow });
+      return {
+        added: this._graph.dependencies,
+        modified: /* @__PURE__ */ new Map(),
+        deleted: /* @__PURE__ */ new Set(),
+        reset: true
+      };
+    }
+    return result;
+  }
+  /**
+   * Returns the graph with all the dependencies. Each module contains the
+   * needed information to do the traversing (dependencies, inverseDependencies)
+   * plus some metadata.
+   */
+  getGraph() {
+    return this._graph;
+  }
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
+  _handleMultipleFileChanges = ({ eventsQueue }) => {
+    eventsQueue.forEach(this._handleFileChange);
+  };
+  /**
+   * Handles a single file change. To avoid doing any work before it's needed,
+   * the listener only stores the modified file, which will then be used later
+   * when the delta needs to be calculated.
+   */
+  _handleFileChange = ({ type, filePath }) => {
+    let state;
+    if (this._deletedFiles.has(filePath)) {
+      state = "deleted";
+    } else if (this._modifiedFiles.has(filePath)) {
+      state = "modified";
+    } else if (this._addedFiles.has(filePath)) {
+      state = "added";
+    }
+    let nextState;
+    if (type === "delete") {
+      nextState = "deleted";
+    } else if (type === "add") {
+      nextState = state === "deleted" ? "modified" : "added";
+    } else {
+      nextState = state === "added" ? "added" : "modified";
+    }
+    switch (nextState) {
+      case "deleted":
+        this._deletedFiles.add(filePath);
+        this._modifiedFiles.delete(filePath);
+        this._addedFiles.delete(filePath);
+        break;
+      case "added":
+        this._addedFiles.add(filePath);
+        this._deletedFiles.delete(filePath);
+        this._modifiedFiles.delete(filePath);
+        break;
+      case "modified":
+        this._modifiedFiles.add(filePath);
+        this._deletedFiles.delete(filePath);
+        this._addedFiles.delete(filePath);
+        break;
+      default:
+        nextState;
+    }
+    this.emit("change");
+  };
+  async _getChangedDependencies(modifiedFiles, deletedFiles, addedFiles) {
+    if (!this._graph.dependencies.size) {
+      const { added: added2 } = await (0, import_graphOperations.initialTraverseDependencies)(this._graph, this._options);
+      return {
+        added: added2,
+        modified: /* @__PURE__ */ new Map(),
+        deleted: /* @__PURE__ */ new Set(),
+        reset: true
+      };
+    }
+    deletedFiles.forEach((filePath) => {
+      const module2 = this._graph.dependencies.get(filePath);
+      if (module2) {
+        module2.inverseDependencies.forEach((path) => {
+          if (!deletedFiles.has(path)) {
+            modifiedFiles.add(path);
+          }
+        });
+      }
+    });
+    if (this._options.unstable_allowRequireContext) {
+      addedFiles.forEach((filePath) => {
+        (0, import_graphOperations.markModifiedContextModules)(this._graph, filePath, modifiedFiles);
+      });
+    }
+    const modifiedDependencies = Array.from(modifiedFiles).filter((filePath) => this._graph.dependencies.has(filePath));
+    if (modifiedDependencies.length === 0) {
+      return {
+        added: /* @__PURE__ */ new Map(),
+        modified: /* @__PURE__ */ new Map(),
+        deleted: /* @__PURE__ */ new Set(),
+        reset: false
+      };
+    }
+    const { added, modified, deleted } = await (0, import_graphOperations.traverseDependencies)(modifiedDependencies, this._graph, this._options);
+    return {
+      added,
+      modified,
+      deleted,
+      reset: false
+    };
+  }
+}
+module.exports = DeltaCalculator;

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

@@ -0,0 +1,61 @@
+"use strict";
+const getAppendScripts = require("../../lib/getAppendScripts");
+const { getJsOutput } = require("./helpers/js");
+const processBytecodeModules = require("./helpers/processBytecodeModules");
+function baseBytecodeBundle(entryPoint, preModules, graph, options) {
+  for (const module2 of graph.dependencies.values()) {
+    options.createModuleId(module2.path);
+  }
+  const processModulesOptions = {
+    filter: options.processModuleFilter,
+    createModuleId: options.createModuleId,
+    dev: options.dev,
+    projectRoot: options.projectRoot
+  };
+  if (options.modulesOnly) {
+    preModules = [];
+  }
+  const modules = [...graph.dependencies.values()].sort(
+    (a, b) => options.createModuleId(a.path) - options.createModuleId(b.path)
+  );
+  const { compile } = require("metro-hermes-compiler");
+  const post = processBytecodeModules(
+    getAppendScripts(entryPoint, [...preModules, ...modules], graph.importBundleNames, {
+      asyncRequireModulePath: options.asyncRequireModulePath,
+      createModuleId: options.createModuleId,
+      getRunModuleStatement: options.getRunModuleStatement,
+      inlineSourceMap: options.inlineSourceMap,
+      projectRoot: options.projectRoot,
+      runBeforeMainModule: options.runBeforeMainModule,
+      runModule: options.runModule,
+      serverRoot: options.serverRoot,
+      sourceMapUrl: options.sourceMapUrl,
+      sourceUrl: options.sourceUrl
+    }).map((module2) => {
+      return {
+        ...module2,
+        output: [
+          ...module2.output,
+          {
+            type: "bytecode/script/virtual",
+            data: {
+              bytecode: compile(getJsOutput(module2).data.code, {
+                sourceURL: module2.path
+              }).bytecode
+            }
+          }
+        ]
+      };
+    }),
+    processModulesOptions
+  ).flatMap(([module2, bytecodeBundle]) => bytecodeBundle);
+  const processedModules = processBytecodeModules([...graph.dependencies.values()], processModulesOptions).map(
+    ([module2, bytecodeBundle]) => [options.createModuleId(module2.path), bytecodeBundle]
+  );
+  return {
+    pre: processBytecodeModules(preModules, processModulesOptions).flatMap(([_, bytecodeBundle]) => bytecodeBundle),
+    post,
+    modules: processedModules
+  };
+}
+module.exports = baseBytecodeBundle;