@metamask/snaps-cli 1.0.2 → 2.0.1

package/dist/cjs/commands/manifest/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/commands/manifest/index.ts"],"sourcesContent":["import type yargs from 'yargs';\n\nimport builders from '../../builders';\nimport type { YargsArgs } from '../../types/yargs';\nimport { manifestHandler } from './manifest';\n\nconst command = {\n  command: ['manifest', 'm'],\n  desc: 'Validate the snap.manifest.json file',\n  builder: (yarg: yargs.Argv) => {\n    // Browserify options. These are merged into the config object.\n    yarg.option('writeManifest', builders.writeManifest);\n\n    // Webpack options.\n    yarg.option('fix', builders.fix);\n  },\n  handler: async (argv: YargsArgs) =>\n    manifestHandler(argv.context.config, { fix: argv.fix }),\n};\n\nexport * from './implementation';\nexport default command;\n"],"names":["command","desc","builder","yarg","option","builders","writeManifest","fix","handler","argv","manifestHandler","context","config"],"mappings":";;;;+BAqBA;;;eAAA;;;iEAnBqB;0BAEW;qBAgBlB;;;;;;;;;;;;;;;;;;;AAdd,MAAMA,UAAU;IACdA,SAAS;QAAC;QAAY;KAAI;IAC1BC,MAAM;IACNC,SAAS,CAACC;QACR,+DAA+D;QAC/DA,KAAKC,MAAM,CAAC,iBAAiBC,iBAAQ,CAACC,aAAa;QAEnD,mBAAmB;QACnBH,KAAKC,MAAM,CAAC,OAAOC,iBAAQ,CAACE,GAAG;IACjC;IACAC,SAAS,OAAOC,OACdC,IAAAA,yBAAe,EAACD,KAAKE,OAAO,CAACC,MAAM,EAAE;YAAEL,KAAKE,KAAKF,GAAG;QAAC;AACzD;MAGA,WAAeP"}

package/dist/cjs/commands/manifest/manifest.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "manifestHandler", {
+    enumerable: true,
+    get: function() {
+        return manifestHandler;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+const _errors = require("../../errors");
+const _utils = require("../../utils");
+const _implementation = require("./implementation");
+const steps = [
+    {
+        name: 'Checking the input file.',
+        task: async ({ input })=>{
+            if (!await (0, _snapsutils.isFile)(input)) {
+                throw new _errors.CommandError(`Manifest file not found: "${input}". Make sure that the \`snap.manifest.json\` file exists.`);
+            }
+        }
+    },
+    {
+        name: 'Validating the snap manifest.',
+        task: async ({ input, config, options, spinner })=>{
+            const write = getWriteManifest(config, options);
+            const valid = await (0, _implementation.manifest)(input, write, spinner);
+            if (valid) {
+                spinner.succeed('The snap manifest file is valid.');
+            }
+        }
+    }
+];
+/**
+ * Get whether to write the manifest to disk.
+ *
+ * @param config - The config object.
+ * @param options - The options object.
+ * @returns Whether to write the manifest to disk.
+ */ function getWriteManifest(config, options) {
+    if (typeof options.fix === 'boolean') {
+        return options.fix;
+    }
+    return config.legacy?.writeManifest ?? false;
+}
+async function manifestHandler(config, options) {
+    await (0, _utils.executeSteps)(steps, {
+        input: config.manifest.path,
+        config,
+        options
+    });
+}
+
+//# sourceMappingURL=manifest.js.map

package/dist/cjs/commands/manifest/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/commands/manifest/manifest.ts"],"sourcesContent":["import { isFile } from '@metamask/snaps-utils';\n\nimport type { ProcessedConfig } from '../../config';\nimport { CommandError } from '../../errors';\nimport type { Steps } from '../../utils';\nimport { executeSteps } from '../../utils';\nimport { manifest } from './implementation';\n\ntype ManifestOptions = {\n  fix?: boolean;\n};\n\ntype ManifestContext = {\n  input: string;\n  config: ProcessedConfig;\n  options: ManifestOptions;\n};\n\nconst steps: Steps<ManifestContext> = [\n  {\n    name: 'Checking the input file.',\n    task: async ({ input }) => {\n      if (!(await isFile(input))) {\n        throw new CommandError(\n          `Manifest file not found: \"${input}\". Make sure that the \\`snap.manifest.json\\` file exists.`,\n        );\n      }\n    },\n  },\n  {\n    name: 'Validating the snap manifest.',\n    task: async ({ input, config, options, spinner }) => {\n      const write = getWriteManifest(config, options);\n      const valid = await manifest(input, write, spinner);\n\n      if (valid) {\n        spinner.succeed('The snap manifest file is valid.');\n      }\n    },\n  },\n];\n\n/**\n * Get whether to write the manifest to disk.\n *\n * @param config - The config object.\n * @param options - The options object.\n * @returns Whether to write the manifest to disk.\n */\nfunction getWriteManifest(config: ProcessedConfig, options: ManifestOptions) {\n  if (typeof options.fix === 'boolean') {\n    return options.fix;\n  }\n\n  return config.legacy?.writeManifest ?? false;\n}\n\n/**\n * Validates a snap.manifest.json file. Attempts to fix the manifest and write\n * the fixed version to disk if `writeManifest` is true. Throws if validation\n * fails.\n *\n * @param config - The config object.\n * @param options - The options object.\n */\nexport async function manifestHandler(\n  config: ProcessedConfig,\n  options: ManifestOptions,\n) {\n  await executeSteps(steps, {\n    input: config.manifest.path,\n    config,\n    options,\n  });\n}\n"],"names":["manifestHandler","steps","name","task","input","isFile","CommandError","config","options","spinner","write","getWriteManifest","valid","manifest","succeed","fix","legacy","writeManifest","executeSteps","path"],"mappings":";;;;+BAiEsBA;;;eAAAA;;;4BAjEC;wBAGM;uBAEA;gCACJ;AAYzB,MAAMC,QAAgC;IACpC;QACEC,MAAM;QACNC,MAAM,OAAO,EAAEC,KAAK,EAAE;YACpB,IAAI,CAAE,MAAMC,IAAAA,kBAAM,EAACD,QAAS;gBAC1B,MAAM,IAAIE,oBAAY,CACpB,CAAC,0BAA0B,EAAEF,MAAM,yDAAyD,CAAC;YAEjG;QACF;IACF;IACA;QACEF,MAAM;QACNC,MAAM,OAAO,EAAEC,KAAK,EAAEG,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAE;YAC9C,MAAMC,QAAQC,iBAAiBJ,QAAQC;YACvC,MAAMI,QAAQ,MAAMC,IAAAA,wBAAQ,EAACT,OAAOM,OAAOD;YAE3C,IAAIG,OAAO;gBACTH,QAAQK,OAAO,CAAC;YAClB;QACF;IACF;CACD;AAED;;;;;;CAMC,GACD,SAASH,iBAAiBJ,MAAuB,EAAEC,OAAwB;IACzE,IAAI,OAAOA,QAAQO,GAAG,KAAK,WAAW;QACpC,OAAOP,QAAQO,GAAG;IACpB;IAEA,OAAOR,OAAOS,MAAM,EAAEC,iBAAiB;AACzC;AAUO,eAAejB,gBACpBO,MAAuB,EACvBC,OAAwB;IAExB,MAAMU,IAAAA,mBAAY,EAACjB,OAAO;QACxBG,OAAOG,OAAOM,QAAQ,CAACM,IAAI;QAC3BZ;QACAC;IACF;AACF"}

package/dist/cjs/commands/serve/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _builders = /*#__PURE__*/ _interop_require_default(require("../../builders"));
+const _serve = require("./serve");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const command = {
+    command: [
+        'serve',
+        's'
+    ],
+    desc: 'Locally serve Snap file(s) for testing',
+    builder: (yarg)=>{
+        yarg.option('root', _builders.default.root).option('port', _builders.default.port);
+    },
+    handler: async (argv)=>(0, _serve.serveHandler)(argv.context.config, {
+            port: argv.port ?? argv.context.config.server.port
+        })
+};
+const _default = command;
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/commands/serve/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/commands/serve/index.ts"],"sourcesContent":["import type yargs from 'yargs';\n\nimport builders from '../../builders';\nimport type { YargsArgs } from '../../types/yargs';\nimport { serveHandler } from './serve';\n\nconst command = {\n  command: ['serve', 's'],\n  desc: 'Locally serve Snap file(s) for testing',\n  builder: (yarg: yargs.Argv) => {\n    yarg.option('root', builders.root).option('port', builders.port);\n  },\n  handler: async (argv: YargsArgs) =>\n    serveHandler(argv.context.config, {\n      port: argv.port ?? argv.context.config.server.port,\n    }),\n};\n\nexport default command;\n"],"names":["command","desc","builder","yarg","option","builders","root","port","handler","argv","serveHandler","context","config","server"],"mappings":";;;;+BAkBA;;;eAAA;;;iEAhBqB;uBAEQ;;;;;;AAE7B,MAAMA,UAAU;IACdA,SAAS;QAAC;QAAS;KAAI;IACvBC,MAAM;IACNC,SAAS,CAACC;QACRA,KAAKC,MAAM,CAAC,QAAQC,iBAAQ,CAACC,IAAI,EAAEF,MAAM,CAAC,QAAQC,iBAAQ,CAACE,IAAI;IACjE;IACAC,SAAS,OAAOC,OACdC,IAAAA,mBAAY,EAACD,KAAKE,OAAO,CAACC,MAAM,EAAE;YAChCL,MAAME,KAAKF,IAAI,IAAIE,KAAKE,OAAO,CAACC,MAAM,CAACC,MAAM,CAACN,IAAI;QACpD;AACJ;MAEA,WAAeP"}

package/dist/cjs/commands/serve/serve.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "serveHandler", {
+    enumerable: true,
+    get: function() {
+        return serveHandler;
+    }
+});
+const _utils = require("../../utils");
+const _webpack = require("../../webpack");
+async function serveHandler(config, options) {
+    const server = (0, _webpack.getServer)(config);
+    // If the `configPort` is `0`, the OS will choose a random port for us, so we
+    // need to get the port from the server after it starts.
+    const { port } = await server.listen(options.port);
+    (0, _utils.info)(`The server is listening on http://localhost:${port}.`);
+}
+
+//# sourceMappingURL=serve.js.map

package/dist/cjs/commands/serve/serve.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/commands/serve/serve.ts"],"sourcesContent":["import type { ProcessedConfig } from '../../config';\nimport { info } from '../../utils';\nimport { getServer } from '../../webpack';\n\ntype ServeOptions = {\n  /**\n   * The port to listen on.\n   */\n  port: number;\n};\n\n/**\n * Starts a local, static HTTP server on the given port with the given root\n * directory.\n *\n * @param config - The config object.\n * @param options - The options object.\n */\nexport async function serveHandler(\n  config: ProcessedConfig,\n  options: ServeOptions,\n): Promise<void> {\n  const server = getServer(config);\n\n  // If the `configPort` is `0`, the OS will choose a random port for us, so we\n  // need to get the port from the server after it starts.\n  const { port } = await server.listen(options.port);\n\n  info(`The server is listening on http://localhost:${port}.`);\n}\n"],"names":["serveHandler","config","options","server","getServer","port","listen","info"],"mappings":";;;;+BAkBsBA;;;eAAAA;;;uBAjBD;yBACK;AAgBnB,eAAeA,aACpBC,MAAuB,EACvBC,OAAqB;IAErB,MAAMC,SAASC,IAAAA,kBAAS,EAACH;IAEzB,6EAA6E;IAC7E,wDAAwD;IACxD,MAAM,EAAEI,IAAI,EAAE,GAAG,MAAMF,OAAOG,MAAM,CAACJ,QAAQG,IAAI;IAEjDE,IAAAA,WAAI,EAAC,CAAC,4CAA4C,EAAEF,KAAK,CAAC,CAAC;AAC7D"}

package/dist/cjs/commands/watch/implementation.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "watch", {
+    enumerable: true,
+    get: function() {
+        return watch;
+    }
+});
+const _path = require("path");
+const _webpack = require("../../webpack");
+async function watch(config, options) {
+    const compiler = await (0, _webpack.getCompiler)(config, {
+        evaluate: config.evaluate,
+        watch: true,
+        spinner: options?.spinner
+    });
+    return new Promise((resolve, reject)=>{
+        compiler.watch({
+            ignored: [
+                '**/node_modules/**/*',
+                `**/${(0, _path.basename)(config.output.path)}/**/*`
+            ]
+        }, (watchError)=>{
+            if (watchError) {
+                reject(watchError);
+                return;
+            }
+            resolve(compiler.watching);
+        });
+    });
+}
+
+//# sourceMappingURL=implementation.js.map

package/dist/cjs/commands/watch/implementation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/commands/watch/implementation.ts"],"sourcesContent":["import { basename } from 'path';\nimport type { Watching } from 'webpack';\n\nimport type { ProcessedWebpackConfig } from '../../config';\nimport type { WebpackOptions } from '../../webpack';\nimport { getCompiler } from '../../webpack';\n\n/**\n * Build the snap bundle and watch for changes. This uses Webpack to build the\n * bundle.\n *\n * @param config - The config object.\n * @param options - The Webpack options.\n * @returns A promise that resolves when the bundle is built for the first time.\n * The promise resolves with a Webpack watching instance that can be used to\n * close the watcher.\n */\nexport async function watch(\n  config: ProcessedWebpackConfig,\n  options?: WebpackOptions,\n) {\n  const compiler = await getCompiler(config, {\n    evaluate: config.evaluate,\n    watch: true,\n    spinner: options?.spinner,\n  });\n\n  return new Promise<Watching>((resolve, reject) => {\n    compiler.watch(\n      {\n        ignored: [\n          '**/node_modules/**/*',\n          `**/${basename(config.output.path)}/**/*`,\n        ],\n      },\n      (watchError) => {\n        if (watchError) {\n          reject(watchError);\n          return;\n        }\n\n        resolve(compiler.watching);\n      },\n    );\n  });\n}\n"],"names":["watch","config","options","compiler","getCompiler","evaluate","spinner","Promise","resolve","reject","ignored","basename","output","path","watchError","watching"],"mappings":";;;;+BAiBsBA;;;eAAAA;;;sBAjBG;yBAKG;AAYrB,eAAeA,MACpBC,MAA8B,EAC9BC,OAAwB;IAExB,MAAMC,WAAW,MAAMC,IAAAA,oBAAW,EAACH,QAAQ;QACzCI,UAAUJ,OAAOI,QAAQ;QACzBL,OAAO;QACPM,SAASJ,SAASI;IACpB;IAEA,OAAO,IAAIC,QAAkB,CAACC,SAASC;QACrCN,SAASH,KAAK,CACZ;YACEU,SAAS;gBACP;gBACA,CAAC,GAAG,EAAEC,IAAAA,cAAQ,EAACV,OAAOW,MAAM,CAACC,IAAI,EAAE,KAAK,CAAC;aAC1C;QACH,GACA,CAACC;YACC,IAAIA,YAAY;gBACdL,OAAOK;gBACP;YACF;YAEAN,QAAQL,SAASY,QAAQ;QAC3B;IAEJ;AACF"}

package/dist/cjs/commands/watch/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _builders = /*#__PURE__*/ _interop_require_default(require("../../builders"));
+const _watch = require("./watch");
+_export_star(require("./implementation"), 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;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const command = {
+    command: [
+        'watch',
+        'w'
+    ],
+    desc: 'Build Snap on change',
+    builder: (yarg)=>{
+        yarg.option('src', _builders.default.src).option('eval', _builders.default.eval).option('dist', _builders.default.dist).option('outfileName', _builders.default.outfileName).option('sourceMaps', _builders.default.sourceMaps).option('stripComments', _builders.default.stripComments).option('transpilationMode', _builders.default.transpilationMode).option('depsToTranspile', _builders.default.depsToTranspile).option('manifest', _builders.default.manifest).option('writeManifest', _builders.default.writeManifest).option('serve', _builders.default.serve).option('root', _builders.default.root).option('port', _builders.default.port).implies('writeManifest', 'manifest').implies('depsToTranspile', 'transpilationMode');
+    },
+    handler: async (argv)=>(0, _watch.watchHandler)(argv.context.config, {
+            port: argv.port
+        })
+};
+const _default = command;
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/commands/watch/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/commands/watch/index.ts"],"sourcesContent":["import type yargs from 'yargs';\n\nimport builders from '../../builders';\nimport type { YargsArgs } from '../../types/yargs';\nimport { watchHandler } from './watch';\n\nconst command = {\n  command: ['watch', 'w'],\n  desc: 'Build Snap on change',\n  builder: (yarg: yargs.Argv) => {\n    yarg\n      .option('src', builders.src)\n      .option('eval', builders.eval)\n      .option('dist', builders.dist)\n      .option('outfileName', builders.outfileName)\n      .option('sourceMaps', builders.sourceMaps)\n      .option('stripComments', builders.stripComments)\n      .option('transpilationMode', builders.transpilationMode)\n      .option('depsToTranspile', builders.depsToTranspile)\n      .option('manifest', builders.manifest)\n      .option('writeManifest', builders.writeManifest)\n      .option('serve', builders.serve)\n      .option('root', builders.root)\n      .option('port', builders.port)\n      .implies('writeManifest', 'manifest')\n      .implies('depsToTranspile', 'transpilationMode');\n  },\n  handler: async (argv: YargsArgs) =>\n    watchHandler(argv.context.config, {\n      port: argv.port,\n    }),\n};\n\nexport * from './implementation';\nexport default command;\n"],"names":["command","desc","builder","yarg","option","builders","src","eval","dist","outfileName","sourceMaps","stripComments","transpilationMode","depsToTranspile","manifest","writeManifest","serve","root","port","implies","handler","argv","watchHandler","context","config"],"mappings":";;;;+BAkCA;;;eAAA;;;iEAhCqB;uBAEQ;qBA6Bf;;;;;;;;;;;;;;;;;;;AA3Bd,MAAMA,UAAU;IACdA,SAAS;QAAC;QAAS;KAAI;IACvBC,MAAM;IACNC,SAAS,CAACC;QACRA,KACGC,MAAM,CAAC,OAAOC,iBAAQ,CAACC,GAAG,EAC1BF,MAAM,CAAC,QAAQC,iBAAQ,CAACE,IAAI,EAC5BH,MAAM,CAAC,QAAQC,iBAAQ,CAACG,IAAI,EAC5BJ,MAAM,CAAC,eAAeC,iBAAQ,CAACI,WAAW,EAC1CL,MAAM,CAAC,cAAcC,iBAAQ,CAACK,UAAU,EACxCN,MAAM,CAAC,iBAAiBC,iBAAQ,CAACM,aAAa,EAC9CP,MAAM,CAAC,qBAAqBC,iBAAQ,CAACO,iBAAiB,EACtDR,MAAM,CAAC,mBAAmBC,iBAAQ,CAACQ,eAAe,EAClDT,MAAM,CAAC,YAAYC,iBAAQ,CAACS,QAAQ,EACpCV,MAAM,CAAC,iBAAiBC,iBAAQ,CAACU,aAAa,EAC9CX,MAAM,CAAC,SAASC,iBAAQ,CAACW,KAAK,EAC9BZ,MAAM,CAAC,QAAQC,iBAAQ,CAACY,IAAI,EAC5Bb,MAAM,CAAC,QAAQC,iBAAQ,CAACa,IAAI,EAC5BC,OAAO,CAAC,iBAAiB,YACzBA,OAAO,CAAC,mBAAmB;IAChC;IACAC,SAAS,OAAOC,OACdC,IAAAA,mBAAY,EAACD,KAAKE,OAAO,CAACC,MAAM,EAAE;YAChCN,MAAMG,KAAKH,IAAI;QACjB;AACJ;MAGA,WAAelB"}

package/dist/cjs/commands/watch/watch.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "watchHandler", {
+    enumerable: true,
+    get: function() {
+        return watchHandler;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+const _errors = require("../../errors");
+const _utils = require("../../utils");
+const _webpack = require("../../webpack");
+const _implementation = require("./implementation");
+const steps = [
+    {
+        name: 'Checking the input file.',
+        task: async ({ config })=>{
+            const { input } = config;
+            if (!await (0, _snapsutils.isFile)(input)) {
+                throw new _errors.CommandError(`Input file not found: "${input}". Make sure that the "input" field in your snap config is correct.`);
+            }
+        }
+    },
+    {
+        name: 'Starting the development server.',
+        condition: ({ config })=>config.server.enabled,
+        task: async ({ config, options, spinner })=>{
+            const server = (0, _webpack.getServer)(config);
+            const { port } = await server.listen(options.port ?? config.server.port);
+            (0, _utils.info)(`The server is listening on http://localhost:${port}.`, spinner);
+        }
+    },
+    {
+        name: 'Building the snap bundle.',
+        task: async ({ config, spinner })=>{
+            await (0, _implementation.watch)(config, {
+                spinner
+            });
+        }
+    }
+];
+async function watchHandler(config, options) {
+    await (0, _utils.executeSteps)(steps, {
+        config,
+        options
+    });
+}
+
+//# sourceMappingURL=watch.js.map

package/dist/cjs/commands/watch/watch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/commands/watch/watch.ts"],"sourcesContent":["import { isFile } from '@metamask/snaps-utils';\n\nimport type { ProcessedConfig, ProcessedWebpackConfig } from '../../config';\nimport { CommandError } from '../../errors';\nimport type { Steps } from '../../utils';\nimport { executeSteps, info } from '../../utils';\nimport { getServer } from '../../webpack';\nimport { watch } from './implementation';\n\ntype WatchOptions = {\n  /**\n   * The port to listen on.\n   */\n  port?: number;\n};\n\ntype WatchContext = {\n  config: ProcessedWebpackConfig;\n  options: WatchOptions;\n};\n\nconst steps: Steps<WatchContext> = [\n  {\n    name: 'Checking the input file.',\n    task: async ({ config }) => {\n      const { input } = config;\n\n      if (!(await isFile(input))) {\n        throw new CommandError(\n          `Input file not found: \"${input}\". Make sure that the \"input\" field in your snap config is correct.`,\n        );\n      }\n    },\n  },\n  {\n    name: 'Starting the development server.',\n    condition: ({ config }) => config.server.enabled,\n    task: async ({ config, options, spinner }) => {\n      const server = getServer(config);\n      const { port } = await server.listen(options.port ?? config.server.port);\n\n      info(`The server is listening on http://localhost:${port}.`, spinner);\n    },\n  },\n  {\n    name: 'Building the snap bundle.',\n    task: async ({ config, spinner }) => {\n      await watch(config, { spinner });\n    },\n  },\n];\n\n/**\n * Watch a directory and its subdirectories for changes, and build when files\n * are added or changed.\n *\n * Ignores 'node_modules' and dotfiles.\n * Creates destination directory if it doesn't exist.\n *\n * @param config - The config object.\n * @param options - The options object.\n */\nexport async function watchHandler(\n  config: ProcessedConfig,\n  options: WatchOptions,\n): Promise<void> {\n  await executeSteps(steps, { config, options });\n}\n"],"names":["watchHandler","steps","name","task","config","input","isFile","CommandError","condition","server","enabled","options","spinner","getServer","port","listen","info","watch","executeSteps"],"mappings":";;;;+BA8DsBA;;;eAAAA;;;4BA9DC;wBAGM;uBAEM;yBACT;gCACJ;AActB,MAAMC,QAA6B;IACjC;QACEC,MAAM;QACNC,MAAM,OAAO,EAAEC,MAAM,EAAE;YACrB,MAAM,EAAEC,KAAK,EAAE,GAAGD;YAElB,IAAI,CAAE,MAAME,IAAAA,kBAAM,EAACD,QAAS;gBAC1B,MAAM,IAAIE,oBAAY,CACpB,CAAC,uBAAuB,EAAEF,MAAM,mEAAmE,CAAC;YAExG;QACF;IACF;IACA;QACEH,MAAM;QACNM,WAAW,CAAC,EAAEJ,MAAM,EAAE,GAAKA,OAAOK,MAAM,CAACC,OAAO;QAChDP,MAAM,OAAO,EAAEC,MAAM,EAAEO,OAAO,EAAEC,OAAO,EAAE;YACvC,MAAMH,SAASI,IAAAA,kBAAS,EAACT;YACzB,MAAM,EAAEU,IAAI,EAAE,GAAG,MAAML,OAAOM,MAAM,CAACJ,QAAQG,IAAI,IAAIV,OAAOK,MAAM,CAACK,IAAI;YAEvEE,IAAAA,WAAI,EAAC,CAAC,4CAA4C,EAAEF,KAAK,CAAC,CAAC,EAAEF;QAC/D;IACF;IACA;QACEV,MAAM;QACNC,MAAM,OAAO,EAAEC,MAAM,EAAEQ,OAAO,EAAE;YAC9B,MAAMK,IAAAA,qBAAK,EAACb,QAAQ;gBAAEQ;YAAQ;QAChC;IACF;CACD;AAYM,eAAeZ,aACpBI,MAAuB,EACvBO,OAAqB;IAErB,MAAMO,IAAAA,mBAAY,EAACjB,OAAO;QAAEG;QAAQO;IAAQ;AAC9C"}

package/dist/cjs/config.js

@@ -0,0 +1,323 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    SnapsBrowserifyConfigStruct: function() {
+        return SnapsBrowserifyConfigStruct;
+    },
+    SnapsWebpackConfigStruct: function() {
+        return SnapsWebpackConfigStruct;
+    },
+    SnapsConfigStruct: function() {
+        return SnapsConfigStruct;
+    },
+    LegacyOptionsStruct: function() {
+        return LegacyOptionsStruct;
+    },
+    getConfig: function() {
+        return getConfig;
+    },
+    loadConfig: function() {
+        return loadConfig;
+    },
+    resolveConfig: function() {
+        return resolveConfig;
+    },
+    getConfigByArgv: function() {
+        return getConfigByArgv;
+    },
+    mergeLegacyOptions: function() {
+        return mergeLegacyOptions;
+    },
+    getWebpackConfig: function() {
+        return getWebpackConfig;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const _core = require("@swc/core");
+const _chalk = require("chalk");
+const _promises = require("fs/promises");
+const _module = /*#__PURE__*/ _interop_require_default(require("module"));
+const _path = require("path");
+const _superstruct = require("superstruct");
+const _builders = require("./builders");
+const _errors = require("./errors");
+const _utils1 = require("./utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const CONFIG_FILES = [
+    _utils1.CONFIG_FILE,
+    _utils1.TS_CONFIG_FILE
+];
+// This struct is essentially the same as the `func` struct, but it's defined
+// separately so that we include the function type in the inferred TypeScript
+// type definitions.
+const SnapsBrowserifyBundlerCustomizerFunctionStruct = (0, _superstruct.define)('function', (0, _superstruct.func)().validator);
+const SnapsBrowserifyConfigStruct = (0, _superstruct.object)({
+    bundler: (0, _superstruct.defaulted)((0, _snapsutils.literal)('browserify'), 'browserify'),
+    cliOptions: (0, _superstruct.defaulted)((0, _superstruct.object)({
+        bundle: (0, _superstruct.optional)((0, _snapsutils.file)()),
+        dist: (0, _superstruct.defaulted)((0, _snapsutils.file)(), 'dist'),
+        eval: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true),
+        manifest: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true),
+        port: (0, _superstruct.defaulted)((0, _superstruct.number)(), 8081),
+        outfileName: (0, _superstruct.defaulted)((0, _superstruct.string)(), 'bundle.js'),
+        root: (0, _superstruct.defaulted)((0, _snapsutils.file)(), process.cwd()),
+        sourceMaps: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+        src: (0, _superstruct.defaulted)((0, _snapsutils.file)(), 'src/index.js'),
+        stripComments: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true),
+        suppressWarnings: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+        transpilationMode: (0, _superstruct.defaulted)((0, _snapsutils.union)([
+            (0, _snapsutils.literal)('localAndDeps'),
+            (0, _snapsutils.literal)('localOnly'),
+            (0, _snapsutils.literal)('none')
+        ]), 'localOnly'),
+        depsToTranspile: (0, _superstruct.defaulted)((0, _superstruct.array)((0, _superstruct.string)()), []),
+        verboseErrors: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true),
+        writeManifest: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true),
+        serve: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true)
+    }), {}),
+    bundlerCustomizer: (0, _superstruct.optional)(SnapsBrowserifyBundlerCustomizerFunctionStruct)
+});
+// This struct is essentially the same as the `func` struct, but it's defined
+// separately so that we include the function type in the inferred TypeScript
+// type definitions.
+const SnapsWebpackCustomizeWebpackConfigFunctionStruct = (0, _superstruct.define)('function', (0, _superstruct.func)().validator);
+const SnapsWebpackConfigStruct = (0, _superstruct.object)({
+    bundler: (0, _snapsutils.literal)('webpack'),
+    input: (0, _superstruct.defaulted)((0, _snapsutils.file)(), (0, _path.resolve)(process.cwd(), 'src/index.js')),
+    sourceMap: (0, _superstruct.defaulted)((0, _snapsutils.union)([
+        (0, _superstruct.boolean)(),
+        (0, _snapsutils.literal)('inline')
+    ]), true),
+    evaluate: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true),
+    output: (0, _superstruct.defaulted)((0, _superstruct.object)({
+        path: (0, _superstruct.defaulted)((0, _snapsutils.file)(), (0, _path.resolve)(process.cwd(), 'dist')),
+        filename: (0, _superstruct.defaulted)((0, _superstruct.string)(), 'bundle.js'),
+        clean: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+        minimize: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true)
+    }), {}),
+    manifest: (0, _superstruct.defaulted)((0, _superstruct.object)({
+        path: (0, _superstruct.defaulted)((0, _snapsutils.file)(), (0, _path.resolve)(process.cwd(), 'snap.manifest.json')),
+        update: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true)
+    }), {}),
+    server: (0, _superstruct.defaulted)((0, _superstruct.object)({
+        enabled: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true),
+        root: (0, _superstruct.defaulted)((0, _snapsutils.file)(), process.cwd()),
+        port: (0, _superstruct.defaulted)((0, _superstruct.number)(), 8081)
+    }), {}),
+    environment: (0, _superstruct.defaulted)((0, _superstruct.record)((0, _superstruct.string)(), (0, _superstruct.unknown)()), {
+        NODE_DEBUG: false,
+        NODE_ENV: 'production',
+        DEBUG: false
+    }),
+    stats: (0, _superstruct.defaulted)((0, _superstruct.object)({
+        verbose: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+        builtIns: (0, _superstruct.defaulted)((0, _snapsutils.union)([
+            (0, _superstruct.object)({
+                ignore: (0, _superstruct.defaulted)((0, _superstruct.array)((0, _superstruct.string)()), [])
+            }),
+            (0, _snapsutils.literal)(false)
+        ]), {}),
+        buffer: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), true)
+    }), {}),
+    polyfills: (0, _superstruct.defaulted)((0, _snapsutils.union)([
+        (0, _superstruct.boolean)(),
+        (0, _superstruct.object)({
+            assert: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            buffer: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            console: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            constants: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            crypto: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            domain: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            events: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            http: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            https: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            os: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            path: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            punycode: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            process: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            querystring: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            stream: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            /* eslint-disable @typescript-eslint/naming-convention */ _stream_duplex: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            _stream_passthrough: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            _stream_readable: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            _stream_transform: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            _stream_writable: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            string_decoder: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            /* eslint-enable @typescript-eslint/naming-convention */ sys: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            timers: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            tty: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            url: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            util: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            vm: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false),
+            zlib: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false)
+        })
+    ]), false),
+    customizeWebpackConfig: (0, _superstruct.optional)(SnapsWebpackCustomizeWebpackConfigFunctionStruct),
+    experimental: (0, _superstruct.defaulted)((0, _superstruct.object)({
+        wasm: (0, _superstruct.defaulted)((0, _superstruct.boolean)(), false)
+    }), {})
+});
+const SnapsConfigStruct = (0, _superstruct.type)({
+    bundler: (0, _superstruct.defaulted)((0, _snapsutils.union)([
+        (0, _snapsutils.literal)('browserify'),
+        (0, _snapsutils.literal)('webpack')
+    ]), 'browserify')
+});
+const LegacyOptionsStruct = (0, _snapsutils.union)([
+    (0, _snapsutils.named)('object with `transpilationMode` set to `localAndDeps` and `depsToTranspile` set to an array of strings', (0, _superstruct.type)({
+        depsToTranspile: (0, _superstruct.array)((0, _superstruct.string)()),
+        transpilationMode: (0, _snapsutils.literal)(_builders.TranspilationModes.LocalAndDeps),
+        writeManifest: (0, _superstruct.boolean)(),
+        bundlerCustomizer: (0, _superstruct.optional)(SnapsBrowserifyBundlerCustomizerFunctionStruct)
+    })),
+    (0, _snapsutils.named)('object without `depsToTranspile`', (0, _superstruct.type)({
+        depsToTranspile: (0, _snapsutils.named)('empty array', (0, _superstruct.empty)((0, _superstruct.array)())),
+        transpilationMode: (0, _snapsutils.union)([
+            (0, _snapsutils.literal)(_builders.TranspilationModes.LocalOnly),
+            (0, _snapsutils.literal)(_builders.TranspilationModes.None)
+        ]),
+        writeManifest: (0, _superstruct.boolean)(),
+        bundlerCustomizer: (0, _superstruct.optional)(SnapsBrowserifyBundlerCustomizerFunctionStruct)
+    }))
+]);
+function getConfig(config, argv) {
+    const prefix = 'The snap config file is invalid';
+    const suffix = (0, _chalk.dim)(// TODO: Link to `docs.metamask.io` once the docs are published.
+    'Refer to the documentation for more information: https://github.com/MetaMask/snaps/tree/main/packages/snaps-cli/');
+    const { bundler } = (0, _snapsutils.createFromStruct)(config, SnapsConfigStruct, prefix, suffix);
+    if (bundler === 'browserify') {
+        const legacyConfig = (0, _snapsutils.createFromStruct)(config, SnapsBrowserifyConfigStruct, prefix, suffix);
+        return getWebpackConfig(mergeLegacyOptions(argv, legacyConfig));
+    }
+    return (0, _snapsutils.createFromStruct)(config, SnapsWebpackConfigStruct, prefix, suffix);
+}
+async function loadConfig(path, argv) {
+    try {
+        const contents = await (0, _promises.readFile)(path, 'utf8');
+        const source = await (0, _core.transform)(contents, {
+            swcrc: false,
+            jsc: {
+                parser: {
+                    syntax: 'typescript'
+                }
+            },
+            module: {
+                type: 'commonjs'
+            }
+        });
+        const config = new _module.default(path);
+        // @ts-expect-error - This function is not typed.
+        config.paths = _module.default._nodeModulePaths((0, _path.dirname)(path));
+        // @ts-expect-error - This function is not typed.
+        config._compile(source.code, path);
+        if (!(0, _utils.hasProperty)(config.exports, 'default')) {
+            return getConfig(config.exports, argv);
+        }
+        return getConfig(config.exports.default, argv);
+    } catch (error) {
+        if (error instanceof _snapsutils.SnapsStructError) {
+            throw new _errors.ConfigError(error.message);
+        }
+        throw new _errors.ConfigError(`Unable to load snap config file at "${path}".\n\n${(0, _snapsutils.indent)(error.message)}`);
+    }
+}
+async function resolveConfig(path, argv) {
+    for (const configFile of CONFIG_FILES){
+        const filePath = (0, _path.resolve)(path, configFile);
+        if (await (0, _snapsutils.isFile)(filePath)) {
+            return await loadConfig(filePath, argv);
+        }
+    }
+    throw new _errors.ConfigError(`Could not find a "snap.config.js" or "snap.config.ts" file in the current or specified directory ("${path}").`);
+}
+async function getConfigByArgv(argv, cwd = process.cwd()) {
+    if (argv.config) {
+        if (!await (0, _snapsutils.isFile)(argv.config)) {
+            throw new _errors.ConfigError(`Could not find a config file at "${argv.config}". Make sure that the path is correct.`);
+        }
+        return await loadConfig(argv.config, argv);
+    }
+    return await resolveConfig(cwd, argv);
+}
+function mergeLegacyOptions(argv, config) {
+    const cliOptions = Object.keys(config.cliOptions).reduce((accumulator, key)=>{
+        if (argv[key] !== undefined) {
+            return {
+                ...accumulator,
+                [key]: argv[key]
+            };
+        }
+        return accumulator;
+    }, config.cliOptions);
+    return {
+        ...config,
+        cliOptions
+    };
+}
+function getWebpackConfig(legacyConfig) {
+    const defaultConfig = (0, _superstruct.create)({
+        bundler: 'webpack'
+    }, SnapsWebpackConfigStruct);
+    // The legacy config has two options for specifying the output path and
+    // filename: `bundle`, and `dist` + `outfileName`. If `bundle` is specified,
+    // we use that as the output path and filename. Otherwise, we use `dist` and
+    // `outfileName`.
+    const path = legacyConfig.cliOptions.bundle ? (0, _path.dirname)(legacyConfig.cliOptions.bundle) : legacyConfig.cliOptions.dist;
+    const filename = legacyConfig.cliOptions.bundle ? (0, _path.basename)(legacyConfig.cliOptions.bundle) : legacyConfig.cliOptions.outfileName;
+    return {
+        ...defaultConfig,
+        input: legacyConfig.cliOptions.src,
+        evaluate: legacyConfig.cliOptions.eval,
+        sourceMap: legacyConfig.cliOptions.sourceMaps,
+        output: {
+            path,
+            filename,
+            // The legacy config has an option to remove comments from the bundle, but
+            // the terser plugin does this by default, so we only enable the terser if
+            // the legacy config has `stripComments` set to `true`. This is not a
+            // perfect solution, but it's the best we can do without breaking the
+            // legacy config.
+            minimize: legacyConfig.cliOptions.stripComments,
+            // The legacy config does not have a `clean` option, so we default to
+            // `false` here.
+            clean: false
+        },
+        manifest: {
+            // The legacy config does not have a `manifest` option, so we default to
+            // `process.cwd()/snap.manifest.json`.
+            path: (0, _path.resolve)(process.cwd(), 'snap.manifest.json'),
+            update: legacyConfig.cliOptions.writeManifest
+        },
+        server: {
+            enabled: legacyConfig.cliOptions.serve,
+            port: legacyConfig.cliOptions.port,
+            root: legacyConfig.cliOptions.root
+        },
+        stats: {
+            verbose: false,
+            // These plugins are designed to be used with the modern config format, so
+            // we disable them for the legacy config format.
+            builtIns: false,
+            buffer: false
+        },
+        legacy: (0, _snapsutils.createFromStruct)({
+            ...legacyConfig.cliOptions,
+            bundlerCustomizer: legacyConfig.bundlerCustomizer
+        }, LegacyOptionsStruct, 'Invalid Browserify CLI options')
+    };
+}
+
+//# sourceMappingURL=config.js.map