@metamask/snaps-cli 0.37.1-flask.1 → 0.38.0-flask.1

package/dist/cjs/webpack/compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/webpack/compiler.ts"],"sourcesContent":["import type { Server } from 'http';\nimport { createServer } from 'http';\nimport type { AddressInfo } from 'net';\nimport serveMiddleware from 'serve-handler';\nimport { webpack } from 'webpack';\n\nimport type { ProcessedConfig, ProcessedWebpackConfig } from '../config';\nimport type { WebpackOptions } from './config';\nimport { getDefaultConfiguration } from './config';\n\n/**\n * Get a Webpack compiler for the given config.\n *\n * @param config - The config object.\n * @param options - The Webpack options.\n * @returns The Webpack compiler.\n */\nexport async function getCompiler(\n  config: ProcessedWebpackConfig,\n  options?: WebpackOptions,\n) {\n  const baseWebpackConfig = await getDefaultConfiguration(config, options);\n  const webpackConfig =\n    config.customizeWebpackConfig?.(baseWebpackConfig) ?? baseWebpackConfig;\n\n  return webpack(webpackConfig);\n}\n\n/**\n * Get a static server for development purposes.\n *\n * Note: We're intentionally not using `webpack-dev-server` here because it\n * adds a lot of extra stuff to the output that we don't need, and it's\n * difficult to customize.\n *\n * @param config - The config object.\n * @returns An object with a `listen` method that returns a promise that\n * resolves when the server is listening.\n */\nexport function getServer(config: ProcessedConfig) {\n  const server = createServer((request, response) => {\n    serveMiddleware(request, response, {\n      public: config.server.root,\n      headers: [\n        {\n          source: '**/*',\n          headers: [\n            {\n              key: 'Cache-Control',\n              value: 'no-cache',\n            },\n            {\n              key: 'Access-Control-Allow-Origin',\n              value: '*',\n            },\n          ],\n        },\n      ],\n    })?.catch(\n      /* istanbul ignore next */ () => {\n        response.statusCode = 500;\n        response.end();\n      },\n    );\n  });\n\n  /**\n   * Start the server on the port specified in the config.\n   *\n   * @param port - The port to listen on.\n   * @returns A promise that resolves when the server is listening. The promise\n   * resolves to an object with the port and the server instance. Note that if\n   * the `config.server.port` is `0`, the OS will choose a random port for us,\n   * so we need to get the port from the server after it starts.\n   */\n  const listen = async (port = config.server.port) => {\n    return new Promise<{\n      port: number;\n      server: Server;\n      close: () => Promise<void>;\n    }>((resolve, reject) => {\n      try {\n        server.listen(port, () => {\n          const close = async () => {\n            await new Promise<void>((resolveClose, rejectClose) => {\n              server.close((closeError) => {\n                if (closeError) {\n                  return rejectClose(closeError);\n                }\n\n                return resolveClose();\n              });\n            });\n          };\n\n          const address = server.address() as AddressInfo;\n          resolve({ port: address.port, server, close });\n        });\n      } catch (listenError) {\n        reject(listenError);\n      }\n    });\n  };\n\n  return { listen };\n}\n"],"names":["getCompiler","getServer","config","options","baseWebpackConfig","getDefaultConfiguration","webpackConfig","customizeWebpackConfig","webpack","server","createServer","request","response","serveMiddleware","public","root","headers","source","key","value","catch","statusCode","end","listen","port","Promise","resolve","reject","close","resolveClose","rejectClose","closeError","address","listenError"],"mappings":";;;;;;;;;;;IAiBsBA,WAAW;eAAXA;;IAsBNC,SAAS;eAATA;;;sBAtCa;qEAED;yBACJ;wBAIgB;;;;;;AASjC,eAAeD,YACpBE,MAA8B,EAC9BC,OAAwB;IAExB,MAAMC,oBAAoB,MAAMC,IAAAA,+BAAuB,EAACH,QAAQC;IAChE,MAAMG,gBACJJ,OAAOK,sBAAsB,GAAGH,sBAAsBA;IAExD,OAAOI,IAAAA,gBAAO,EAACF;AACjB;AAaO,SAASL,UAAUC,MAAuB;IAC/C,MAAMO,SAASC,IAAAA,kBAAY,EAAC,CAACC,SAASC;QACpCC,IAAAA,qBAAe,EAACF,SAASC,UAAU;YACjCE,QAAQZ,OAAOO,MAAM,CAACM,IAAI;YAC1BC,SAAS;gBACP;oBACEC,QAAQ;oBACRD,SAAS;wBACP;4BACEE,KAAK;4BACLC,OAAO;wBACT;wBACA;4BACED,KAAK;4BACLC,OAAO;wBACT;qBACD;gBACH;aACD;QACH,IAAIC,MACF,wBAAwB,GAAG;YACzBR,SAASS,UAAU,GAAG;YACtBT,SAASU,GAAG;QACd;IAEJ;IAEA;;;;;;;;GAQC,GACD,MAAMC,SAAS,OAAOC,OAAOtB,OAAOO,MAAM,CAACe,IAAI;QAC7C,OAAO,IAAIC,QAIR,CAACC,SAASC;YACX,IAAI;gBACFlB,OAAOc,MAAM,CAACC,MAAM;oBAClB,MAAMI,QAAQ;wBACZ,MAAM,IAAIH,QAAc,CAACI,cAAcC;4BACrCrB,OAAOmB,KAAK,CAAC,CAACG;gCACZ,IAAIA,YAAY;oCACd,OAAOD,YAAYC;gCACrB;gCAEA,OAAOF;4BACT;wBACF;oBACF;oBAEA,MAAMG,UAAUvB,OAAOuB,OAAO;oBAC9BN,QAAQ;wBAAEF,MAAMQ,QAAQR,IAAI;wBAAEf;wBAAQmB;oBAAM;gBAC9C;YACF,EAAE,OAAOK,aAAa;gBACpBN,OAAOM;YACT;QACF;IACF;IAEA,OAAO;QAAEV;IAAO;AAClB"}

package/dist/cjs/webpack/config.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getDefaultConfiguration", {
+    enumerable: true,
+    get: function() {
+        return getDefaultConfiguration;
+    }
+});
+const _snapswebpackplugin = /*#__PURE__*/ _interop_require_default(require("@metamask/snaps-webpack-plugin"));
+const _module = require("module");
+const _path = require("path");
+const _terserwebpackplugin = /*#__PURE__*/ _interop_require_default(require("terser-webpack-plugin"));
+const _webpack = require("webpack");
+const _plugins = require("./plugins");
+const _utils = require("./utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function getDefaultConfiguration(config, options = {
+    evaluate: config.evaluate
+}) {
+    const spinnerText = options.spinner?.text;
+    const builtInResolver = config.stats.builtIns && new _plugins.SnapsBuiltInResolver(config.stats.builtIns, options.spinner);
+    return {
+        /**
+     * The target is set to `browserslist` so that Webpack will compile the
+     * bundle to support the browsers specified in the `.browserslistrc` file.
+     * This Browserslist file contains the browsers that are supported by
+     * MetaMask Snaps.
+     *
+     * @see https://webpack.js.org/configuration/target/
+     */ target: `browserslist:${_utils.BROWSERSLIST_FILE}`,
+        /**
+     * The mode is set to `production` by default, so that Webpack will minify
+     * and optimize the bundle.
+     *
+     * @see https://webpack.js.org/configuration/mode/
+     */ mode: 'production',
+        /**
+     * The entry point is set to the `input` value from the config object.
+     *
+     * @see https://webpack.js.org/configuration/entry-context/
+     */ entry: config.input,
+        /**
+     * The devtool option controls how source maps are generated. We set it to
+     * the `sourceMap` value from the config object.
+     *
+     * @see https://webpack.js.org/configuration/devtool/
+     */ devtool: (0, _utils.getDevTool)(config.sourceMap),
+        /**
+     * The stats option controls how much information is printed to the console
+     * when Webpack is running. We set it to `none` so that we can control the
+     * output ourselves.
+     *
+     * @see https://webpack.js.org/configuration/stats/
+     */ stats: 'none',
+        /**
+     * The output options.
+     *
+     * @see https://webpack.js.org/configuration/output/
+     */ output: {
+            /**
+       * This indicates whether Webpack should clear the output directory
+       * before building. We set it to the `clean` value from the config
+       * object.
+       *
+       * @see https://webpack.js.org/configuration/output/#outputclean
+       */ clean: config.output.clean,
+            /**
+       * The filename of the bundle. We set it to the `filename` value from
+       * the config object.
+       *
+       * @see https://webpack.js.org/configuration/output/#outputfilename
+       */ filename: config.output.filename,
+            /**
+       * The path to the output directory. We set it to the `path` value from
+       * the config object.
+       *
+       * @see https://webpack.js.org/configuration/output/#outputpath
+       */ path: config.output.path,
+            /**
+       * The public path of the bundle. We set it to `/` by default, so that
+       * the bundle can be loaded from the root of the server.
+       *
+       * @see https://webpack.js.org/configuration/output/#outputpublicpath
+       */ publicPath: '/',
+            /**
+       * The library configuration. This tells Webpack how to export the
+       * bundle.
+       *
+       * @see https://webpack.js.org/configuration/output/#outputlibrary
+       */ library: {
+                /**
+         * This tells Webpack to export the bundle as a CommonJS module. This
+         * is necessary for MetaMask Snaps.
+         *
+         * @see https://webpack.js.org/configuration/output/#outputlibrarytarget
+         */ type: 'commonjs'
+            }
+        },
+        /**
+     * The module configuration. This is where we tell Webpack how to handle
+     * different types of files.
+     *
+     * @see https://webpack.js.org/configuration/module/
+     */ module: {
+            rules: [
+                {
+                    test: /\.[tj]sx?$/u,
+                    exclude: /node_modules/u,
+                    use: await (0, _utils.getDefaultLoader)(config)
+                },
+                config.experimental.wasm && {
+                    test: /\.wasm$/u,
+                    use: {
+                        loader: (0, _path.resolve)(__dirname, 'loaders', 'wasm')
+                    }
+                }
+            ]
+        },
+        /**
+     * The resolve configuration. This tells Webpack how to resolve imports.
+     * We set it to resolve `.js` and `.ts` files.
+     *
+     * @see https://webpack.js.org/configuration/resolve/
+     */ resolve: {
+            /**
+       * The extensions to resolve. We set it to resolve `.js` and `.ts`
+       * files.
+       */ extensions: [
+                '.js',
+                '.ts'
+            ],
+            /**
+       * The fallback options. This tells Webpack how to handle imports that
+       * aren't resolved. By default, we set Node.js built-ins to `false`, so
+       * that they are ignored.
+       */ fallback: Object.fromEntries(_module.builtinModules.map((name)=>[
+                    name,
+                    false
+                ])),
+            /**
+       * The plugins to use. We use the {@link SnapsBuiltInResolver} to show
+       * warnings about using Node.js built-ins, when no fallback is specified.
+       */ plugins: [
+                builtInResolver
+            ]
+        },
+        /**
+     * The plugins to use.
+     *
+     * @see https://webpack.js.org/configuration/plugins/
+     */ plugins: [
+            /**
+       * The `SnapsWebpackPlugin` is a Webpack plugin that checks and updates
+       * the manifest file, and evaluates the bundle in SES. While not strictly
+       * required, it's highly recommended to use this plugin.
+       */ new _snapswebpackplugin.default({
+                manifestPath: config.manifest.path,
+                writeManifest: config.manifest.update,
+                eval: !options.watch && options.evaluate
+            }),
+            /**
+       * The `SnapsStatsPlugin` is a Webpack plugin that handles the stats
+       * output. It's used to show the stats in the terminal, in a format that
+       * is easy to read.
+       */ new _plugins.SnapsStatsPlugin({
+                verbose: config.stats.verbose
+            }, options.spinner),
+            /**
+       * The `EnvironmentPlugin` is a Webpack plugin that adds environment
+       * variables to the bundle. We use it to add the `NODE_ENV` and `DEBUG`
+       * environment variables.
+       */ new _webpack.EnvironmentPlugin(config.environment),
+            /**
+       * The `ProgressPlugin` is a Webpack plugin that logs the progress of
+       * the build. We set it to log the progress to the spinner.
+       */ new _webpack.ProgressPlugin({
+                handler: (0, _utils.getProgressHandler)(options.spinner, spinnerText)
+            }),
+            /**
+       * The `SnapsBundleWarningPlugin` is a Webpack plugin that shows a
+       * warning when the bundle is potentially incompatible with MetaMask
+       * Snaps.
+       */ new _plugins.SnapsBundleWarningsPlugin({
+                builtInResolver,
+                builtIns: Boolean(config.stats.builtIns),
+                buffer: config.stats.buffer
+            }, options.spinner),
+            /**
+       * The `WatchPlugin` is a Webpack plugin that adds extra files to watch
+       * for changes. This is useful for rebuilding the bundle when the
+       * manifest file changes.
+       */ options.watch && new _plugins.SnapsWatchPlugin({
+                bundle: (0, _path.resolve)(config.output.path, config.output.filename),
+                evaluate: options.evaluate,
+                files: [
+                    config.manifest.path
+                ]
+            }, options.spinner)
+        ].filter(Boolean),
+        /**
+     * The optimization configuration. This tells Webpack how to optimize the
+     * bundle. Most of the time, you won't need to change this, as the default
+     * options set by the `mode` option are sufficient.
+     */ optimization: {
+            minimize: config.output.minimize,
+            /**
+       * The minimizer to use. We set it to use the `TerserPlugin`.
+       */ minimizer: [
+                new _terserwebpackplugin.default({
+                    parallel: true
+                })
+            ]
+        },
+        /**
+     * The infrastructure logging configuration. This tells Webpack how to
+     * log messages.
+     *
+     * @see https://webpack.js.org/configuration/infrastructure-logging
+     */ infrastructureLogging: {
+            /**
+       * The level of logging to use. We set it to `none`, so that we can
+       * control the output ourselves.
+       */ level: 'none'
+        }
+    };
+}
+
+//# sourceMappingURL=config.js.map

package/dist/cjs/webpack/config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/webpack/config.ts"],"sourcesContent":["import SnapsWebpackPlugin from '@metamask/snaps-webpack-plugin';\nimport { builtinModules } from 'module';\nimport type { Ora } from 'ora';\nimport { resolve } from 'path';\nimport TerserPlugin from 'terser-webpack-plugin';\nimport type { Configuration } from 'webpack';\nimport { EnvironmentPlugin, ProgressPlugin } from 'webpack';\n\nimport type { ProcessedWebpackConfig } from '../config';\nimport {\n  SnapsBuiltInResolver,\n  SnapsBundleWarningsPlugin,\n  SnapsStatsPlugin,\n  SnapsWatchPlugin,\n} from './plugins';\nimport {\n  BROWSERSLIST_FILE,\n  getDefaultLoader,\n  getDevTool,\n  getProgressHandler,\n} from './utils';\n\nexport type WebpackOptions = {\n  /**\n   * Whether to watch for changes.\n   */\n  watch?: boolean;\n\n  /**\n   * Whether to evaluate the bundle. If this is set, it will override the\n   * `evaluate` option in the config object.\n   */\n  evaluate?: boolean;\n\n  /**\n   * The spinner to use for logging.\n   */\n  spinner?: Ora;\n};\n\n/**\n * Get the default Webpack configuration. This is the configuration that will\n * be used if the user doesn't provide a custom Webpack configuration. The\n * configuration is based on the snap config.\n *\n * The default configuration includes:\n *\n * - `SWC` to transpile TypeScript and JavaScript files.\n * - `TerserPlugin` to minify the bundle.\n * - `SnapsWebpackPlugin` to validate the bundle and update the manifest.\n *\n * It can be customized through the `customizeWebpackConfig` function in the\n * snap config, but in most cases, you shouldn't need to do that.\n *\n * @param config - The processed snap Webpack config.\n * @param options - The Webpack options.\n * @returns The default Webpack configuration.\n */\nexport async function getDefaultConfiguration(\n  config: ProcessedWebpackConfig,\n  options: WebpackOptions = {\n    evaluate: config.evaluate,\n  },\n): Promise<Configuration> {\n  const spinnerText = options.spinner?.text;\n  const builtInResolver =\n    config.stats.builtIns &&\n    new SnapsBuiltInResolver(config.stats.builtIns, options.spinner);\n\n  return {\n    /**\n     * The target is set to `browserslist` so that Webpack will compile the\n     * bundle to support the browsers specified in the `.browserslistrc` file.\n     * This Browserslist file contains the browsers that are supported by\n     * MetaMask Snaps.\n     *\n     * @see https://webpack.js.org/configuration/target/\n     */\n    target: `browserslist:${BROWSERSLIST_FILE}`,\n\n    /**\n     * The mode is set to `production` by default, so that Webpack will minify\n     * and optimize the bundle.\n     *\n     * @see https://webpack.js.org/configuration/mode/\n     */\n    mode: 'production',\n\n    /**\n     * The entry point is set to the `input` value from the config object.\n     *\n     * @see https://webpack.js.org/configuration/entry-context/\n     */\n    entry: config.input,\n\n    /**\n     * The devtool option controls how source maps are generated. We set it to\n     * the `sourceMap` value from the config object.\n     *\n     * @see https://webpack.js.org/configuration/devtool/\n     */\n    devtool: getDevTool(config.sourceMap),\n\n    /**\n     * The stats option controls how much information is printed to the console\n     * when Webpack is running. We set it to `none` so that we can control the\n     * output ourselves.\n     *\n     * @see https://webpack.js.org/configuration/stats/\n     */\n    stats: 'none',\n\n    /**\n     * The output options.\n     *\n     * @see https://webpack.js.org/configuration/output/\n     */\n    output: {\n      /**\n       * This indicates whether Webpack should clear the output directory\n       * before building. We set it to the `clean` value from the config\n       * object.\n       *\n       * @see https://webpack.js.org/configuration/output/#outputclean\n       */\n      clean: config.output.clean,\n\n      /**\n       * The filename of the bundle. We set it to the `filename` value from\n       * the config object.\n       *\n       * @see https://webpack.js.org/configuration/output/#outputfilename\n       */\n      filename: config.output.filename,\n\n      /**\n       * The path to the output directory. We set it to the `path` value from\n       * the config object.\n       *\n       * @see https://webpack.js.org/configuration/output/#outputpath\n       */\n      path: config.output.path,\n\n      /**\n       * The public path of the bundle. We set it to `/` by default, so that\n       * the bundle can be loaded from the root of the server.\n       *\n       * @see https://webpack.js.org/configuration/output/#outputpublicpath\n       */\n      publicPath: '/',\n\n      /**\n       * The library configuration. This tells Webpack how to export the\n       * bundle.\n       *\n       * @see https://webpack.js.org/configuration/output/#outputlibrary\n       */\n      library: {\n        /**\n         * This tells Webpack to export the bundle as a CommonJS module. This\n         * is necessary for MetaMask Snaps.\n         *\n         * @see https://webpack.js.org/configuration/output/#outputlibrarytarget\n         */\n        type: 'commonjs',\n      },\n    },\n\n    /**\n     * The module configuration. This is where we tell Webpack how to handle\n     * different types of files.\n     *\n     * @see https://webpack.js.org/configuration/module/\n     */\n    module: {\n      rules: [\n        {\n          test: /\\.[tj]sx?$/u,\n          exclude: /node_modules/u,\n          use: await getDefaultLoader(config),\n        },\n\n        config.experimental.wasm && {\n          test: /\\.wasm$/u,\n          use: {\n            loader: resolve(__dirname, 'loaders', 'wasm'),\n          },\n        },\n      ],\n    },\n\n    /**\n     * The resolve configuration. This tells Webpack how to resolve imports.\n     * We set it to resolve `.js` and `.ts` files.\n     *\n     * @see https://webpack.js.org/configuration/resolve/\n     */\n    resolve: {\n      /**\n       * The extensions to resolve. We set it to resolve `.js` and `.ts`\n       * files.\n       */\n      extensions: ['.js', '.ts'],\n\n      /**\n       * The fallback options. This tells Webpack how to handle imports that\n       * aren't resolved. By default, we set Node.js built-ins to `false`, so\n       * that they are ignored.\n       */\n      fallback: Object.fromEntries(builtinModules.map((name) => [name, false])),\n\n      /**\n       * The plugins to use. We use the {@link SnapsBuiltInResolver} to show\n       * warnings about using Node.js built-ins, when no fallback is specified.\n       */\n      plugins: [builtInResolver],\n    },\n\n    /**\n     * The plugins to use.\n     *\n     * @see https://webpack.js.org/configuration/plugins/\n     */\n    plugins: [\n      /**\n       * The `SnapsWebpackPlugin` is a Webpack plugin that checks and updates\n       * the manifest file, and evaluates the bundle in SES. While not strictly\n       * required, it's highly recommended to use this plugin.\n       */\n      new SnapsWebpackPlugin({\n        manifestPath: config.manifest.path,\n        writeManifest: config.manifest.update,\n        eval: !options.watch && options.evaluate,\n      }),\n\n      /**\n       * The `SnapsStatsPlugin` is a Webpack plugin that handles the stats\n       * output. It's used to show the stats in the terminal, in a format that\n       * is easy to read.\n       */\n      new SnapsStatsPlugin({ verbose: config.stats.verbose }, options.spinner),\n\n      /**\n       * The `EnvironmentPlugin` is a Webpack plugin that adds environment\n       * variables to the bundle. We use it to add the `NODE_ENV` and `DEBUG`\n       * environment variables.\n       */\n      new EnvironmentPlugin(config.environment),\n\n      /**\n       * The `ProgressPlugin` is a Webpack plugin that logs the progress of\n       * the build. We set it to log the progress to the spinner.\n       */\n      new ProgressPlugin({\n        handler: getProgressHandler(options.spinner, spinnerText),\n      }),\n\n      /**\n       * The `SnapsBundleWarningPlugin` is a Webpack plugin that shows a\n       * warning when the bundle is potentially incompatible with MetaMask\n       * Snaps.\n       */\n      new SnapsBundleWarningsPlugin(\n        {\n          builtInResolver,\n          builtIns: Boolean(config.stats.builtIns),\n          buffer: config.stats.buffer,\n        },\n        options.spinner,\n      ),\n\n      /**\n       * The `WatchPlugin` is a Webpack plugin that adds extra files to watch\n       * for changes. This is useful for rebuilding the bundle when the\n       * manifest file changes.\n       */\n      options.watch &&\n        new SnapsWatchPlugin(\n          {\n            bundle: resolve(config.output.path, config.output.filename),\n            evaluate: options.evaluate,\n            files: [config.manifest.path],\n          },\n          options.spinner,\n        ),\n    ].filter(Boolean),\n\n    /**\n     * The optimization configuration. This tells Webpack how to optimize the\n     * bundle. Most of the time, you won't need to change this, as the default\n     * options set by the `mode` option are sufficient.\n     */\n    optimization: {\n      minimize: config.output.minimize,\n\n      /**\n       * The minimizer to use. We set it to use the `TerserPlugin`.\n       */\n      minimizer: [\n        new TerserPlugin({\n          parallel: true,\n        }),\n      ],\n    },\n\n    /**\n     * The infrastructure logging configuration. This tells Webpack how to\n     * log messages.\n     *\n     * @see https://webpack.js.org/configuration/infrastructure-logging\n     */\n    infrastructureLogging: {\n      /**\n       * The level of logging to use. We set it to `none`, so that we can\n       * control the output ourselves.\n       */\n      level: 'none',\n    },\n  };\n}\n"],"names":["getDefaultConfiguration","config","options","evaluate","spinnerText","spinner","text","builtInResolver","stats","builtIns","SnapsBuiltInResolver","target","BROWSERSLIST_FILE","mode","entry","input","devtool","getDevTool","sourceMap","output","clean","filename","path","publicPath","library","type","module","rules","test","exclude","use","getDefaultLoader","experimental","wasm","loader","resolve","__dirname","extensions","fallback","Object","fromEntries","builtinModules","map","name","plugins","SnapsWebpackPlugin","manifestPath","manifest","writeManifest","update","eval","watch","SnapsStatsPlugin","verbose","EnvironmentPlugin","environment","ProgressPlugin","handler","getProgressHandler","SnapsBundleWarningsPlugin","Boolean","buffer","SnapsWatchPlugin","bundle","files","filter","optimization","minimize","minimizer","TerserPlugin","parallel","infrastructureLogging","level"],"mappings":"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"}

package/dist/cjs/webpack/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./compiler"), exports);
+_export_star(require("./config"), exports);
+_export_star(require("./plugins"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/webpack/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/webpack/index.ts"],"sourcesContent":["export * from './compiler';\nexport * from './config';\nexport * from './plugins';\n"],"names":[],"mappings":";;;;qBAAc;qBACA;qBACA"}

package/dist/cjs/webpack/loaders/browserify.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _browserify = /*#__PURE__*/ _interop_require_default(require("browserify"));
+const _stream = require("stream");
+const _builders = require("../../builders");
+const _utils = require("../../utils");
+const _utils1 = require("../utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/**
+ * A Browserify loader for Webpack. This exists for backwards compatibility with
+ * the legacy configuration format, in order to support the `bundlerCustomizer`
+ * function.
+ *
+ * When this loader is used, the input file will be processed by Browserify, and
+ * written to disk by Webpack. Most processing will be handled by Browserify, so
+ * there are no benefits like tree-shaking.
+ *
+ * @param content - The input file contents as a string.
+ * @param sourceMap - The source map of the input file.
+ */ const loader = async function(content, sourceMap) {
+    const config = this.getOptions();
+    const { transpilationMode } = config;
+    const bundler = (0, _browserify.default)({
+        extensions: [
+            '.js',
+            '.ts'
+        ],
+        debug: Boolean(sourceMap),
+        standalone: '<snap>'
+    });
+    if (transpilationMode !== _builders.TranspilationModes.None) {
+        const babelifyOptions = (0, _utils.processDependencies)(config);
+        // We need to statically import all Browserify transforms, and all Babel
+        // presets and plugins, and calling `require` is the sanest way to do that.
+        /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires, n/global-require */ bundler.transform(require('babelify'), {
+            global: transpilationMode === _builders.TranspilationModes.LocalAndDeps,
+            extensions: [
+                '.js',
+                '.ts'
+            ],
+            presets: [
+                require('@babel/preset-typescript'),
+                [
+                    require('@babel/preset-env'),
+                    {
+                        targets: {
+                            browsers: await (0, _utils1.getBrowserslistTargets)()
+                        }
+                    }
+                ]
+            ],
+            plugins: [
+                require('@babel/plugin-transform-runtime'),
+                require('@babel/plugin-proposal-class-properties'),
+                require('@babel/plugin-proposal-private-methods'),
+                require('@babel/plugin-proposal-class-static-block'),
+                require('@babel/plugin-proposal-private-property-in-object')
+            ],
+            ...babelifyOptions
+        });
+    /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires, n/global-require */ }
+    config.bundlerCustomizer?.(bundler);
+    // Browserify doesn't accept a string as an entry point, so we need to convert
+    // it to a stream.
+    const stream = new _stream.Readable();
+    stream.push(content);
+    stream.push(null);
+    bundler.add(stream, {
+        file: this.resourcePath
+    });
+    return new Promise((resolve, reject)=>{
+        bundler.bundle((bundleError, buffer)=>{
+            if (bundleError) {
+                reject(bundleError);
+                return;
+            }
+            // Browserify inlines the source map, so we just pass the output buffer back
+            // to Webpack.
+            resolve(buffer);
+        });
+    });
+};
+const _default = loader;
+
+//# sourceMappingURL=browserify.js.map

package/dist/cjs/webpack/loaders/browserify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/webpack/loaders/browserify.ts"],"sourcesContent":["import browserify from 'browserify';\nimport { Readable } from 'stream';\nimport type { LoaderDefinitionFunction } from 'webpack';\n\nimport { TranspilationModes } from '../../builders';\nimport type { LegacyOptions } from '../../config';\nimport { processDependencies } from '../../utils';\nimport { getBrowserslistTargets } from '../utils';\n\n/**\n * A Browserify loader for Webpack. This exists for backwards compatibility with\n * the legacy configuration format, in order to support the `bundlerCustomizer`\n * function.\n *\n * When this loader is used, the input file will be processed by Browserify, and\n * written to disk by Webpack. Most processing will be handled by Browserify, so\n * there are no benefits like tree-shaking.\n *\n * @param content - The input file contents as a string.\n * @param sourceMap - The source map of the input file.\n */\nconst loader: LoaderDefinitionFunction<LegacyOptions> = async function (\n  content,\n  sourceMap,\n) {\n  const config = this.getOptions();\n\n  const { transpilationMode } = config;\n\n  const bundler = browserify({\n    extensions: ['.js', '.ts'],\n    debug: Boolean(sourceMap),\n    standalone: '<snap>',\n  });\n\n  if (transpilationMode !== TranspilationModes.None) {\n    const babelifyOptions = processDependencies(config);\n\n    // We need to statically import all Browserify transforms, and all Babel\n    // presets and plugins, and calling `require` is the sanest way to do that.\n    /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires, n/global-require */\n    bundler.transform(require('babelify'), {\n      global: transpilationMode === TranspilationModes.LocalAndDeps,\n      extensions: ['.js', '.ts'],\n      presets: [\n        require('@babel/preset-typescript'),\n        [\n          require('@babel/preset-env'),\n          {\n            targets: {\n              browsers: await getBrowserslistTargets(),\n            },\n          },\n        ],\n      ],\n      plugins: [\n        require('@babel/plugin-transform-runtime'),\n        require('@babel/plugin-proposal-class-properties'),\n        require('@babel/plugin-proposal-private-methods'),\n        require('@babel/plugin-proposal-class-static-block'),\n        require('@babel/plugin-proposal-private-property-in-object'),\n      ],\n      ...(babelifyOptions as any),\n    });\n    /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires, n/global-require */\n  }\n\n  config.bundlerCustomizer?.(bundler);\n\n  // Browserify doesn't accept a string as an entry point, so we need to convert\n  // it to a stream.\n  const stream = new Readable();\n  stream.push(content);\n  stream.push(null);\n\n  bundler.add(stream, {\n    file: this.resourcePath,\n  });\n\n  return new Promise<Buffer>((resolve, reject) => {\n    bundler.bundle((bundleError, buffer: Buffer) => {\n      if (bundleError) {\n        reject(bundleError);\n        return;\n      }\n\n      // Browserify inlines the source map, so we just pass the output buffer back\n      // to Webpack.\n      resolve(buffer);\n    });\n  });\n};\n\nexport default loader;\n"],"names":["loader","content","sourceMap","config","getOptions","transpilationMode","bundler","browserify","extensions","debug","Boolean","standalone","TranspilationModes","None","babelifyOptions","processDependencies","transform","require","global","LocalAndDeps","presets","targets","browsers","getBrowserslistTargets","plugins","bundlerCustomizer","stream","Readable","push","add","file","resourcePath","Promise","resolve","reject","bundle","bundleError","buffer"],"mappings":";;;;+BA6FA;;;eAAA;;;mEA7FuB;wBACE;0BAGU;uBAEC;wBACG;;;;;;AAEvC;;;;;;;;;;;CAWC,GACD,MAAMA,SAAkD,eACtDC,OAAO,EACPC,SAAS;IAET,MAAMC,SAAS,IAAI,CAACC,UAAU;IAE9B,MAAM,EAAEC,iBAAiB,EAAE,GAAGF;IAE9B,MAAMG,UAAUC,IAAAA,mBAAU,EAAC;QACzBC,YAAY;YAAC;YAAO;SAAM;QAC1BC,OAAOC,QAAQR;QACfS,YAAY;IACd;IAEA,IAAIN,sBAAsBO,4BAAkB,CAACC,IAAI,EAAE;QACjD,MAAMC,kBAAkBC,IAAAA,0BAAmB,EAACZ;QAE5C,wEAAwE;QACxE,2EAA2E;QAC3E,8GAA8G,GAC9GG,QAAQU,SAAS,CAACC,QAAQ,aAAa;YACrCC,QAAQb,sBAAsBO,4BAAkB,CAACO,YAAY;YAC7DX,YAAY;gBAAC;gBAAO;aAAM;YAC1BY,SAAS;gBACPH,QAAQ;gBACR;oBACEA,QAAQ;oBACR;wBACEI,SAAS;4BACPC,UAAU,MAAMC,IAAAA,8BAAsB;wBACxC;oBACF;iBACD;aACF;YACDC,SAAS;gBACPP,QAAQ;gBACRA,QAAQ;gBACRA,QAAQ;gBACRA,QAAQ;gBACRA,QAAQ;aACT;YACD,GAAIH,eAAe;QACrB;IACA,6GAA6G,GAC/G;IAEAX,OAAOsB,iBAAiB,GAAGnB;IAE3B,8EAA8E;IAC9E,kBAAkB;IAClB,MAAMoB,SAAS,IAAIC,gBAAQ;IAC3BD,OAAOE,IAAI,CAAC3B;IACZyB,OAAOE,IAAI,CAAC;IAEZtB,QAAQuB,GAAG,CAACH,QAAQ;QAClBI,MAAM,IAAI,CAACC,YAAY;IACzB;IAEA,OAAO,IAAIC,QAAgB,CAACC,SAASC;QACnC5B,QAAQ6B,MAAM,CAAC,CAACC,aAAaC;YAC3B,IAAID,aAAa;gBACfF,OAAOE;gBACP;YACF;YAEA,4EAA4E;YAC5E,cAAc;YACdH,QAAQI;QACV;IACF;AACF;MAEA,WAAerC"}

package/dist/cjs/webpack/loaders/wasm.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * A Webpack loader that inlines the WASM module as a `Uint8Array`. This makes
+ * it possible to import the WASM module directly, and use it with the
+ * `WebAssembly.instantiate` function.
+ *
+ * This is useful, because snaps are not allowed to import assets from outside
+ * of their package. This loader allows you to inline the WASM module as a
+ * `Uint8Array`, which can then be passed to `WebAssembly.instantiate`.
+ *
+ * @param source - The WASM module as a string.
+ * @returns A string that exports the WASM module as a `Uint8Array`.
+ * @example
+ * ```ts
+ * import wasm from './program.wasm';
+ *
+ * const { instance } = await WebAssembly.instantiate(wasm, {});
+ * // Do something with the WASM module...
+ * ```
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return loader;
+    }
+});
+const _utils = require("@metamask/utils");
+function loader(source) {
+    (0, _utils.assert)(typeof source === 'string', 'Expected source to be a string.');
+    const bytes = (0, _utils.stringToBytes)(source);
+    return `export default new Uint8Array(${JSON.stringify(Array.from(bytes))});`;
+}
+
+//# sourceMappingURL=wasm.js.map

package/dist/cjs/webpack/loaders/wasm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/webpack/loaders/wasm.ts"],"sourcesContent":["import { assert, stringToBytes } from '@metamask/utils';\n\n/**\n * A Webpack loader that inlines the WASM module as a `Uint8Array`. This makes\n * it possible to import the WASM module directly, and use it with the\n * `WebAssembly.instantiate` function.\n *\n * This is useful, because snaps are not allowed to import assets from outside\n * of their package. This loader allows you to inline the WASM module as a\n * `Uint8Array`, which can then be passed to `WebAssembly.instantiate`.\n *\n * @param source - The WASM module as a string.\n * @returns A string that exports the WASM module as a `Uint8Array`.\n * @example\n * ```ts\n * import wasm from './program.wasm';\n *\n * const { instance } = await WebAssembly.instantiate(wasm, {});\n * // Do something with the WASM module...\n * ```\n */\nexport default function loader(source: unknown) {\n  assert(typeof source === 'string', 'Expected source to be a string.');\n\n  const bytes = stringToBytes(source);\n  return `export default new Uint8Array(${JSON.stringify(Array.from(bytes))});`;\n}\n"],"names":["loader","source","assert","bytes","stringToBytes","JSON","stringify","Array","from"],"mappings":";;;;+BAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD;;;eAAwBA;;;uBArBc;AAqBvB,SAASA,OAAOC,MAAe;IAC5CC,IAAAA,aAAM,EAAC,OAAOD,WAAW,UAAU;IAEnC,MAAME,QAAQC,IAAAA,oBAAa,EAACH;IAC5B,OAAO,CAAC,8BAA8B,EAAEI,KAAKC,SAAS,CAACC,MAAMC,IAAI,CAACL,QAAQ,EAAE,CAAC;AAC/E"}