@metamask/snaps-sdk 6.3.0 → 6.4.0

package/dist/internals/structs.cjs

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectiveUnion = exports.typedUnion = exports.enumValue = exports.union = exports.literal = void 0;
+const superstruct_1 = require("@metamask/superstruct");
+const utils_1 = require("@metamask/utils");
+/**
+ * A wrapper of `superstruct`'s `literal` struct that also defines the name of
+ * the struct as the literal value.
+ *
+ * This is useful for improving the error messages returned by `superstruct`.
+ * For example, instead of returning an error like:
+ *
+ * ```
+ * Expected the value to satisfy a union of `literal | literal`, but received: \"baz\"
+ * ```
+ *
+ * This struct will return an error like:
+ *
+ * ```
+ * Expected the value to satisfy a union of `"foo" | "bar"`, but received: \"baz\"
+ * ```
+ *
+ * @param value - The literal value.
+ * @returns The `superstruct` struct, which validates that the value is equal
+ * to the literal value.
+ */
+function literal(value) {
+    return (0, superstruct_1.define)(JSON.stringify(value), (0, superstruct_1.literal)(value).validator);
+}
+exports.literal = literal;
+/**
+ * A wrapper of `superstruct`'s `union` struct that also defines the schema as
+ * the union of the schemas of the structs.
+ *
+ * This is useful for improving the error messages returned by `superstruct`.
+ *
+ * @param structs - The structs to union.
+ * @param structs."0" - The first struct.
+ * @param structs."1" - The remaining structs.
+ * @returns The `superstruct` struct, which validates that the value satisfies
+ * one of the structs.
+ */
+function union([head, ...tail]) {
+    const struct = (0, superstruct_1.union)([head, ...tail]);
+    return new superstruct_1.Struct({
+        ...struct,
+        schema: [head, ...tail],
+    });
+}
+exports.union = union;
+/**
+ * Superstruct struct for validating an enum value. This allows using both the
+ * enum string values and the enum itself as values.
+ *
+ * @param constant - The enum to validate against.
+ * @returns The superstruct struct.
+ */
+function enumValue(constant) {
+    return literal(constant);
+}
+exports.enumValue = enumValue;
+/**
+ * Create a custom union struct that validates exclusively based on a `type` field.
+ *
+ * This should improve error messaging for unions with many structs in them.
+ *
+ * @param structs - The structs to union.
+ * @returns The `superstruct` struct, which validates that the value satisfies
+ * one of the structs.
+ */
+function typedUnion(structs) {
+    const flatStructs = structs
+        .map((struct) => struct.type === 'union' && Array.isArray(struct.schema)
+        ? struct.schema
+        : struct)
+        .flat(Infinity);
+    const types = flatStructs.map(({ schema }) => schema.type.type);
+    return new superstruct_1.Struct({
+        type: 'union',
+        schema: flatStructs,
+        *entries(value, context) {
+            if (!(0, utils_1.isPlainObject)(value) || !(0, utils_1.hasProperty)(value, 'type')) {
+                return;
+            }
+            const { type } = value;
+            const struct = flatStructs.find(({ schema }) => (0, superstruct_1.is)(type, schema.type));
+            if (!struct) {
+                return;
+            }
+            for (const entry of struct.entries(value, context)) {
+                yield entry;
+            }
+        },
+        coercer(value, context) {
+            if (!(0, utils_1.isPlainObject)(value) || !(0, utils_1.hasProperty)(value, 'type')) {
+                return value;
+            }
+            const { type } = value;
+            const struct = flatStructs.find(({ schema }) => (0, superstruct_1.is)(type, schema.type));
+            if (struct) {
+                return struct.coercer(value, context);
+            }
+            return value;
+        },
+        // At this point we know the value to be an object.
+        *refiner(value, context) {
+            const struct = flatStructs.find(({ schema }) => (0, superstruct_1.is)(value.type, schema.type));
+            yield* struct.refiner(value, context);
+        },
+        validator(value, context) {
+            if (!(0, utils_1.isPlainObject)(value) ||
+                !(0, utils_1.hasProperty)(value, 'type') ||
+                typeof value.type !== 'string') {
+                return `Expected type to be one of: ${types.join(', ')}, but received: undefined`;
+            }
+            const { type } = value;
+            const struct = flatStructs.find(({ schema }) => (0, superstruct_1.is)(type, schema.type));
+            if (struct) {
+                // This only validates the root of the struct, entries does the rest of the work.
+                return struct.validator(value, context);
+            }
+            return `Expected type to be one of: ${types.join(', ')}, but received: "${type}"`;
+        },
+    });
+}
+exports.typedUnion = typedUnion;
+/**
+ * Create a custom union struct that uses a `selector` function for choosing
+ * the validation path.
+ *
+ * @param selector - The selector function choosing the struct to validate with.
+ * @returns The `superstruct` struct, which validates that the value satisfies
+ * one of the structs.
+ */
+function selectiveUnion(selector) {
+    return new superstruct_1.Struct({
+        type: 'union',
+        schema: null,
+        *entries(value, context) {
+            const struct = selector(value);
+            for (const entry of struct.entries(value, context)) {
+                yield entry;
+            }
+        },
+        *refiner(value, context) {
+            const struct = selector(value);
+            yield* struct.refiner(value, context);
+        },
+        coercer(value, context) {
+            const struct = selector(value);
+            return struct.coercer(value, context);
+        },
+        validator(value, context) {
+            const struct = selector(value);
+            // This only validates the root of the struct, entries does the rest of the work.
+            return struct.validator(value, context);
+        },
+    });
+}
+exports.selectiveUnion = selectiveUnion;
+//# sourceMappingURL=structs.cjs.map

package/dist/internals/structs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"structs.cjs","sourceRoot":"","sources":["../../src/internals/structs.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AnyStruct, Infer, InferStructTuple } from '@metamask/superstruct';\nimport {\n  Struct,\n  define,\n  is,\n  literal as superstructLiteral,\n  union as superstructUnion,\n} from '@metamask/superstruct';\nimport type { PlainObject } from '@metamask/utils';\nimport { hasProperty, isPlainObject } from '@metamask/utils';\n\nimport type { EnumToUnion } from './helpers';\n\n/**\n * A wrapper of `superstruct`'s `literal` struct that also defines the name of\n * the struct as the literal value.\n *\n * This is useful for improving the error messages returned by `superstruct`.\n * For example, instead of returning an error like:\n *\n * ```\n * Expected the value to satisfy a union of `literal | literal`, but received: \\\"baz\\\"\n * ```\n *\n * This struct will return an error like:\n *\n * ```\n * Expected the value to satisfy a union of `\"foo\" | \"bar\"`, but received: \\\"baz\\\"\n * ```\n *\n * @param value - The literal value.\n * @returns The `superstruct` struct, which validates that the value is equal\n * to the literal value.\n */\nexport function literal<Type extends string | number | boolean>(value: Type) {\n  return define<Type>(\n    JSON.stringify(value),\n    superstructLiteral(value).validator,\n  );\n}\n\n/**\n * A wrapper of `superstruct`'s `union` struct that also defines the schema as\n * the union of the schemas of the structs.\n *\n * This is useful for improving the error messages returned by `superstruct`.\n *\n * @param structs - The structs to union.\n * @param structs.\"0\" - The first struct.\n * @param structs.\"1\" - The remaining structs.\n * @returns The `superstruct` struct, which validates that the value satisfies\n * one of the structs.\n */\nexport function union<Head extends AnyStruct, Tail extends AnyStruct[]>([\n  head,\n  ...tail\n]: [head: Head, ...tail: Tail]): Struct<\n  Infer<Head> | InferStructTuple<Tail>[number],\n  [head: Head, ...tail: Tail]\n> {\n  const struct = superstructUnion([head, ...tail]);\n\n  return new Struct({\n    ...struct,\n    schema: [head, ...tail],\n  });\n}\n\n/**\n * Superstruct struct for validating an enum value. This allows using both the\n * enum string values and the enum itself as values.\n *\n * @param constant - The enum to validate against.\n * @returns The superstruct struct.\n */\nexport function enumValue<Type extends string>(\n  constant: Type,\n): Struct<EnumToUnion<Type>, null> {\n  return literal(constant as EnumToUnion<Type>);\n}\n\n/**\n * Create a custom union struct that validates exclusively based on a `type` field.\n *\n * This should improve error messaging for unions with many structs in them.\n *\n * @param structs - The structs to union.\n * @returns The `superstruct` struct, which validates that the value satisfies\n * one of the structs.\n */\nexport function typedUnion<Head extends AnyStruct, Tail extends AnyStruct[]>(\n  structs: [head: Head, ...tail: Tail],\n): Struct<Infer<Head> | InferStructTuple<Tail>[number], null> {\n  const flatStructs = structs\n    .map((struct) =>\n      struct.type === 'union' && Array.isArray(struct.schema)\n        ? struct.schema\n        : struct,\n    )\n    .flat(Infinity);\n  const types = flatStructs.map(({ schema }) => schema.type.type);\n  return new Struct({\n    type: 'union',\n    schema: flatStructs,\n    *entries(value, context) {\n      if (!isPlainObject(value) || !hasProperty(value, 'type')) {\n        return;\n      }\n\n      const { type } = value;\n      const struct = flatStructs.find(({ schema }) => is(type, schema.type));\n\n      if (!struct) {\n        return;\n      }\n\n      for (const entry of struct.entries(value, context)) {\n        yield entry;\n      }\n    },\n    coercer(value, context) {\n      if (!isPlainObject(value) || !hasProperty(value, 'type')) {\n        return value;\n      }\n\n      const { type } = value;\n      const struct = flatStructs.find(({ schema }) => is(type, schema.type));\n      if (struct) {\n        return struct.coercer(value, context);\n      }\n\n      return value;\n    },\n    // At this point we know the value to be an object.\n    *refiner(value: PlainObject, context) {\n      const struct = flatStructs.find(({ schema }) =>\n        is(value.type, schema.type),\n      );\n\n      yield* struct.refiner(value, context);\n    },\n    validator(value, context) {\n      if (\n        !isPlainObject(value) ||\n        !hasProperty(value, 'type') ||\n        typeof value.type !== 'string'\n      ) {\n        return `Expected type to be one of: ${types.join(\n          ', ',\n        )}, but received: undefined`;\n      }\n\n      const { type } = value;\n\n      const struct = flatStructs.find(({ schema }) => is(type, schema.type));\n\n      if (struct) {\n        // This only validates the root of the struct, entries does the rest of the work.\n        return struct.validator(value, context);\n      }\n\n      return `Expected type to be one of: ${types.join(\n        ', ',\n      )}, but received: \"${type}\"`;\n    },\n  }) as unknown as Struct<Infer<Head> | InferStructTuple<Tail>[number], null>;\n}\n\n/**\n * Create a custom union struct that uses a `selector` function for choosing\n * the validation path.\n *\n * @param selector - The selector function choosing the struct to validate with.\n * @returns The `superstruct` struct, which validates that the value satisfies\n * one of the structs.\n */\nexport function selectiveUnion<Selector extends (value: any) => AnyStruct>(\n  selector: Selector,\n): Struct<Infer<ReturnType<Selector>>, null> {\n  return new Struct({\n    type: 'union',\n    schema: null,\n    *entries(value, context) {\n      const struct = selector(value);\n\n      for (const entry of struct.entries(value, context)) {\n        yield entry;\n      }\n    },\n    *refiner(value, context) {\n      const struct = selector(value);\n\n      yield* struct.refiner(value, context);\n    },\n    coercer(value, context) {\n      const struct = selector(value);\n\n      return struct.coercer(value, context);\n    },\n    validator(value, context) {\n      const struct = selector(value);\n\n      // This only validates the root of the struct, entries does the rest of the work.\n      return struct.validator(value, context);\n    },\n  });\n}\n"]}

package/dist/{types/internals/structs.d.ts → internals/structs.d.cts}

@@ -1,6 +1,6 @@
-import type { AnyStruct, Infer, InferStructTuple } from '@metamask/superstruct';
-import { Struct } from '@metamask/superstruct';
-import type { EnumToUnion } from './helpers';
+import type { AnyStruct, Infer, InferStructTuple } from "@metamask/superstruct";
+import { Struct } from "@metamask/superstruct";
+import type { EnumToUnion } from "./helpers.cjs";
 /**
  * A wrapper of `superstruct`'s `literal` struct that also defines the name of
  * the struct as the literal value.
@@ -57,3 +57,13 @@ export declare function enumValue<Type extends string>(constant: Type): Struct<E
  * one of the structs.
  */
 export declare function typedUnion<Head extends AnyStruct, Tail extends AnyStruct[]>(structs: [head: Head, ...tail: Tail]): Struct<Infer<Head> | InferStructTuple<Tail>[number], null>;
+/**
+ * Create a custom union struct that uses a `selector` function for choosing
+ * the validation path.
+ *
+ * @param selector - The selector function choosing the struct to validate with.
+ * @returns The `superstruct` struct, which validates that the value satisfies
+ * one of the structs.
+ */
+export declare function selectiveUnion<Selector extends (value: any) => AnyStruct>(selector: Selector): Struct<Infer<ReturnType<Selector>>, null>;
+//# sourceMappingURL=structs.d.cts.map

package/dist/internals/structs.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structs.d.cts","sourceRoot":"","sources":["../../src/internals/structs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,gBAAgB,EAAE,8BAA8B;AAChF,OAAO,EACL,MAAM,EAKP,8BAA8B;AAI/B,OAAO,KAAK,EAAE,WAAW,EAAE,sBAAkB;AAE7C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,KAAK,EAAE,IAAI,sBAK1E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,IAAI,SAAS,SAAS,EAAE,IAAI,SAAS,SAAS,EAAE,EAAE,CACtE,IAAI,EACJ,GAAG,IAAI,CACR,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,CAAC,GAAG,MAAM,CACrC,KAAK,CAAC,IAAI,CAAC,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,EAC5C;IAAC,IAAI,EAAE,IAAI;IAAE,GAAG,IAAI,EAAE,IAAI;CAAC,CAC5B,CAOA;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,SAAS,MAAM,EAC3C,QAAQ,EAAE,IAAI,GACb,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAEjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,SAAS,SAAS,EAAE,IAAI,SAAS,SAAS,EAAE,EACzE,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,CAAC,GACnC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CA0E5D;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,CAAC,KAAK,EAAE,GAAG,KAAK,SAAS,EACvE,QAAQ,EAAE,QAAQ,GACjB,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CA4B3C"}

package/dist/internals/structs.d.mts

@@ -0,0 +1,69 @@
+import type { AnyStruct, Infer, InferStructTuple } from "@metamask/superstruct";
+import { Struct } from "@metamask/superstruct";
+import type { EnumToUnion } from "./helpers.mjs";
+/**
+ * A wrapper of `superstruct`'s `literal` struct that also defines the name of
+ * the struct as the literal value.
+ *
+ * This is useful for improving the error messages returned by `superstruct`.
+ * For example, instead of returning an error like:
+ *
+ * ```
+ * Expected the value to satisfy a union of `literal | literal`, but received: \"baz\"
+ * ```
+ *
+ * This struct will return an error like:
+ *
+ * ```
+ * Expected the value to satisfy a union of `"foo" | "bar"`, but received: \"baz\"
+ * ```
+ *
+ * @param value - The literal value.
+ * @returns The `superstruct` struct, which validates that the value is equal
+ * to the literal value.
+ */
+export declare function literal<Type extends string | number | boolean>(value: Type): Struct<Type, null>;
+/**
+ * A wrapper of `superstruct`'s `union` struct that also defines the schema as
+ * the union of the schemas of the structs.
+ *
+ * This is useful for improving the error messages returned by `superstruct`.
+ *
+ * @param structs - The structs to union.
+ * @param structs."0" - The first struct.
+ * @param structs."1" - The remaining structs.
+ * @returns The `superstruct` struct, which validates that the value satisfies
+ * one of the structs.
+ */
+export declare function union<Head extends AnyStruct, Tail extends AnyStruct[]>([head, ...tail]: [head: Head, ...tail: Tail]): Struct<Infer<Head> | InferStructTuple<Tail>[number], [
+    head: Head,
+    ...tail: Tail
+]>;
+/**
+ * Superstruct struct for validating an enum value. This allows using both the
+ * enum string values and the enum itself as values.
+ *
+ * @param constant - The enum to validate against.
+ * @returns The superstruct struct.
+ */
+export declare function enumValue<Type extends string>(constant: Type): Struct<EnumToUnion<Type>, null>;
+/**
+ * Create a custom union struct that validates exclusively based on a `type` field.
+ *
+ * This should improve error messaging for unions with many structs in them.
+ *
+ * @param structs - The structs to union.
+ * @returns The `superstruct` struct, which validates that the value satisfies
+ * one of the structs.
+ */
+export declare function typedUnion<Head extends AnyStruct, Tail extends AnyStruct[]>(structs: [head: Head, ...tail: Tail]): Struct<Infer<Head> | InferStructTuple<Tail>[number], null>;
+/**
+ * Create a custom union struct that uses a `selector` function for choosing
+ * the validation path.
+ *
+ * @param selector - The selector function choosing the struct to validate with.
+ * @returns The `superstruct` struct, which validates that the value satisfies
+ * one of the structs.
+ */
+export declare function selectiveUnion<Selector extends (value: any) => AnyStruct>(selector: Selector): Struct<Infer<ReturnType<Selector>>, null>;
+//# sourceMappingURL=structs.d.mts.map

package/dist/internals/structs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structs.d.mts","sourceRoot":"","sources":["../../src/internals/structs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,gBAAgB,EAAE,8BAA8B;AAChF,OAAO,EACL,MAAM,EAKP,8BAA8B;AAI/B,OAAO,KAAK,EAAE,WAAW,EAAE,sBAAkB;AAE7C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,KAAK,EAAE,IAAI,sBAK1E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,IAAI,SAAS,SAAS,EAAE,IAAI,SAAS,SAAS,EAAE,EAAE,CACtE,IAAI,EACJ,GAAG,IAAI,CACR,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,CAAC,GAAG,MAAM,CACrC,KAAK,CAAC,IAAI,CAAC,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,EAC5C;IAAC,IAAI,EAAE,IAAI;IAAE,GAAG,IAAI,EAAE,IAAI;CAAC,CAC5B,CAOA;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,SAAS,MAAM,EAC3C,QAAQ,EAAE,IAAI,GACb,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAEjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,SAAS,SAAS,EAAE,IAAI,SAAS,SAAS,EAAE,EACzE,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,CAAC,GACnC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CA0E5D;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,CAAC,KAAK,EAAE,GAAG,KAAK,SAAS,EACvE,QAAQ,EAAE,QAAQ,GACjB,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CA4B3C"}

package/dist/internals/structs.mjs

@@ -0,0 +1,153 @@
+import { Struct, define, is, literal as superstructLiteral, union as superstructUnion } from "@metamask/superstruct";
+import { hasProperty, isPlainObject } from "@metamask/utils";
+/**
+ * A wrapper of `superstruct`'s `literal` struct that also defines the name of
+ * the struct as the literal value.
+ *
+ * This is useful for improving the error messages returned by `superstruct`.
+ * For example, instead of returning an error like:
+ *
+ * ```
+ * Expected the value to satisfy a union of `literal | literal`, but received: \"baz\"
+ * ```
+ *
+ * This struct will return an error like:
+ *
+ * ```
+ * Expected the value to satisfy a union of `"foo" | "bar"`, but received: \"baz\"
+ * ```
+ *
+ * @param value - The literal value.
+ * @returns The `superstruct` struct, which validates that the value is equal
+ * to the literal value.
+ */
+export function literal(value) {
+    return define(JSON.stringify(value), superstructLiteral(value).validator);
+}
+/**
+ * A wrapper of `superstruct`'s `union` struct that also defines the schema as
+ * the union of the schemas of the structs.
+ *
+ * This is useful for improving the error messages returned by `superstruct`.
+ *
+ * @param structs - The structs to union.
+ * @param structs."0" - The first struct.
+ * @param structs."1" - The remaining structs.
+ * @returns The `superstruct` struct, which validates that the value satisfies
+ * one of the structs.
+ */
+export function union([head, ...tail]) {
+    const struct = superstructUnion([head, ...tail]);
+    return new Struct({
+        ...struct,
+        schema: [head, ...tail],
+    });
+}
+/**
+ * Superstruct struct for validating an enum value. This allows using both the
+ * enum string values and the enum itself as values.
+ *
+ * @param constant - The enum to validate against.
+ * @returns The superstruct struct.
+ */
+export function enumValue(constant) {
+    return literal(constant);
+}
+/**
+ * Create a custom union struct that validates exclusively based on a `type` field.
+ *
+ * This should improve error messaging for unions with many structs in them.
+ *
+ * @param structs - The structs to union.
+ * @returns The `superstruct` struct, which validates that the value satisfies
+ * one of the structs.
+ */
+export function typedUnion(structs) {
+    const flatStructs = structs
+        .map((struct) => struct.type === 'union' && Array.isArray(struct.schema)
+        ? struct.schema
+        : struct)
+        .flat(Infinity);
+    const types = flatStructs.map(({ schema }) => schema.type.type);
+    return new Struct({
+        type: 'union',
+        schema: flatStructs,
+        *entries(value, context) {
+            if (!isPlainObject(value) || !hasProperty(value, 'type')) {
+                return;
+            }
+            const { type } = value;
+            const struct = flatStructs.find(({ schema }) => is(type, schema.type));
+            if (!struct) {
+                return;
+            }
+            for (const entry of struct.entries(value, context)) {
+                yield entry;
+            }
+        },
+        coercer(value, context) {
+            if (!isPlainObject(value) || !hasProperty(value, 'type')) {
+                return value;
+            }
+            const { type } = value;
+            const struct = flatStructs.find(({ schema }) => is(type, schema.type));
+            if (struct) {
+                return struct.coercer(value, context);
+            }
+            return value;
+        },
+        // At this point we know the value to be an object.
+        *refiner(value, context) {
+            const struct = flatStructs.find(({ schema }) => is(value.type, schema.type));
+            yield* struct.refiner(value, context);
+        },
+        validator(value, context) {
+            if (!isPlainObject(value) ||
+                !hasProperty(value, 'type') ||
+                typeof value.type !== 'string') {
+                return `Expected type to be one of: ${types.join(', ')}, but received: undefined`;
+            }
+            const { type } = value;
+            const struct = flatStructs.find(({ schema }) => is(type, schema.type));
+            if (struct) {
+                // This only validates the root of the struct, entries does the rest of the work.
+                return struct.validator(value, context);
+            }
+            return `Expected type to be one of: ${types.join(', ')}, but received: "${type}"`;
+        },
+    });
+}
+/**
+ * Create a custom union struct that uses a `selector` function for choosing
+ * the validation path.
+ *
+ * @param selector - The selector function choosing the struct to validate with.
+ * @returns The `superstruct` struct, which validates that the value satisfies
+ * one of the structs.
+ */
+export function selectiveUnion(selector) {
+    return new Struct({
+        type: 'union',
+        schema: null,
+        *entries(value, context) {
+            const struct = selector(value);
+            for (const entry of struct.entries(value, context)) {
+                yield entry;
+            }
+        },
+        *refiner(value, context) {
+            const struct = selector(value);
+            yield* struct.refiner(value, context);
+        },
+        coercer(value, context) {
+            const struct = selector(value);
+            return struct.coercer(value, context);
+        },
+        validator(value, context) {
+            const struct = selector(value);
+            // This only validates the root of the struct, entries does the rest of the work.
+            return struct.validator(value, context);
+        },
+    });
+}
+//# sourceMappingURL=structs.mjs.map

package/dist/internals/structs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"structs.mjs","sourceRoot":"","sources":["../../src/internals/structs.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AnyStruct, Infer, InferStructTuple } from '@metamask/superstruct';\nimport {\n  Struct,\n  define,\n  is,\n  literal as superstructLiteral,\n  union as superstructUnion,\n} from '@metamask/superstruct';\nimport type { PlainObject } from '@metamask/utils';\nimport { hasProperty, isPlainObject } from '@metamask/utils';\n\nimport type { EnumToUnion } from './helpers';\n\n/**\n * A wrapper of `superstruct`'s `literal` struct that also defines the name of\n * the struct as the literal value.\n *\n * This is useful for improving the error messages returned by `superstruct`.\n * For example, instead of returning an error like:\n *\n * ```\n * Expected the value to satisfy a union of `literal | literal`, but received: \\\"baz\\\"\n * ```\n *\n * This struct will return an error like:\n *\n * ```\n * Expected the value to satisfy a union of `\"foo\" | \"bar\"`, but received: \\\"baz\\\"\n * ```\n *\n * @param value - The literal value.\n * @returns The `superstruct` struct, which validates that the value is equal\n * to the literal value.\n */\nexport function literal<Type extends string | number | boolean>(value: Type) {\n  return define<Type>(\n    JSON.stringify(value),\n    superstructLiteral(value).validator,\n  );\n}\n\n/**\n * A wrapper of `superstruct`'s `union` struct that also defines the schema as\n * the union of the schemas of the structs.\n *\n * This is useful for improving the error messages returned by `superstruct`.\n *\n * @param structs - The structs to union.\n * @param structs.\"0\" - The first struct.\n * @param structs.\"1\" - The remaining structs.\n * @returns The `superstruct` struct, which validates that the value satisfies\n * one of the structs.\n */\nexport function union<Head extends AnyStruct, Tail extends AnyStruct[]>([\n  head,\n  ...tail\n]: [head: Head, ...tail: Tail]): Struct<\n  Infer<Head> | InferStructTuple<Tail>[number],\n  [head: Head, ...tail: Tail]\n> {\n  const struct = superstructUnion([head, ...tail]);\n\n  return new Struct({\n    ...struct,\n    schema: [head, ...tail],\n  });\n}\n\n/**\n * Superstruct struct for validating an enum value. This allows using both the\n * enum string values and the enum itself as values.\n *\n * @param constant - The enum to validate against.\n * @returns The superstruct struct.\n */\nexport function enumValue<Type extends string>(\n  constant: Type,\n): Struct<EnumToUnion<Type>, null> {\n  return literal(constant as EnumToUnion<Type>);\n}\n\n/**\n * Create a custom union struct that validates exclusively based on a `type` field.\n *\n * This should improve error messaging for unions with many structs in them.\n *\n * @param structs - The structs to union.\n * @returns The `superstruct` struct, which validates that the value satisfies\n * one of the structs.\n */\nexport function typedUnion<Head extends AnyStruct, Tail extends AnyStruct[]>(\n  structs: [head: Head, ...tail: Tail],\n): Struct<Infer<Head> | InferStructTuple<Tail>[number], null> {\n  const flatStructs = structs\n    .map((struct) =>\n      struct.type === 'union' && Array.isArray(struct.schema)\n        ? struct.schema\n        : struct,\n    )\n    .flat(Infinity);\n  const types = flatStructs.map(({ schema }) => schema.type.type);\n  return new Struct({\n    type: 'union',\n    schema: flatStructs,\n    *entries(value, context) {\n      if (!isPlainObject(value) || !hasProperty(value, 'type')) {\n        return;\n      }\n\n      const { type } = value;\n      const struct = flatStructs.find(({ schema }) => is(type, schema.type));\n\n      if (!struct) {\n        return;\n      }\n\n      for (const entry of struct.entries(value, context)) {\n        yield entry;\n      }\n    },\n    coercer(value, context) {\n      if (!isPlainObject(value) || !hasProperty(value, 'type')) {\n        return value;\n      }\n\n      const { type } = value;\n      const struct = flatStructs.find(({ schema }) => is(type, schema.type));\n      if (struct) {\n        return struct.coercer(value, context);\n      }\n\n      return value;\n    },\n    // At this point we know the value to be an object.\n    *refiner(value: PlainObject, context) {\n      const struct = flatStructs.find(({ schema }) =>\n        is(value.type, schema.type),\n      );\n\n      yield* struct.refiner(value, context);\n    },\n    validator(value, context) {\n      if (\n        !isPlainObject(value) ||\n        !hasProperty(value, 'type') ||\n        typeof value.type !== 'string'\n      ) {\n        return `Expected type to be one of: ${types.join(\n          ', ',\n        )}, but received: undefined`;\n      }\n\n      const { type } = value;\n\n      const struct = flatStructs.find(({ schema }) => is(type, schema.type));\n\n      if (struct) {\n        // This only validates the root of the struct, entries does the rest of the work.\n        return struct.validator(value, context);\n      }\n\n      return `Expected type to be one of: ${types.join(\n        ', ',\n      )}, but received: \"${type}\"`;\n    },\n  }) as unknown as Struct<Infer<Head> | InferStructTuple<Tail>[number], null>;\n}\n\n/**\n * Create a custom union struct that uses a `selector` function for choosing\n * the validation path.\n *\n * @param selector - The selector function choosing the struct to validate with.\n * @returns The `superstruct` struct, which validates that the value satisfies\n * one of the structs.\n */\nexport function selectiveUnion<Selector extends (value: any) => AnyStruct>(\n  selector: Selector,\n): Struct<Infer<ReturnType<Selector>>, null> {\n  return new Struct({\n    type: 'union',\n    schema: null,\n    *entries(value, context) {\n      const struct = selector(value);\n\n      for (const entry of struct.entries(value, context)) {\n        yield entry;\n      }\n    },\n    *refiner(value, context) {\n      const struct = selector(value);\n\n      yield* struct.refiner(value, context);\n    },\n    coercer(value, context) {\n      const struct = selector(value);\n\n      return struct.coercer(value, context);\n    },\n    validator(value, context) {\n      const struct = selector(value);\n\n      // This only validates the root of the struct, entries does the rest of the work.\n      return struct.validator(value, context);\n    },\n  });\n}\n"]}

package/dist/internals/svg.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.svg = void 0;
+const superstruct_1 = require("@metamask/superstruct");
+/**
+ * Get a Struct that validates a string as a valid SVG.
+ *
+ * @returns A Struct that validates a string as a valid SVG.
+ * @internal
+ */
+function svg() {
+    return (0, superstruct_1.refine)((0, superstruct_1.string)(), 'SVG', (value) => {
+        // This validation is intentionally very basic, we don't need to be that strict
+        // and merely have this extra validation as a helpful error if devs aren't
+        // passing in SVGs.
+        if (!value.includes('<svg')) {
+            return 'Value is not a valid SVG.';
+        }
+        return true;
+    });
+}
+exports.svg = svg;
+//# sourceMappingURL=svg.cjs.map

package/dist/internals/svg.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"svg.cjs","sourceRoot":"","sources":["../../src/internals/svg.ts"],"names":[],"mappings":";;;AAAA,uDAAuD;AAEvD;;;;;GAKG;AACH,SAAgB,GAAG;IACjB,OAAO,IAAA,oBAAM,EAAC,IAAA,oBAAM,GAAE,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;QACvC,+EAA+E;QAC/E,0EAA0E;QAC1E,mBAAmB;QACnB,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5B,OAAO,2BAA2B,CAAC;QACrC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC;AAXD,kBAWC","sourcesContent":["import { refine, string } from '@metamask/superstruct';\n\n/**\n * Get a Struct that validates a string as a valid SVG.\n *\n * @returns A Struct that validates a string as a valid SVG.\n * @internal\n */\nexport function svg() {\n  return refine(string(), 'SVG', (value) => {\n    // This validation is intentionally very basic, we don't need to be that strict\n    // and merely have this extra validation as a helpful error if devs aren't\n    // passing in SVGs.\n    if (!value.includes('<svg')) {\n      return 'Value is not a valid SVG.';\n    }\n\n    return true;\n  });\n}\n"]}

package/dist/{types/internals/svg.d.ts → internals/svg.d.cts}

@@ -5,3 +5,4 @@
  * @internal
  */
 export declare function svg(): import("@metamask/superstruct").Struct<string, null>;
+//# sourceMappingURL=svg.d.cts.map

package/dist/internals/svg.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svg.d.cts","sourceRoot":"","sources":["../../src/internals/svg.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,GAAG,yDAWlB"}

package/dist/internals/svg.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Get a Struct that validates a string as a valid SVG.
+ *
+ * @returns A Struct that validates a string as a valid SVG.
+ * @internal
+ */
+export declare function svg(): import("@metamask/superstruct").Struct<string, null>;
+//# sourceMappingURL=svg.d.mts.map

package/dist/internals/svg.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svg.d.mts","sourceRoot":"","sources":["../../src/internals/svg.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,GAAG,yDAWlB"}

package/dist/internals/svg.mjs

@@ -0,0 +1,19 @@
+import { refine, string } from "@metamask/superstruct";
+/**
+ * Get a Struct that validates a string as a valid SVG.
+ *
+ * @returns A Struct that validates a string as a valid SVG.
+ * @internal
+ */
+export function svg() {
+    return refine(string(), 'SVG', (value) => {
+        // This validation is intentionally very basic, we don't need to be that strict
+        // and merely have this extra validation as a helpful error if devs aren't
+        // passing in SVGs.
+        if (!value.includes('<svg')) {
+            return 'Value is not a valid SVG.';
+        }
+        return true;
+    });
+}
+//# sourceMappingURL=svg.mjs.map

package/dist/internals/svg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"svg.mjs","sourceRoot":"","sources":["../../src/internals/svg.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,8BAA8B;AAEvD;;;;;GAKG;AACH,MAAM,UAAU,GAAG;IACjB,OAAO,MAAM,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;QACvC,+EAA+E;QAC/E,0EAA0E;QAC1E,mBAAmB;QACnB,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5B,OAAO,2BAA2B,CAAC;QACrC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { refine, string } from '@metamask/superstruct';\n\n/**\n * Get a Struct that validates a string as a valid SVG.\n *\n * @returns A Struct that validates a string as a valid SVG.\n * @internal\n */\nexport function svg() {\n  return refine(string(), 'SVG', (value) => {\n    // This validation is intentionally very basic, we don't need to be that strict\n    // and merely have this extra validation as a helpful error if devs aren't\n    // passing in SVGs.\n    if (!value.includes('<svg')) {\n      return 'Value is not a valid SVG.';\n    }\n\n    return true;\n  });\n}\n"]}

package/dist/jsx/component.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSnapComponent = void 0;
+/**
+ * Remove undefined props from an object.
+ *
+ * @param props - The object to remove undefined props from.
+ * @returns The object without undefined props.
+ */
+function removeUndefinedProps(props) {
+    return Object.fromEntries(Object.entries(props).filter(([, value]) => value !== undefined));
+}
+/**
+ * Create a Snap component from a type. This is a helper function that creates a
+ * Snap component function.
+ *
+ * @param type - The type of the component.
+ * @returns A function that creates a Snap element.
+ * @see SnapComponent
+ */
+function createSnapComponent(type) {
+    return (props) => {
+        const { key = null, ...rest } = props;
+        return {
+            type,
+            props: removeUndefinedProps(rest),
+            key,
+        };
+    };
+}
+exports.createSnapComponent = createSnapComponent;
+//# sourceMappingURL=component.cjs.map

package/dist/jsx/component.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.cjs","sourceRoot":"","sources":["../../src/jsx/component.ts"],"names":[],"mappings":";;;AA8EA;;;;;GAKG;AACH,SAAS,oBAAoB,CAA2B,KAAY;IAClE,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC,CACxD,CAAC;AACb,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAGjC,IAAU;IACV,OAAO,CAAC,KAAmC,EAAE,EAAE;QAC7C,MAAM,EAAE,GAAG,GAAG,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC;QACtC,OAAO;YACL,IAAI;YACJ,KAAK,EAAE,oBAAoB,CAAC,IAAa,CAAC;YAC1C,GAAG;SACJ,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAZD,kDAYC","sourcesContent":["import type { Json } from '@metamask/utils';\n\n/**\n * A key, which can be a string or a number.\n */\nexport type Key = string | number;\n\n/**\n * A JSON object.\n */\nexport type JsonObject = Record<string, Json>;\n\n/**\n * A generic JSX element.\n *\n * @property type - The type of the element.\n * @property props - The props of the element.\n * @property key - The key of the element.\n */\nexport type GenericSnapElement = {\n  type: string;\n  props: JsonObject;\n  key: Key | null;\n};\n\n/**\n * A JSX element.\n *\n * @property type - The type of the element.\n * @property props - The props of the element.\n * @property key - The key of the element.\n */\nexport type SnapElement<\n  Props extends JsonObject = Record<string, never>,\n  Type extends string = string,\n> = {\n  type: Type;\n  props: Props;\n  key: Key | null;\n};\n\n/**\n * A type that can be a single value or an infinitely nestable array of values.\n *\n * @template Type - The type that can be an array.\n * @example\n * type NestableString = Nestable<string>;\n * const nestableString: NestableString = 'hello';\n * const nestableStringArray: NestableString = ['hello', 'world', ['foo', ['bar']]];\n */\nexport type Nestable<Type> = Type | Nestable<Type>[];\n\n/**\n * A type that can be a single value or an array of values, a boolean, or null.\n *\n * @template Type - The type that can be an array.\n */\nexport type SnapsChildren<Type> = Nestable<Type | boolean | null>;\n\n/**\n * A JSX node, which can be an element, a string, null, or an array of nodes.\n */\nexport type SnapNode = SnapsChildren<GenericSnapElement | string>;\n\n/**\n * A JSX string element, which can be a string or an array of strings, or\n * booleans (for conditional rendering).\n */\nexport type StringElement = SnapsChildren<string>;\n\n/**\n * A JSX component.\n */\nexport type SnapComponent<\n  Props extends JsonObject = Record<string, never>,\n  Type extends string = string,\n> = (props: Props & { key?: Key | null }) => SnapElement<Props, Type>;\n\n/**\n * Remove undefined props from an object.\n *\n * @param props - The object to remove undefined props from.\n * @returns The object without undefined props.\n */\nfunction removeUndefinedProps<Props extends JsonObject>(props: Props): Props {\n  return Object.fromEntries(\n    Object.entries(props).filter(([, value]) => value !== undefined),\n  ) as Props;\n}\n\n/**\n * Create a Snap component from a type. This is a helper function that creates a\n * Snap component function.\n *\n * @param type - The type of the component.\n * @returns A function that creates a Snap element.\n * @see SnapComponent\n */\nexport function createSnapComponent<\n  Props extends JsonObject = Record<string, never>,\n  Type extends string = string,\n>(type: Type): SnapComponent<Props, Type> {\n  return (props: Props & { key?: Key | null }) => {\n    const { key = null, ...rest } = props;\n    return {\n      type,\n      props: removeUndefinedProps(rest as Props),\n      key,\n    };\n  };\n}\n"]}

package/dist/{types/jsx/component.d.ts → jsx/component.d.cts}

@@ -1,4 +1,4 @@
-import type { Json } from '@metamask/utils';
+import type { Json } from "@metamask/utils";
 /**
  * A key, which can be a string or a number.
  */
@@ -71,3 +71,4 @@ export type SnapComponent<Props extends JsonObject = Record<string, never>, Type
  * @see SnapComponent
  */
 export declare function createSnapComponent<Props extends JsonObject = Record<string, never>, Type extends string = string>(type: Type): SnapComponent<Props, Type>;
+//# sourceMappingURL=component.d.cts.map

package/dist/jsx/component.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.cts","sourceRoot":"","sources":["../../src/jsx/component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,wBAAwB;AAE5C;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,GAAG,MAAM,CAAC;AAElC;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,UAAU,CAAC;IAClB,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;CACjB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CACrB,KAAK,SAAS,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAChD,IAAI,SAAS,MAAM,GAAG,MAAM,IAC1B;IACF,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;CACjB,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,CAAC,IAAI,IAAI,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;AAErD;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,GAAG,OAAO,GAAG,IAAI,CAAC,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,aAAa,CAAC,kBAAkB,GAAG,MAAM,CAAC,CAAC;AAElE;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;AAElD;;GAEG;AACH,MAAM,MAAM,aAAa,CACvB,KAAK,SAAS,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAChD,IAAI,SAAS,MAAM,GAAG,MAAM,IAC1B,CAAC,KAAK,EAAE,KAAK,GAAG;IAAE,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAA;CAAE,KAAK,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AActE;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,SAAS,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAChD,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,IAAI,EAAE,IAAI,GAAG,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,CASxC"}