@metamask/snaps-jest 0.35.1-flask.1

package/dist/cjs/environment.js

@@ -0,0 +1,205 @@
+"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, {
+    SnapsEnvironment: function() {
+        return SnapsEnvironment;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _utils = require("@metamask/utils");
+const _jestenvironmentnode = /*#__PURE__*/ _interop_require_default(require("jest-environment-node"));
+const _webdriverio = require("webdriverio");
+const _internals = require("./internals");
+const _options = require("./options");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/* eslint-enable */ const log = (0, _utils.createModuleLogger)(_internals.rootLogger, 'environment');
+var _options1 = /*#__PURE__*/ new WeakMap(), _server = /*#__PURE__*/ new WeakMap();
+class SnapsEnvironment extends _jestenvironmentnode.default {
+    /**
+   * Set up the environment. This starts the built-in HTTP server, and creates a
+   * new browser instance.
+   */ async setup() {
+        await super.setup();
+        if (_class_private_field_get(this, _options1).server.enabled) {
+            log('Starting server.');
+            _class_private_field_set(this, _server, await (0, _internals.startServer)(_class_private_field_get(this, _options1).server));
+        }
+        const args = [];
+        if (_class_private_field_get(this, _options1).browser.headless) {
+            args.push('--headless', '--disable-gpu');
+        }
+        log('Starting browser.');
+        this.browser = await (0, _webdriverio.remote)({
+            logLevel: 'error',
+            capabilities: {
+                browserName: 'chrome',
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'goog:chromeOptions': {
+                    args
+                }
+            }
+        });
+        this.global.browser = this.browser;
+        this.global.snapsEnvironment = this;
+    }
+    /**
+   * Tear down the environment. This closes the browser, and stops the built-in
+   * HTTP server.
+   */ async teardown() {
+        if (_class_private_field_get(this, _options1).keepAlive) {
+            log('Not tearing down environment because keepAlive is enabled.');
+            return;
+        }
+        log('Closing browser, and stopping server.');
+        await this.browser?.deleteSession();
+        _class_private_field_get(this, _server)?.close();
+        await super.teardown();
+    }
+    /**
+   * Get the URL to the simulator, including the environment URL.
+   *
+   * @returns The simulator URL.
+   * @throws If the server is not running.
+   */ get url() {
+        (0, _utils.assert)(_class_private_field_get(this, _server), 'Server is not running.');
+        const { port } = _class_private_field_get(this, _server).address();
+        const simulatorUrl = _class_private_field_get(this, _options1).simulatorUrl ?? `http://localhost:${port}/simulator/`;
+        const executionEnvironmentUrl = _class_private_field_get(this, _options1).executionEnvironmentUrl ?? `http://localhost:${port}/environment/`;
+        return `${simulatorUrl}?environment=${encodeURIComponent(executionEnvironmentUrl)}`;
+    }
+    /**
+   * Get the snap ID for the current environment, which is used if no snap ID is
+   * passed to {@link installSnap}. This assumes that the built-in server is
+   * running.
+   *
+   * @returns The snap ID.
+   * @throws If the server is not running.
+   */ get snapId() {
+        (0, _utils.assert)(_class_private_field_get(this, _server), 'You must specify a snap ID, because the built-in server is not running.');
+        const { port } = _class_private_field_get(this, _server).address();
+        return `local:http://localhost:${port}`;
+    }
+    /**
+   * Create a new page, and attach logging handlers.
+   *
+   * @param url - The page URL. Defaults to the specified Snaps Simulator URL,
+   * or the default simulator URL if none is specified.
+   * @param timeout - The page timeout, in milliseconds.
+   * @returns The new page.
+   */ async createPage(url = this.url, timeout = 10000) {
+        const puppeteer = await this.browser.getPuppeteer();
+        const page = await puppeteer.newPage();
+        page.setDefaultTimeout(timeout);
+        page.setDefaultNavigationTimeout(timeout);
+        // Give the page permission to show notifications. This is required for
+        // testing `snap_notify`.
+        await page.browserContext().overridePermissions(url, [
+            'notifications'
+        ]);
+        // `networkidle0` is used to ensure that the page is fully loaded. This
+        // makes it wait for no requests to be made, which guarantees that the page
+        // is ready.
+        await page.goto(url, {
+            waitUntil: 'networkidle0'
+        });
+        const browserLog = (0, _utils.createModuleLogger)(_internals.rootLogger, 'browser');
+        page// This is fired when the page calls `console.log` or similar.
+        .on('console', (message)=>{
+            browserLog(`[${message.type()}] ${message.text()}`);
+        })// This is fired when the page throws an error.
+        .on('pageerror', ({ message })=>{
+            browserLog(`[page error] ${message}`);
+        });
+        return page;
+    }
+    /**
+   * Constructor.
+   *
+   * @param options - The environment options.
+   * @param context - The environment context.
+   */ constructor(options, context){
+        super(options, context);
+        // `browser` is always set in the environment setup function. To avoid needing
+        // to check for `undefined` everywhere, we use a type assertion here.
+        _define_property(this, "browser", void 0);
+        _class_private_field_init(this, _options1, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _server, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _options1, (0, _options.getOptions)(options.projectConfig.testEnvironmentOptions));
+    }
+}
+const _default = SnapsEnvironment;
+
+//# sourceMappingURL=environment.js.map

package/dist/cjs/environment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/environment.ts"],"sourcesContent":["import { EnvironmentContext, JestEnvironmentConfig } from '@jest/environment';\nimport { assert, createModuleLogger } from '@metamask/utils';\nimport { Server } from 'http';\nimport NodeEnvironment from 'jest-environment-node';\nimport { AddressInfo } from 'net';\nimport { Browser } from 'puppeteer';\nimport { remote } from 'webdriverio';\n\nimport { rootLogger, startServer } from './internals';\nimport { getOptions, SnapsEnvironmentOptions } from './options';\n\n/* eslint-disable */\ndeclare global {\n  const browser: WebdriverIO.Browser;\n  const snapsEnvironment: SnapsEnvironment;\n}\n/* eslint-enable */\n\nconst log = createModuleLogger(rootLogger, 'environment');\n\nexport class SnapsEnvironment extends NodeEnvironment {\n  // `browser` is always set in the environment setup function. To avoid needing\n  // to check for `undefined` everywhere, we use a type assertion here.\n  browser!: WebdriverIO.Browser;\n\n  #options: SnapsEnvironmentOptions;\n\n  #server: Server | undefined;\n\n  /**\n   * Constructor.\n   *\n   * @param options - The environment options.\n   * @param context - The environment context.\n   */\n  constructor(options: JestEnvironmentConfig, context: EnvironmentContext) {\n    super(options, context);\n    this.#options = getOptions(options.projectConfig.testEnvironmentOptions);\n  }\n\n  /**\n   * Set up the environment. This starts the built-in HTTP server, and creates a\n   * new browser instance.\n   */\n  async setup() {\n    await super.setup();\n\n    if (this.#options.server.enabled) {\n      log('Starting server.');\n      this.#server = await startServer(this.#options.server);\n    }\n\n    const args = [];\n    if (this.#options.browser.headless) {\n      args.push('--headless', '--disable-gpu');\n    }\n\n    log('Starting browser.');\n    this.browser = await remote({\n      logLevel: 'error',\n      capabilities: {\n        browserName: 'chrome',\n        // eslint-disable-next-line @typescript-eslint/naming-convention\n        'goog:chromeOptions': {\n          args,\n        },\n      },\n    });\n\n    this.global.browser = this.browser;\n    this.global.snapsEnvironment = this;\n  }\n\n  /**\n   * Tear down the environment. This closes the browser, and stops the built-in\n   * HTTP server.\n   */\n  async teardown() {\n    if (this.#options.keepAlive) {\n      log('Not tearing down environment because keepAlive is enabled.');\n      return;\n    }\n\n    log('Closing browser, and stopping server.');\n    await this.browser?.deleteSession();\n    this.#server?.close();\n\n    await super.teardown();\n  }\n\n  /**\n   * Get the URL to the simulator, including the environment URL.\n   *\n   * @returns The simulator URL.\n   * @throws If the server is not running.\n   */\n  get url() {\n    assert(this.#server, 'Server is not running.');\n\n    const { port } = this.#server.address() as AddressInfo;\n    const simulatorUrl =\n      this.#options.simulatorUrl ?? `http://localhost:${port}/simulator/`;\n\n    const executionEnvironmentUrl =\n      this.#options.executionEnvironmentUrl ??\n      `http://localhost:${port}/environment/`;\n\n    return `${simulatorUrl}?environment=${encodeURIComponent(\n      executionEnvironmentUrl,\n    )}`;\n  }\n\n  /**\n   * Get the snap ID for the current environment, which is used if no snap ID is\n   * passed to {@link installSnap}. This assumes that the built-in server is\n   * running.\n   *\n   * @returns The snap ID.\n   * @throws If the server is not running.\n   */\n  get snapId() {\n    assert(\n      this.#server,\n      'You must specify a snap ID, because the built-in server is not running.',\n    );\n\n    const { port } = this.#server.address() as AddressInfo;\n    return `local:http://localhost:${port}`;\n  }\n\n  /**\n   * Create a new page, and attach logging handlers.\n   *\n   * @param url - The page URL. Defaults to the specified Snaps Simulator URL,\n   * or the default simulator URL if none is specified.\n   * @param timeout - The page timeout, in milliseconds.\n   * @returns The new page.\n   */\n  async createPage(url: string = this.url, timeout = 10000) {\n    const puppeteer = (await this.browser.getPuppeteer()) as unknown as Browser;\n    const page = await puppeteer.newPage();\n\n    page.setDefaultTimeout(timeout);\n    page.setDefaultNavigationTimeout(timeout);\n\n    // Give the page permission to show notifications. This is required for\n    // testing `snap_notify`.\n    await page.browserContext().overridePermissions(url, ['notifications']);\n\n    // `networkidle0` is used to ensure that the page is fully loaded. This\n    // makes it wait for no requests to be made, which guarantees that the page\n    // is ready.\n    await page.goto(url, { waitUntil: 'networkidle0' });\n\n    const browserLog = createModuleLogger(rootLogger, 'browser');\n\n    page\n      // This is fired when the page calls `console.log` or similar.\n      .on('console', (message) => {\n        browserLog(`[${message.type()}] ${message.text()}`);\n      })\n\n      // This is fired when the page throws an error.\n      .on('pageerror', ({ message }) => {\n        browserLog(`[page error] ${message}`);\n      });\n\n    return page;\n  }\n}\n\nexport default SnapsEnvironment;\n"],"names":["SnapsEnvironment","log","createModuleLogger","rootLogger","NodeEnvironment","setup","options","server","enabled","startServer","args","browser","headless","push","remote","logLevel","capabilities","browserName","global","snapsEnvironment","teardown","keepAlive","deleteSession","close","url","assert","port","address","simulatorUrl","executionEnvironmentUrl","encodeURIComponent","snapId","createPage","timeout","puppeteer","getPuppeteer","page","newPage","setDefaultTimeout","setDefaultNavigationTimeout","browserContext","overridePermissions","goto","waitUntil","browserLog","on","message","type","text","constructor","context","getOptions","projectConfig","testEnvironmentOptions"],"mappings":"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"}

package/dist/cjs/helpers.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "installSnap", {
+    enumerable: true,
+    get: function() {
+        return installSnap;
+    }
+});
+const _utils = require("@metamask/utils");
+const _pptrtestinglibrary = require("pptr-testing-library");
+const _internals = require("./internals");
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const { getByTestId } = _pptrtestinglibrary.queries;
+const log = (0, _utils.createModuleLogger)(_internals.rootLogger, 'helpers');
+async function installSnap(snapId = (0, _internals.getEnvironment)().snapId) {
+    const environment = (0, _internals.getEnvironment)();
+    log('Installing snap %s.', snapId);
+    const page = await environment.createPage();
+    const document = await (0, _pptrtestinglibrary.getDocument)(page);
+    log('Setting snap ID to %s.', snapId);
+    await page.evaluate((payload)=>{
+        window.__SIMULATOR_API__.dispatch({
+            type: 'configuration/setSnapId',
+            payload
+        });
+    }, snapId);
+    log('Waiting for snap to install.');
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    await (0, _internals.waitFor)(async ()=>await getByTestId(document, 'status-ok'), {
+        timeout: 10000,
+        message: `Timed out waiting for snap to install. Make sure the snap ID ("${snapId}") is correct, and the server is running.`
+    });
+    return {
+        request: (options)=>{
+            log('Sending request %o.', options);
+            // Note: This function is intentionally not async, so that we can access
+            // the `getInterface` method on the response.
+            return (0, _internals.request)(page, options);
+        },
+        sendTransaction: async (options = {})=>{
+            log('Sending transaction %o.', options);
+            return await (0, _internals.sendTransaction)(page, options);
+        },
+        runCronjob: (options)=>{
+            log('Running cronjob %o.', options);
+            // Note: This function is intentionally not async, so that we can access
+            // the `getInterface` method on the response.
+            return (0, _internals.runCronjob)(page, options);
+        },
+        close: async ()=>{
+            log('Closing page.');
+            await page.close();
+        },
+        mock: async (options)=>{
+            log('Mocking %o.', options);
+            return await (0, _internals.mock)(page, options);
+        },
+        mockJsonRpc: async (options)=>{
+            log('Mocking JSON-RPC %o.', options);
+            return await (0, _internals.mockJsonRpc)(page, options);
+        }
+    };
+}
+
+//# sourceMappingURL=helpers.js.map

package/dist/cjs/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers.ts"],"sourcesContent":["import { createModuleLogger } from '@metamask/utils';\nimport { getDocument, queries } from 'pptr-testing-library';\n\nimport {\n  getEnvironment,\n  mock,\n  waitFor,\n  request,\n  sendTransaction,\n  runCronjob,\n  mockJsonRpc,\n  rootLogger,\n} from './internals';\nimport type { Snap, SnapResponse } from './types';\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nconst { getByTestId } = queries;\n\nconst log = createModuleLogger(rootLogger, 'helpers');\n\n/**\n * Load a snap into the environment. This is the main entry point for testing\n * snaps: It returns a {@link Snap} object that can be used to interact with the\n * snap.\n *\n * @example\n * ```ts\n * import { installSnap } from '@metamask/snaps-jest';\n *\n * describe('My Snap', () => {\n *   it('should do something', async () => {\n *     const { request } = await installSnap('local:my-snap');\n *     const response = await request({\n *       method: 'foo',\n *       params: ['bar'],\n *     });\n *     expect(response).toRespondWith('bar');\n *   });\n * });\n * ```\n * @param snapId - The ID of the snap, including the prefix (`local:`). Defaults\n * to the URL of the built-in server, if it is running. This supports both\n * local snap IDs and NPM snap IDs.\n * @returns The snap.\n * @throws If the built-in server is not running, and no snap ID is provided.\n */\nexport async function installSnap(\n  snapId: string = getEnvironment().snapId,\n): Promise<Snap> {\n  const environment = getEnvironment();\n\n  log('Installing snap %s.', snapId);\n\n  const page = await environment.createPage();\n  const document = await getDocument(page);\n\n  log('Setting snap ID to %s.', snapId);\n  await page.evaluate((payload) => {\n    window.__SIMULATOR_API__.dispatch({\n      type: 'configuration/setSnapId',\n      payload,\n    });\n  }, snapId);\n\n  log('Waiting for snap to install.');\n  // eslint-disable-next-line @typescript-eslint/no-misused-promises\n  await waitFor(async () => await getByTestId(document, 'status-ok'), {\n    timeout: 10000,\n    message: `Timed out waiting for snap to install. Make sure the snap ID (\"${snapId}\") is correct, and the server is running.`,\n  });\n\n  return {\n    request: (options) => {\n      log('Sending request %o.', options);\n\n      // Note: This function is intentionally not async, so that we can access\n      // the `getInterface` method on the response.\n      return request(page, options);\n    },\n\n    sendTransaction: async (options = {}): Promise<SnapResponse> => {\n      log('Sending transaction %o.', options);\n\n      return await sendTransaction(page, options);\n    },\n\n    runCronjob: (options) => {\n      log('Running cronjob %o.', options);\n\n      // Note: This function is intentionally not async, so that we can access\n      // the `getInterface` method on the response.\n      return runCronjob(page, options);\n    },\n\n    close: async () => {\n      log('Closing page.');\n\n      await page.close();\n    },\n\n    mock: async (options) => {\n      log('Mocking %o.', options);\n\n      return await mock(page, options);\n    },\n\n    mockJsonRpc: async (options) => {\n      log('Mocking JSON-RPC %o.', options);\n\n      return await mockJsonRpc(page, options);\n    },\n  };\n}\n"],"names":["installSnap","getByTestId","queries","log","createModuleLogger","rootLogger","snapId","getEnvironment","environment","page","createPage","document","getDocument","evaluate","payload","window","__SIMULATOR_API__","dispatch","type","waitFor","timeout","message","request","options","sendTransaction","runCronjob","close","mock","mockJsonRpc"],"mappings":";;;;+BA8CsBA;;;eAAAA;;;uBA9Ca;oCACE;2BAW9B;AAGP,6DAA6D;AAC7D,MAAM,EAAEC,WAAW,EAAE,GAAGC,2BAAO;AAE/B,MAAMC,MAAMC,IAAAA,yBAAkB,EAACC,qBAAU,EAAE;AA4BpC,eAAeL,YACpBM,SAAiBC,IAAAA,yBAAc,IAAGD,MAAM;IAExC,MAAME,cAAcD,IAAAA,yBAAc;IAElCJ,IAAI,uBAAuBG;IAE3B,MAAMG,OAAO,MAAMD,YAAYE,UAAU;IACzC,MAAMC,WAAW,MAAMC,IAAAA,+BAAW,EAACH;IAEnCN,IAAI,0BAA0BG;IAC9B,MAAMG,KAAKI,QAAQ,CAAC,CAACC;QACnBC,OAAOC,iBAAiB,CAACC,QAAQ,CAAC;YAChCC,MAAM;YACNJ;QACF;IACF,GAAGR;IAEHH,IAAI;IACJ,kEAAkE;IAClE,MAAMgB,IAAAA,kBAAO,EAAC,UAAY,MAAMlB,YAAYU,UAAU,cAAc;QAClES,SAAS;QACTC,SAAS,CAAC,+DAA+D,EAAEf,OAAO,yCAAyC,CAAC;IAC9H;IAEA,OAAO;QACLgB,SAAS,CAACC;YACRpB,IAAI,uBAAuBoB;YAE3B,wEAAwE;YACxE,6CAA6C;YAC7C,OAAOD,IAAAA,kBAAO,EAACb,MAAMc;QACvB;QAEAC,iBAAiB,OAAOD,UAAU,CAAC,CAAC;YAClCpB,IAAI,2BAA2BoB;YAE/B,OAAO,MAAMC,IAAAA,0BAAe,EAACf,MAAMc;QACrC;QAEAE,YAAY,CAACF;YACXpB,IAAI,uBAAuBoB;YAE3B,wEAAwE;YACxE,6CAA6C;YAC7C,OAAOE,IAAAA,qBAAU,EAAChB,MAAMc;QAC1B;QAEAG,OAAO;YACLvB,IAAI;YAEJ,MAAMM,KAAKiB,KAAK;QAClB;QAEAC,MAAM,OAAOJ;YACXpB,IAAI,eAAeoB;YAEnB,OAAO,MAAMI,IAAAA,eAAI,EAAClB,MAAMc;QAC1B;QAEAK,aAAa,OAAOL;YAClBpB,IAAI,wBAAwBoB;YAE5B,OAAO,MAAMK,IAAAA,sBAAW,EAACnB,MAAMc;QACjC;IACF;AACF"}

package/dist/cjs/index.js

@@ -0,0 +1,42 @@
+"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, {
+    default: function() {
+        return _environment.default;
+    },
+    TestEnvironment: function() {
+        return _environment.default;
+    }
+});
+const _environment = /*#__PURE__*/ _interop_require_default(require("./environment"));
+_export_star(require("./helpers"), exports);
+_export_star(require("./options"), exports);
+_export_star(require("./types"), 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
+    };
+}
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export { default, default as TestEnvironment } from './environment';\nexport * from './helpers';\nexport * from './options';\nexport * from './types';\n"],"names":["default","TestEnvironment"],"mappings":";;;;;;;;;;;IAASA,OAAO;eAAPA,oBAAO;;IAAaC,eAAe;eAAfA,oBAAe;;;oEAAQ;qBACtC;qBACA;qBACA"}

package/dist/cjs/internals/environment.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getEnvironment", {
+    enumerable: true,
+    get: function() {
+        return getEnvironment;
+    }
+});
+const _utils = require("@metamask/utils");
+function getEnvironment() {
+    // `snapsEnvironment` is a global variable that is set by the Jest
+    // environment.
+    (0, _utils.assert)(snapsEnvironment, 'Snaps environment not found. Make sure you have configured the environment correctly.');
+    return snapsEnvironment;
+}
+
+//# sourceMappingURL=environment.js.map

package/dist/cjs/internals/environment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/environment.ts"],"sourcesContent":["import { assert } from '@metamask/utils';\n\n/**\n * Get the Snaps environment. This asserts that the environment has been\n * configured.\n *\n * @returns The Snaps environment.\n */\nexport function getEnvironment() {\n  // `snapsEnvironment` is a global variable that is set by the Jest\n  // environment.\n  assert(\n    snapsEnvironment,\n    'Snaps environment not found. Make sure you have configured the environment correctly.',\n  );\n\n  return snapsEnvironment;\n}\n"],"names":["getEnvironment","assert","snapsEnvironment"],"mappings":";;;;+BAQgBA;;;eAAAA;;;uBARO;AAQhB,SAASA;IACd,kEAAkE;IAClE,eAAe;IACfC,IAAAA,aAAM,EACJC,kBACA;IAGF,OAAOA;AACT"}

package/dist/cjs/internals/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./environment"), exports);
+_export_star(require("./interface"), exports);
+_export_star(require("./logger"), exports);
+_export_star(require("./network"), exports);
+_export_star(require("./request"), exports);
+_export_star(require("./server"), exports);
+_export_star(require("./structs"), exports);
+_export_star(require("./types"), exports);
+_export_star(require("./wait-for"), 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/internals/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/index.ts"],"sourcesContent":["export * from './environment';\nexport * from './interface';\nexport * from './logger';\nexport * from './network';\nexport * from './request';\nexport * from './server';\nexport * from './structs';\n// eslint-disable-next-line import/export\nexport * from './types';\nexport * from './wait-for';\n"],"names":[],"mappings":";;;;qBAAc;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBAEA;qBACA"}

package/dist/cjs/internals/interface.js

@@ -0,0 +1,103 @@
+"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, {
+    getInterface: function() {
+        return getInterface;
+    },
+    getNotifications: function() {
+        return getNotifications;
+    }
+});
+const _rpcmethods = require("@metamask/rpc-methods");
+const _utils = require("@metamask/utils");
+const _superstruct = require("superstruct");
+const _structs = require("./structs");
+const _waitfor = require("./wait-for");
+async function getInterface(page, options = {}) {
+    const { timeout } = (0, _superstruct.create)(options, _structs.SnapOptionsStruct);
+    const { type, node: content } = await (0, _waitfor.waitFor)(async ()=>{
+        const ui = await page.evaluate(()=>{
+            const state = window.__SIMULATOR_API__.getState();
+            return state.simulation.ui;
+        });
+        (0, _utils.assert)(ui);
+        return ui;
+    }, {
+        timeout,
+        message: 'Timed out waiting for snap interface to be shown.'
+    });
+    switch(type){
+        case _rpcmethods.DialogType.Alert:
+            return {
+                type: 'alert',
+                content,
+                ok: async ()=>{
+                    await page.evaluate(()=>{
+                        window.__SIMULATOR_API__.dispatch({
+                            type: 'simulation/resolveUserInterface',
+                            payload: null
+                        });
+                    });
+                }
+            };
+        case _rpcmethods.DialogType.Confirmation:
+            return {
+                type: 'confirmation',
+                content,
+                ok: async ()=>{
+                    await page.evaluate(()=>{
+                        window.__SIMULATOR_API__.dispatch({
+                            type: 'simulation/resolveUserInterface',
+                            payload: true
+                        });
+                    });
+                },
+                cancel: async ()=>{
+                    await page.evaluate(()=>{
+                        window.__SIMULATOR_API__.dispatch({
+                            type: 'simulation/resolveUserInterface',
+                            payload: false
+                        });
+                    });
+                }
+            };
+        case _rpcmethods.DialogType.Prompt:
+            return {
+                type: 'prompt',
+                content,
+                ok: async (value)=>{
+                    await page.evaluate((payload)=>{
+                        window.__SIMULATOR_API__.dispatch({
+                            type: 'simulation/resolveUserInterface',
+                            payload
+                        });
+                    }, value);
+                },
+                cancel: async ()=>{
+                    await page.evaluate(()=>{
+                        window.__SIMULATOR_API__.dispatch({
+                            type: 'simulation/resolveUserInterface',
+                            payload: null
+                        });
+                    });
+                }
+            };
+        default:
+            throw new Error(`Unknown or unsupported dialog type: ${String(type)}.`);
+    }
+}
+async function getNotifications(page, requestId) {
+    return await page.evaluate((id)=>{
+        return window.__SIMULATOR_API__.getNotifications(id);
+    }, requestId);
+}
+
+//# sourceMappingURL=interface.js.map

package/dist/cjs/internals/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/interface.ts"],"sourcesContent":["import { DialogType } from '@metamask/rpc-methods';\nimport { assert } from '@metamask/utils';\nimport { Page } from 'puppeteer';\nimport { create } from 'superstruct';\n\nimport { SnapInterface, SnapOptions } from '../types';\nimport { SnapOptionsStruct } from './structs';\nimport { waitFor } from './wait-for';\n\n/**\n * Get the current snap user interface (i.e., dialog). This will throw an error\n * if the snap does not show a user interface within the timeout.\n *\n * @param page - The page to get the interface from.\n * @param options - The options to use.\n * @param options.timeout - The timeout in milliseconds to use. Defaults to\n * `1000`.\n * @returns The user interface object.\n */\nexport async function getInterface(\n  page: Page,\n  options: SnapOptions = {},\n): Promise<SnapInterface> {\n  const { timeout } = create(options, SnapOptionsStruct);\n\n  const { type, node: content } = await waitFor(\n    async () => {\n      const ui = await page.evaluate(() => {\n        const state = window.__SIMULATOR_API__.getState();\n        return state.simulation.ui;\n      });\n\n      assert(ui);\n      return ui;\n    },\n    {\n      timeout,\n      message: 'Timed out waiting for snap interface to be shown.',\n    },\n  );\n\n  switch (type) {\n    case DialogType.Alert:\n      return {\n        type: 'alert',\n        content,\n\n        ok: async () => {\n          await page.evaluate(() => {\n            window.__SIMULATOR_API__.dispatch({\n              type: 'simulation/resolveUserInterface',\n              payload: null,\n            });\n          });\n        },\n      };\n\n    case DialogType.Confirmation:\n      return {\n        type: 'confirmation',\n        content,\n\n        ok: async () => {\n          await page.evaluate(() => {\n            window.__SIMULATOR_API__.dispatch({\n              type: 'simulation/resolveUserInterface',\n              payload: true,\n            });\n          });\n        },\n\n        cancel: async () => {\n          await page.evaluate(() => {\n            window.__SIMULATOR_API__.dispatch({\n              type: 'simulation/resolveUserInterface',\n              payload: false,\n            });\n          });\n        },\n      };\n\n    case DialogType.Prompt:\n      return {\n        type: 'prompt',\n        content,\n\n        ok: async (value) => {\n          await page.evaluate((payload) => {\n            window.__SIMULATOR_API__.dispatch({\n              type: 'simulation/resolveUserInterface',\n              payload,\n            });\n          }, value);\n        },\n\n        cancel: async () => {\n          await page.evaluate(() => {\n            window.__SIMULATOR_API__.dispatch({\n              type: 'simulation/resolveUserInterface',\n              payload: null,\n            });\n          });\n        },\n      };\n\n    default:\n      throw new Error(`Unknown or unsupported dialog type: ${String(type)}.`);\n  }\n}\n\n/**\n * Get the text of the notifications.\n *\n * @param page - The page to get the notifications from.\n * @param requestId - The ID of the request to get the notifications for.\n * @returns The text of the notifications, in order of appearance.\n */\nexport async function getNotifications(page: Page, requestId: string) {\n  return await page.evaluate((id) => {\n    return window.__SIMULATOR_API__.getNotifications(id);\n  }, requestId);\n}\n"],"names":["getInterface","getNotifications","page","options","timeout","create","SnapOptionsStruct","type","node","content","waitFor","ui","evaluate","state","window","__SIMULATOR_API__","getState","simulation","assert","message","DialogType","Alert","ok","dispatch","payload","Confirmation","cancel","Prompt","value","Error","String","requestId","id"],"mappings":";;;;;;;;;;;IAmBsBA,YAAY;eAAZA;;IAkGAC,gBAAgB;eAAhBA;;;4BArHK;uBACJ;6BAEA;yBAGW;yBACV;AAYjB,eAAeD,aACpBE,IAAU,EACVC,UAAuB,CAAC,CAAC;IAEzB,MAAM,EAAEC,OAAO,EAAE,GAAGC,IAAAA,mBAAM,EAACF,SAASG,0BAAiB;IAErD,MAAM,EAAEC,IAAI,EAAEC,MAAMC,OAAO,EAAE,GAAG,MAAMC,IAAAA,gBAAO,EAC3C;QACE,MAAMC,KAAK,MAAMT,KAAKU,QAAQ,CAAC;YAC7B,MAAMC,QAAQC,OAAOC,iBAAiB,CAACC,QAAQ;YAC/C,OAAOH,MAAMI,UAAU,CAACN,EAAE;QAC5B;QAEAO,IAAAA,aAAM,EAACP;QACP,OAAOA;IACT,GACA;QACEP;QACAe,SAAS;IACX;IAGF,OAAQZ;QACN,KAAKa,sBAAU,CAACC,KAAK;YACnB,OAAO;gBACLd,MAAM;gBACNE;gBAEAa,IAAI;oBACF,MAAMpB,KAAKU,QAAQ,CAAC;wBAClBE,OAAOC,iBAAiB,CAACQ,QAAQ,CAAC;4BAChChB,MAAM;4BACNiB,SAAS;wBACX;oBACF;gBACF;YACF;QAEF,KAAKJ,sBAAU,CAACK,YAAY;YAC1B,OAAO;gBACLlB,MAAM;gBACNE;gBAEAa,IAAI;oBACF,MAAMpB,KAAKU,QAAQ,CAAC;wBAClBE,OAAOC,iBAAiB,CAACQ,QAAQ,CAAC;4BAChChB,MAAM;4BACNiB,SAAS;wBACX;oBACF;gBACF;gBAEAE,QAAQ;oBACN,MAAMxB,KAAKU,QAAQ,CAAC;wBAClBE,OAAOC,iBAAiB,CAACQ,QAAQ,CAAC;4BAChChB,MAAM;4BACNiB,SAAS;wBACX;oBACF;gBACF;YACF;QAEF,KAAKJ,sBAAU,CAACO,MAAM;YACpB,OAAO;gBACLpB,MAAM;gBACNE;gBAEAa,IAAI,OAAOM;oBACT,MAAM1B,KAAKU,QAAQ,CAAC,CAACY;wBACnBV,OAAOC,iBAAiB,CAACQ,QAAQ,CAAC;4BAChChB,MAAM;4BACNiB;wBACF;oBACF,GAAGI;gBACL;gBAEAF,QAAQ;oBACN,MAAMxB,KAAKU,QAAQ,CAAC;wBAClBE,OAAOC,iBAAiB,CAACQ,QAAQ,CAAC;4BAChChB,MAAM;4BACNiB,SAAS;wBACX;oBACF;gBACF;YACF;QAEF;YACE,MAAM,IAAIK,MAAM,CAAC,oCAAoC,EAAEC,OAAOvB,MAAM,CAAC,CAAC;IAC1E;AACF;AASO,eAAeN,iBAAiBC,IAAU,EAAE6B,SAAiB;IAClE,OAAO,MAAM7B,KAAKU,QAAQ,CAAC,CAACoB;QAC1B,OAAOlB,OAAOC,iBAAiB,CAACd,gBAAgB,CAAC+B;IACnD,GAAGD;AACL"}

package/dist/cjs/internals/logger.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "rootLogger", {
+    enumerable: true,
+    get: function() {
+        return rootLogger;
+    }
+});
+const _utils = require("@metamask/utils");
+const rootLogger = (0, _utils.createProjectLogger)('snaps-jest');
+
+//# sourceMappingURL=logger.js.map

package/dist/cjs/internals/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/internals/logger.ts"],"sourcesContent":["import { createProjectLogger } from '@metamask/utils';\n\nexport const rootLogger = createProjectLogger('snaps-jest');\n"],"names":["rootLogger","createProjectLogger"],"mappings":";;;;+BAEaA;;;eAAAA;;;uBAFuB;AAE7B,MAAMA,aAAaC,IAAAA,0BAAmB,EAAC"}