@metamask/snaps-jest 4.0.0 → 5.0.0

package/dist/esm/internals/types.js

@@ -1,3 +0,0 @@
-export { };
-
-//# sourceMappingURL=types.js.map

package/dist/esm/internals/types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/internals/types.ts"],"sourcesContent":["import type { NotificationType, EnumToUnion } from '@metamask/snaps-sdk';\nimport type { ApplicationState, Dispatch } from '@metamask/snaps-simulator';\n\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions\n  interface Window {\n    // This API is injected into the page by the simulator. It allows us to\n    // dispatch actions to the simulator, and read the state directly from the\n    // Redux store.\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    __SIMULATOR_API__: {\n      dispatch: Dispatch;\n      subscribe: (listener: () => void) => () => void;\n      getState: () => ApplicationState;\n      getRequestId: () => string;\n      getNotifications: (requestId: string) => {\n        id: string;\n        message: string;\n        type: EnumToUnion<NotificationType>;\n      }[];\n    };\n  }\n}\n\nexport {};\n"],"names":[],"mappings":"AAAA,WAwBU"}

package/dist/esm/internals/wait-for.js

@@ -1,63 +0,0 @@
-import { assert, createModuleLogger } from '@metamask/utils';
-import { waitFor as waitForPuppeteer } from 'pptr-testing-library';
-import { rootLogger } from './logger';
-const log = createModuleLogger(rootLogger, 'wait-for');
-/**
- * Wait for a condition to be true. This is a wrapper around
- * `pptr-testing-library`'s `waitFor` function, with the addition of a custom
- * error message.
- *
- * @param fn - The condition to wait for.
- * @param options - The options.
- * @param options.timeout - The timeout in milliseconds.
- * @param options.message - The error message to throw if the condition is not
- * met.
- * @returns A promise that resolves when the condition is met. The promise
- * resolves to the return value of the condition function.
- */ export async function waitFor(fn, { timeout = 3000, message } = {}) {
-    try {
-        let result;
-        await waitForPuppeteer(// eslint-disable-next-line @typescript-eslint/no-misused-promises
-        async ()=>{
-            // Puppeteer's `waitFor` function does not support returning a value
-            // from the condition function, so we need to use a variable outside
-            // the scope of the function.
-            result = await fn();
-        }, {
-            timeout
-        });
-        assert(result !== undefined);
-        return result;
-    } catch (error) {
-        if (message) {
-            throw new Error(message);
-        }
-        throw error;
-    }
-}
-/**
- * Wait for a JSON-RPC response.
- *
- * @param page - The page to wait for the response on.
- * @param type - The type of response to wait for.
- * @returns The JSON-RPC response.
- */ export async function waitForResponse(page, type) {
-    log('Waiting for response of type %s.', type);
-    return await page.evaluate(async (_type)=>{
-        return new Promise((resolve)=>{
-            window.__SIMULATOR_API__.dispatch({
-                type: `${_type}/clearResponse`
-            });
-            const unsubscribe = window.__SIMULATOR_API__.subscribe(()=>{
-                const state = window.__SIMULATOR_API__.getState();
-                const { pending, response } = state[_type];
-                if (!pending && response) {
-                    unsubscribe();
-                    resolve(response);
-                }
-            });
-        });
-    }, type);
-}
-
-//# sourceMappingURL=wait-for.js.map

package/dist/esm/internals/wait-for.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/internals/wait-for.ts"],"sourcesContent":["import type { HandlerType } from '@metamask/snaps-utils';\nimport { assert, createModuleLogger } from '@metamask/utils';\nimport { waitFor as waitForPuppeteer } from 'pptr-testing-library';\nimport type { Page } from 'puppeteer';\n\nimport type { SnapResponse } from '../types';\nimport { rootLogger } from './logger';\n\nexport type WaitForOptions = {\n  /**\n   * The timeout in milliseconds.\n   */\n  timeout?: number;\n\n  /**\n   * The error message to throw if the condition is not met.\n   */\n  message?: string;\n};\n\nconst log = createModuleLogger(rootLogger, 'wait-for');\n\n/**\n * Wait for a condition to be true. This is a wrapper around\n * `pptr-testing-library`'s `waitFor` function, with the addition of a custom\n * error message.\n *\n * @param fn - The condition to wait for.\n * @param options - The options.\n * @param options.timeout - The timeout in milliseconds.\n * @param options.message - The error message to throw if the condition is not\n * met.\n * @returns A promise that resolves when the condition is met. The promise\n * resolves to the return value of the condition function.\n */\nexport async function waitFor<Result>(\n  fn: () => Promise<Result>,\n  { timeout = 3000, message }: WaitForOptions = {},\n) {\n  try {\n    let result: Result | undefined;\n\n    await waitForPuppeteer(\n      // eslint-disable-next-line @typescript-eslint/no-misused-promises\n      async () => {\n        // Puppeteer's `waitFor` function does not support returning a value\n        // from the condition function, so we need to use a variable outside\n        // the scope of the function.\n        result = await fn();\n      },\n      {\n        timeout,\n      },\n    );\n\n    assert(result !== undefined);\n    return result;\n  } catch (error) {\n    if (message) {\n      throw new Error(message);\n    }\n\n    throw error;\n  }\n}\n\n/**\n * Wait for a JSON-RPC response.\n *\n * @param page - The page to wait for the response on.\n * @param type - The type of response to wait for.\n * @returns The JSON-RPC response.\n */\nexport async function waitForResponse(\n  page: Page,\n  type:\n    | HandlerType.OnTransaction\n    | HandlerType.OnRpcRequest\n    | HandlerType.OnCronjob,\n) {\n  log('Waiting for response of type %s.', type);\n\n  return await page.evaluate(async (_type) => {\n    return new Promise<SnapResponse['response']>((resolve) => {\n      window.__SIMULATOR_API__.dispatch({\n        type: `${_type}/clearResponse`,\n      });\n\n      const unsubscribe = window.__SIMULATOR_API__.subscribe(() => {\n        const state = window.__SIMULATOR_API__.getState();\n        const { pending, response } = state[_type];\n\n        if (!pending && response) {\n          unsubscribe();\n\n          resolve(response);\n        }\n      });\n    });\n  }, type);\n}\n"],"names":["assert","createModuleLogger","waitFor","waitForPuppeteer","rootLogger","log","fn","timeout","message","result","undefined","error","Error","waitForResponse","page","type","evaluate","_type","Promise","resolve","window","__SIMULATOR_API__","dispatch","unsubscribe","subscribe","state","getState","pending","response"],"mappings":"AACA,SAASA,MAAM,EAAEC,kBAAkB,QAAQ,kBAAkB;AAC7D,SAASC,WAAWC,gBAAgB,QAAQ,uBAAuB;AAInE,SAASC,UAAU,QAAQ,WAAW;AActC,MAAMC,MAAMJ,mBAAmBG,YAAY;AAE3C;;;;;;;;;;;;CAYC,GACD,OAAO,eAAeF,QACpBI,EAAyB,EACzB,EAAEC,UAAU,IAAI,EAAEC,OAAO,EAAkB,GAAG,CAAC,CAAC;IAEhD,IAAI;QACF,IAAIC;QAEJ,MAAMN,iBACJ,kEAAkE;QAClE;YACE,oEAAoE;YACpE,oEAAoE;YACpE,6BAA6B;YAC7BM,SAAS,MAAMH;QACjB,GACA;YACEC;QACF;QAGFP,OAAOS,WAAWC;QAClB,OAAOD;IACT,EAAE,OAAOE,OAAO;QACd,IAAIH,SAAS;YACX,MAAM,IAAII,MAAMJ;QAClB;QAEA,MAAMG;IACR;AACF;AAEA;;;;;;CAMC,GACD,OAAO,eAAeE,gBACpBC,IAAU,EACVC,IAGyB;IAEzBV,IAAI,oCAAoCU;IAExC,OAAO,MAAMD,KAAKE,QAAQ,CAAC,OAAOC;QAChC,OAAO,IAAIC,QAAkC,CAACC;YAC5CC,OAAOC,iBAAiB,CAACC,QAAQ,CAAC;gBAChCP,MAAM,CAAC,EAAEE,MAAM,cAAc,CAAC;YAChC;YAEA,MAAMM,cAAcH,OAAOC,iBAAiB,CAACG,SAAS,CAAC;gBACrD,MAAMC,QAAQL,OAAOC,iBAAiB,CAACK,QAAQ;gBAC/C,MAAM,EAAEC,OAAO,EAAEC,QAAQ,EAAE,GAAGH,KAAK,CAACR,MAAM;gBAE1C,IAAI,CAACU,WAAWC,UAAU;oBACxBL;oBAEAJ,QAAQS;gBACV;YACF;QACF;IACF,GAAGb;AACL"}

package/dist/types/internals/interface.d.ts

@@ -1,25 +0,0 @@
-import type { Page } from 'puppeteer';
-import type { SnapInterface, SnapOptions } from '../types';
-/**
- * Get the current snap user interface (i.e., dialog). This will throw an error
- * if the snap does not show a user interface within the timeout.
- *
- * @param page - The page to get the interface from.
- * @param options - The options to use.
- * @param options.timeout - The timeout in milliseconds to use. Defaults to
- * `1000`.
- * @returns The user interface object.
- */
-export declare function getInterface(page: Page, options?: SnapOptions): Promise<SnapInterface>;
-/**
- * Get the text of the notifications.
- *
- * @param page - The page to get the notifications from.
- * @param requestId - The ID of the request to get the notifications for.
- * @returns The text of the notifications, in order of appearance.
- */
-export declare function getNotifications(page: Page, requestId: string): Promise<{
-    id: string;
-    message: string;
-    type: "native" | "inApp";
-}[]>;

package/dist/types/internals/network.d.ts

@@ -1,87 +0,0 @@
-import type { Page, HTTPRequest } from 'puppeteer';
-import type { Infer, Struct } from 'superstruct';
-import type { DeepPartial } from '../types';
-export declare type Unmock = () => Promise<void>;
-export declare type Mock = {
-    /**
-     * A function that can be used to unmock the URL.
-     */
-    unmock: Unmock;
-};
-/**
- * A function that can return `true` if the given request should be mocked, or
- * false if not.
- *
- * @param request - The request to check.
- * @returns Whether to mock the request.
- */
-export declare type ConditionFunction = (request: HTTPRequest) => boolean;
-export declare const MockOptionsStruct: Struct<{
-    response: {
-        headers: Record<string, unknown>;
-        status: number;
-        body: string;
-        contentType: string;
-    };
-    url: string | RegExp;
-    partial?: boolean | undefined;
-} | {
-    response: {
-        headers: Record<string, unknown>;
-        status: number;
-        body: string;
-        contentType: string;
-    };
-    condition: ConditionFunction;
-}, null>;
-/**
- * The options for the network mocking.
- *
- * @property url - The URL to mock. If a string is provided, the URL will be
- * matched exactly. If a RegExp is provided, the URL will be matched against it.
- * This option is incompatible with the `condition` option.
- * @property partial - If enabled, the request will be mocked if the URL starts
- * with the given URL. This option is ignored if a RegExp is provided to the
- * `url` option. This option is incompatible with the `condition` option.
- * @property condition - A function which gets the {@link HTTPRequest} as
- * parameter and returns a boolean to indicate whether the response should be
- * mocked or not. This option is incompatible with the `url` and `partial`
- * options.
- * @property response - The response to send for the request.
- * @property response.status - The status code to send for the response.
- * Defaults to `200`.
- * @property response.headers - The headers to send for the response. Defaults
- * to headers that enable CORS.
- * @property response.contentType - The content type to send for the response.
- * Defaults to `text/plain`.
- */
-export declare type MockOptions = Infer<typeof MockOptionsStruct>;
-/**
- * Enable network mocking for the given page, and all its sub-frames.
- *
- * @param page - The page to enable network mocking on.
- * @param options - The options for the network mocking.
- * @returns A {@link Mock} object, with an `unmock` function.
- */
-export declare function mock(page: Page, options: DeepPartial<MockOptions>): Promise<Mock>;
-declare const MockJsonRpcOptionsStruct: Struct<{
-    method: string;
-    result: import("@metamask/utils").Json;
-}, {
-    method: Struct<string, null>;
-    result: Struct<import("@metamask/utils").Json, unknown>;
-}>;
-export declare type MockJsonRpcOptions = Infer<typeof MockJsonRpcOptionsStruct>;
-/**
- * Mock an Ethereum JSON-RPC request. This intercepts all requests to the
- * Ethereum provider, and returns the `result` instead.
- *
- * @param page - The page to enable network JSON-RPC mocking on.
- * @param options - The options for the JSON-RPC mock.
- * @param options.method - The JSON-RPC method to mock. Any other methods will be
- * forwarded to the provider.
- * @param options.result - The JSON response to return.
- * @returns A {@link Mock} object, with an `unmock` function.
- */
-export declare function mockJsonRpc(page: Page, { method, result }: MockJsonRpcOptions): Promise<Mock>;
-export {};

package/dist/types/internals/types.d.ts

@@ -1,18 +0,0 @@
-import type { NotificationType, EnumToUnion } from '@metamask/snaps-sdk';
-import type { ApplicationState, Dispatch } from '@metamask/snaps-simulator';
-declare global {
-    interface Window {
-        __SIMULATOR_API__: {
-            dispatch: Dispatch;
-            subscribe: (listener: () => void) => () => void;
-            getState: () => ApplicationState;
-            getRequestId: () => string;
-            getNotifications: (requestId: string) => {
-                id: string;
-                message: string;
-                type: EnumToUnion<NotificationType>;
-            }[];
-        };
-    }
-}
-export {};

package/dist/types/internals/wait-for.d.ts

@@ -1,38 +0,0 @@
-import type { HandlerType } from '@metamask/snaps-utils';
-import type { Page } from 'puppeteer';
-export declare type WaitForOptions = {
-    /**
-     * The timeout in milliseconds.
-     */
-    timeout?: number;
-    /**
-     * The error message to throw if the condition is not met.
-     */
-    message?: string;
-};
-/**
- * Wait for a condition to be true. This is a wrapper around
- * `pptr-testing-library`'s `waitFor` function, with the addition of a custom
- * error message.
- *
- * @param fn - The condition to wait for.
- * @param options - The options.
- * @param options.timeout - The timeout in milliseconds.
- * @param options.message - The error message to throw if the condition is not
- * met.
- * @returns A promise that resolves when the condition is met. The promise
- * resolves to the return value of the condition function.
- */
-export declare function waitFor<Result>(fn: () => Promise<Result>, { timeout, message }?: WaitForOptions): Promise<Result & ({} | null)>;
-/**
- * Wait for a JSON-RPC response.
- *
- * @param page - The page to wait for the response on.
- * @param type - The type of response to wait for.
- * @returns The JSON-RPC response.
- */
-export declare function waitForResponse(page: Page, type: HandlerType.OnTransaction | HandlerType.OnRpcRequest | HandlerType.OnCronjob): Promise<{
-    result: import("@metamask/utils").Json;
-} | {
-    error: import("@metamask/utils").Json;
-}>;