@granite-js/mpack 0.0.1

package/dist/vendors/metro-transform-worker/src/index.js

@@ -0,0 +1,430 @@
+"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
+));
+const getMinifier = require("./utils/getMinifier");
+const { transformFromAstSync } = require("@babel/core");
+const generate = require("@babel/generator").default;
+const babylon = require("@babel/parser");
+const types = require("@babel/types");
+const { stableHash } = require("metro-cache");
+const getCacheKey = require("metro-cache-key");
+const { fromRawMappings, toBabelSegments, toSegmentTuple } = require("metro-source-map");
+const metroTransformPlugins = require("metro-transform-plugins");
+const countLines = require("../../metro/src/lib/countLines");
+const {
+  InvalidRequireCallError: InternalInvalidRequireCallError
+} = require("../../metro/src/ModuleGraph/worker/collectDependencies");
+const generateImportNames = require("../../metro/src/ModuleGraph/worker/generateImportNames");
+const JsFileWrapping = require("../../metro/src/ModuleGraph/worker/JsFileWrapping");
+const nullthrows = require("nullthrows");
+function getDynamicDepsBehavior(inPackages, filename) {
+  switch (inPackages) {
+    case "reject":
+      return "reject";
+    case "throwAtRuntime":
+      const isPackage = /(?:^|[/\\])node_modules[/\\]/.test(filename);
+      return isPackage ? inPackages : "reject";
+    default:
+      inPackages;
+      throw new Error(`invalid value for dynamic deps behavior: \`${inPackages}\``);
+  }
+}
+const minifyCode = async (config, projectRoot, filename, code, source, map, reserved = []) => {
+  const sourceMap = fromRawMappings([{ code, source, map, functionMap: null, path: filename }]).toMap(void 0, {});
+  const minify = getMinifier(config.minifierPath);
+  try {
+    const minified = await minify({
+      code,
+      map: sourceMap,
+      filename,
+      reserved,
+      config: config.minifierConfig
+    });
+    return {
+      code: minified.code,
+      map: minified.map ? toBabelSegments(minified.map).map(toSegmentTuple) : []
+    };
+  } catch (error) {
+    if (error.constructor.name === "JS_Parse_Error") {
+      throw new Error(`${error.message} in file ${filename} at ${error.line}:${error.col}`);
+    }
+    throw error;
+  }
+};
+const compileToBytecode = (rawCode, type, options) => {
+  let code = rawCode;
+  if (type.startsWith("js/module")) {
+    const index = code.lastIndexOf(")");
+    code = code.slice(0, index) + ",$$METRO_D[0],$$METRO_D[1],$$METRO_D[2]" + code.slice(index);
+  }
+  const HermesCompiler = require("metro-hermes-compiler");
+  return HermesCompiler.compile(code, options);
+};
+const disabledDependencyTransformer = {
+  transformSyncRequire: () => void 0,
+  transformImportCall: () => void 0,
+  transformJSResource: () => void 0,
+  transformPrefetch: () => void 0,
+  transformIllegalDynamicRequire: () => void 0
+};
+class InvalidRequireCallError extends Error {
+  innerError;
+  filename;
+  constructor(innerError, filename) {
+    super(`${filename}:${innerError.message}`);
+    this.innerError = innerError;
+    this.filename = filename;
+  }
+}
+async function transformJS(file, { config, options, projectRoot }) {
+  let ast = file.ast ?? babylon.parse(file.code, { sourceType: "unambiguous" });
+  const { importDefault, importAll } = generateImportNames(ast);
+  const { directives } = ast.program;
+  if (ast.program.sourceType === "module" && directives != null && directives.findIndex((d) => d.value.value === "use strict") === -1) {
+    directives.push(types.directive(types.directiveLiteral("use strict")));
+  }
+  const plugins = [];
+  const babelPluginOpts = {
+    ...options,
+    inlineableCalls: [importDefault, importAll],
+    importDefault,
+    importAll
+  };
+  if (options.experimentalImportSupport === true) {
+    plugins.push([metroTransformPlugins.importExportPlugin, babelPluginOpts]);
+  }
+  if (options.inlineRequires) {
+    plugins.push([
+      // $FlowFixMe[untyped-import] untyped module
+      require("babel-preset-fbjs/plugins/inline-requires"),
+      {
+        ...babelPluginOpts,
+        ignoredRequires: options.nonInlinedRequires
+      }
+    ]);
+  }
+  plugins.push([metroTransformPlugins.inlinePlugin, babelPluginOpts]);
+  ast = nullthrows(
+    transformFromAstSync(ast, "", {
+      ast: true,
+      babelrc: false,
+      code: false,
+      configFile: false,
+      comments: false,
+      filename: file.filename,
+      plugins,
+      sourceMaps: false,
+      // Not-Cloning the input AST here should be safe because other code paths above this call
+      // are mutating the AST as well and no code is depending on the original AST.
+      // However, switching the flag to false caused issues with ES Modules if `experimentalImportSupport` isn't used https://github.com/facebook/metro/issues/641
+      // either because one of the plugins is doing something funky or Babel messes up some caches.
+      // Make sure to test the above mentioned case before flipping the flag back to false.
+      cloneInputAst: true
+    }).ast
+  );
+  if (!options.dev) {
+    ast = nullthrows(
+      transformFromAstSync(ast, "", {
+        ast: true,
+        babelrc: false,
+        code: false,
+        configFile: false,
+        comments: false,
+        filename: file.filename,
+        plugins: [[metroTransformPlugins.constantFoldingPlugin, babelPluginOpts]],
+        sourceMaps: false,
+        cloneInputAst: false
+      }).ast
+    );
+  }
+  let dependencyMapName = "";
+  let dependencies;
+  let wrappedAst;
+  if (file.type === "js/script") {
+    dependencies = [];
+    wrappedAst = JsFileWrapping.wrapPolyfill(ast);
+  } else {
+    try {
+      const opts = {
+        asyncRequireModulePath: config.asyncRequireModulePath,
+        dependencyTransformer: config.unstable_disableModuleWrapping === true ? disabledDependencyTransformer : void 0,
+        dynamicRequires: getDynamicDepsBehavior(config.dynamicDepsInPackages, file.filename),
+        inlineableCalls: [importDefault, importAll],
+        keepRequireNames: options.dev,
+        allowOptionalDependencies: config.allowOptionalDependencies,
+        dependencyMapName: config.unstable_dependencyMapReservedName,
+        unstable_allowRequireContext: config.unstable_allowRequireContext
+      };
+      const collectDependencies = require(config.unstable_collectDependenciesPath);
+      ({ ast, dependencies, dependencyMapName } = collectDependencies(ast, opts));
+    } catch (error) {
+      if (error instanceof InternalInvalidRequireCallError) {
+        throw new InvalidRequireCallError(error, file.filename);
+      }
+      throw error;
+    }
+    if (config.unstable_disableModuleWrapping === true) {
+      wrappedAst = ast;
+    } else {
+      ({ ast: wrappedAst } = JsFileWrapping.wrapModule(
+        ast,
+        importDefault,
+        importAll,
+        dependencyMapName,
+        config.globalPrefix
+      ));
+    }
+  }
+  const minify = options.minify && options.unstable_transformProfile !== "hermes-canary" && options.unstable_transformProfile !== "hermes-stable";
+  const reserved = [];
+  if (config.unstable_dependencyMapReservedName != null) {
+    reserved.push(config.unstable_dependencyMapReservedName);
+  }
+  if (minify && file.inputFileSize <= config.optimizationSizeLimit && !config.unstable_disableNormalizePseudoGlobals) {
+    reserved.push(
+      ...metroTransformPlugins.normalizePseudoGlobals(wrappedAst, {
+        reservedNames: reserved
+      })
+    );
+  }
+  const result = generate(
+    wrappedAst,
+    {
+      comments: false,
+      compact: config.unstable_compactOutput,
+      filename: file.filename,
+      retainLines: false,
+      sourceFileName: file.filename,
+      sourceMaps: true
+    },
+    file.code
+  );
+  let map = result.rawMappings ? result.rawMappings.map(toSegmentTuple) : [];
+  let code = result.code;
+  if (minify) {
+    ({ map, code } = await minifyCode(config, projectRoot, file.filename, result.code, file.code, map, reserved));
+  }
+  const output = [
+    {
+      data: {
+        code,
+        lineCount: countLines(code),
+        map,
+        functionMap: file.functionMap
+      },
+      type: file.type
+    }
+  ];
+  if (options.runtimeBytecodeVersion != null) {
+    output.push({
+      data: compileToBytecode(code, file.type, {
+        sourceURL: file.filename,
+        sourceMap: fromRawMappings([
+          {
+            code,
+            source: file.code,
+            map,
+            functionMap: null,
+            path: file.filename
+          }
+        ]).toString()
+      }),
+      type: getBytecodeFileType(file.type)
+    });
+  }
+  return {
+    dependencies,
+    output
+  };
+}
+async function transformAsset(file, context) {
+  const assetTransformer = require("./utils/assetTransformer");
+  const { assetRegistryPath, assetPlugins } = context.config;
+  const result = await assetTransformer.transform(
+    getBabelTransformArgs(file, context),
+    assetRegistryPath,
+    assetPlugins
+  );
+  const jsFile = {
+    ...file,
+    type: "js/module/asset",
+    ast: result.ast,
+    functionMap: null
+  };
+  return transformJS(jsFile, context);
+}
+async function transformJSWithBabel(file, context) {
+  const { babelTransformerPath } = context.config;
+  const transformer = require(babelTransformerPath);
+  const transformResult = await transformer.transform(getBabelTransformArgs(file, context));
+  const jsFile = {
+    ...file,
+    ast: transformResult.ast,
+    functionMap: transformResult.functionMap ?? null
+  };
+  return await transformJS(jsFile, context);
+}
+async function transformJSON(file, { options, config, projectRoot }) {
+  let code = config.unstable_disableModuleWrapping === true ? JsFileWrapping.jsonToCommonJS(file.code) : JsFileWrapping.wrapJson(file.code, config.globalPrefix);
+  let map = [];
+  const minify = options.minify && options.unstable_transformProfile !== "hermes-canary" && options.unstable_transformProfile !== "hermes-stable";
+  if (minify) {
+    ({ map, code } = await minifyCode(config, projectRoot, file.filename, code, file.code, map));
+  }
+  let jsType;
+  if (file.type === "asset") {
+    jsType = "js/module/asset";
+  } else if (file.type === "script") {
+    jsType = "js/script";
+  } else {
+    jsType = "js/module";
+  }
+  const output = [
+    {
+      data: { code, lineCount: countLines(code), map, functionMap: null },
+      type: jsType
+    }
+  ];
+  if (options.runtimeBytecodeVersion != null) {
+    output.push({
+      data: compileToBytecode(code, jsType, {
+        sourceURL: file.filename,
+        sourceMap: fromRawMappings([
+          {
+            code,
+            source: file.code,
+            map,
+            functionMap: null,
+            path: file.filename
+          }
+        ]).toString()
+      }),
+      type: getBytecodeFileType(jsType)
+    });
+  }
+  return {
+    dependencies: [],
+    output
+  };
+}
+function getBytecodeFileType(type) {
+  switch (type) {
+    case "js/module/asset":
+      return "bytecode/module/asset";
+    case "js/script":
+      return "bytecode/script";
+    default:
+      type;
+      return "bytecode/module";
+  }
+}
+function getBabelTransformArgs(file, { options, config, projectRoot }) {
+  const additionalBabelConfig = config.INTERNAL__babelConfig ?? {};
+  return {
+    filename: file.filename,
+    options: {
+      ...options,
+      enableBabelRCLookup: config.enableBabelRCLookup,
+      enableBabelRuntime: config.enableBabelRuntime,
+      globalPrefix: config.globalPrefix,
+      hermesParser: config.hermesParser,
+      // Inline requires are now performed at a secondary step. We cannot
+      // unfortunately remove it from the internal transformer, since this one
+      // is used by other tooling, and this would affect it.
+      inlineRequires: false,
+      nonInlinedRequires: [],
+      projectRoot,
+      publicPath: config.publicPath
+    },
+    // MARK: - GRANITE
+    ...additionalBabelConfig,
+    plugins: additionalBabelConfig?.plugins ?? [],
+    filename: file.filename,
+    src: file.code
+  };
+}
+module.exports = {
+  transform: async (config, projectRoot, filename, data, options) => {
+    const context = {
+      config,
+      projectRoot,
+      options
+    };
+    const sourceCode = data.toString("utf8");
+    const { unstable_dependencyMapReservedName } = config;
+    if (unstable_dependencyMapReservedName != null) {
+      const position = sourceCode.indexOf(unstable_dependencyMapReservedName);
+      if (position > -1) {
+        throw new SyntaxError(
+          "Source code contains the reserved string `" + unstable_dependencyMapReservedName + "` at character offset " + position
+        );
+      }
+    }
+    if (filename.endsWith(".json")) {
+      const jsonFile = {
+        filename,
+        inputFileSize: data.length,
+        code: sourceCode,
+        type: options.type
+      };
+      return await transformJSON(jsonFile, context);
+    }
+    if (options.type === "asset") {
+      const file2 = {
+        filename,
+        inputFileSize: data.length,
+        code: sourceCode,
+        type: options.type
+      };
+      return await transformAsset(file2, context);
+    }
+    const file = {
+      filename,
+      inputFileSize: data.length,
+      code: sourceCode,
+      type: options.type === "script" ? "js/script" : "js/module",
+      functionMap: null
+    };
+    return await transformJSWithBabel(file, context);
+  },
+  getCacheKey: (config) => {
+    const { babelTransformerPath, minifierPath, unstable_collectDependenciesPath, ...remainingConfig } = config;
+    const filesKey = getCacheKey([
+      require.resolve(babelTransformerPath),
+      require.resolve(minifierPath),
+      require.resolve("./utils/getMinifier"),
+      require.resolve("./utils/assetTransformer"),
+      require.resolve(unstable_collectDependenciesPath),
+      // MARK: - GRANITE
+      require.resolve("../../metro/src/ModuleGraph/worker/generateImportNames"),
+      require.resolve("../../metro/src/ModuleGraph/worker/JsFileWrapping"),
+      ...metroTransformPlugins.getTransformPluginCacheKeyFiles()
+    ]);
+    const babelTransformer = require(babelTransformerPath);
+    return [
+      filesKey,
+      stableHash(remainingConfig).toString("hex"),
+      babelTransformer.getCacheKey ? babelTransformer.getCacheKey() : ""
+    ].join("$");
+  }
+};

package/dist/vendors/metro-transform-worker/src/utils/assetTransformer.js

@@ -0,0 +1,20 @@
+"use strict";
+const { getAssetData } = require("../../../metro/src/Assets");
+const { generateAssetCodeFileAst } = require("../../../metro/src/Bundler/util");
+const path = require("path");
+async function transform({ filename, options, src }, assetRegistryPath, assetDataPlugins) {
+  options = options || {
+    platform: "",
+    projectRoot: "",
+    inlineRequires: false,
+    minify: false
+  };
+  const absolutePath = path.resolve(options.projectRoot, filename);
+  const data = await getAssetData(absolutePath, filename, assetDataPlugins, options.platform, options.publicPath);
+  return {
+    ast: generateAssetCodeFileAst(assetRegistryPath, data)
+  };
+}
+module.exports = {
+  transform
+};

package/dist/vendors/metro-transform-worker/src/utils/getMinifier.js

@@ -0,0 +1,11 @@
+"use strict";
+function getMinifier(minifierPath) {
+  try {
+    return require(minifierPath);
+  } catch (e) {
+    throw new Error(
+      'A problem occurred while trying to fetch the minifier. Path: "' + minifierPath + '", error message: ' + e.message
+    );
+  }
+}
+module.exports = getMinifier;

package/package.json

@@ -0,0 +1,162 @@
+{
+  "name": "@granite-js/mpack",
+  "version": "0.0.1",
+  "description": "A bundler for Granite apps",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.ts",
+      "default": "./dist/plugins/index.js"
+    },
+    "./vendors": {
+      "types": "./dist/vendors/index.d.ts",
+      "default": "./dist/vendors/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "!**/testing",
+    "!**/__tests__"
+  ],
+  "scripts": {
+    "prepack": "yarn build",
+    "typecheck": "tsc --noEmit",
+    "build": "tsup && tsc -p tsconfig.build.json && node .scripts/copy-vendors-dts.mjs",
+    "lint": "eslint .",
+    "find-deadcode": "ts-prune",
+    "test:no-parallel": "vitest --no-watch --no-file-parallelism"
+  },
+  "devDependencies": {
+    "@babel/runtime": "7.24.8",
+    "@types/accepts": "^1",
+    "@types/async": "^3",
+    "@types/babel__code-frame": "^7",
+    "@types/babel__core": "^7",
+    "@types/babel__generator": "^7",
+    "@types/babel__template": "^7",
+    "@types/babel__traverse": "^7",
+    "@types/connect": "^3",
+    "@types/debug": "^4.1.12",
+    "@types/denodeify": "^1",
+    "@types/eslint": "^9",
+    "@types/events": "^3",
+    "@types/graceful-fs": "^4",
+    "@types/invariant": "^2",
+    "@types/lodash.throttle": "^4",
+    "@types/mime-types": "^2",
+    "@types/node": "^22.10.2",
+    "@types/path-browserify": "^1",
+    "@types/pnpapi": "^0",
+    "@types/prompts": "^2",
+    "@types/serve-static": "^1",
+    "@types/temp": "^0",
+    "@types/ws": "^8",
+    "eslint": "9.7.0",
+    "execa": "^5.0.0",
+    "fast-glob": "^3.3.2",
+    "flow-remove-types": "^2.251.1",
+    "prettier-2": "npm:prettier@^2",
+    "ts-prune": "^0.10.3",
+    "typescript": "5.8.3",
+    "vitest": "^2.1.8"
+  },
+  "dependencies": {
+    "@babel/code-frame": "7.24.7",
+    "@babel/core": "7.23.9",
+    "@babel/generator": "^7.14.0",
+    "@babel/parser": "^7.14.0",
+    "@babel/plugin-proposal-class-properties": "7.18.6",
+    "@babel/plugin-proposal-private-methods": "7.18.6",
+    "@babel/plugin-proposal-private-property-in-object": "7.21.11",
+    "@babel/plugin-transform-flow-strip-types": "7.23.3",
+    "@babel/preset-env": "7.23.3",
+    "@babel/preset-react": "7.23.3",
+    "@babel/preset-typescript": "7.23.3",
+    "@babel/template": "^7.0.0",
+    "@babel/traverse": "^7.14.0",
+    "@babel/types": "^7.0.0",
+    "@fastify/static": "7.0.1",
+    "@granite-js/devtools-frontend": "0.0.3",
+    "@granite-js/utils": "0.0.1",
+    "@inquirer/prompts": "^7.2.3",
+    "@react-native-community/cli-plugin-metro": "11.3.7",
+    "@react-native-community/cli-server-api": "11.3.7",
+    "@react-native-community/cli-tools": "11.3.7",
+    "@react-native/dev-middleware": "0.73.8",
+    "@shopify/semaphore": "^3.1.0",
+    "@swc/core": "1.5.24",
+    "@swc/helpers": "0.5.13",
+    "absolute-path": "^0.0.0",
+    "accepts": "^1.3.7",
+    "assert": "2.1.0",
+    "async": "^3.2.2",
+    "babel-preset-fbjs": "^3.4.0",
+    "browserify-zlib": "0.2.0",
+    "buffer": "6.0.3",
+    "chalk": "^4",
+    "chrome-launcher": "^0.15.0",
+    "ci-info": "^2.0.0",
+    "connect": "^3.7.0",
+    "cosmiconfig": "^7.0.0",
+    "debug": "^4.3.7",
+    "denodeify": "^1.2.1",
+    "enhanced-resolve": "^5.17.1",
+    "error-stack-parser": "^2.0.6",
+    "es-toolkit": "^1.26.1",
+    "esbuild": "^0.25.4",
+    "events": "3.3.0",
+    "fastify": "4.14.0",
+    "fastify-plugin": "4.5.1",
+    "frogress-bar": "^0.1.0",
+    "fs-extra": "^1.0.0",
+    "graceful-fs": "^4.2.4",
+    "hermes-parser": "0.8.0",
+    "https-browserify": "1.0.0",
+    "image-size": "^0.6.0",
+    "invariant": "^2.2.4",
+    "jest-validate": "^26.5.2",
+    "jest-worker": "^27.2.0",
+    "lodash.throttle": "^4.1.1",
+    "metro-babel-transformer": "0.72.3",
+    "metro-cache": "0.72.3",
+    "metro-cache-key": "0.72.3",
+    "metro-file-map": "0.72.3",
+    "metro-hermes-compiler": "0.72.3",
+    "metro-inspector-proxy": "0.72.3",
+    "metro-minify-uglify": "0.72.3",
+    "metro-react-native-babel-preset": "0.72.3",
+    "metro-react-native-babel-transformer": "0.76.8",
+    "metro-resolver": "0.72.3",
+    "metro-runtime": "0.72.3",
+    "metro-source-map": "0.72.3",
+    "metro-symbolicate": "0.72.3",
+    "metro-transform-plugins": "0.72.3",
+    "mime-types": "^2.1.27",
+    "node-fetch": "^2.2.0",
+    "nullthrows": "^1.1.1",
+    "path-browserify": "1.0.1",
+    "react-native-devtools-standalone": "^0.4.1",
+    "rimraf": "^2.5.4",
+    "serialize-error": "^2.1.0",
+    "serve-static": "^1.15.0",
+    "source-map": "^0.7.4",
+    "stream-browserify": "3.0.0",
+    "stream-http": "3.2.0",
+    "strip-ansi": "^6.0.0",
+    "sucrase": "^3.35.0",
+    "temp": "0.8.3",
+    "throat": "^5.0.0",
+    "tsup": "^8.5.0",
+    "url": "0.11.0",
+    "util": "0.12.5",
+    "ws": "^8.18.0",
+    "yargs": "^15.3.1",
+    "zod": "3.24.4"
+  }
+}