@metamask/snaps-sdk 5.0.0 → 6.1.0

package/dist/jsx/index.mjs

@@ -19,77 +19,101 @@ function createSnapComponent(type) {
 var TYPE = "Button";
 var Button = createSnapComponent(TYPE);
 
+// src/jsx/components/form/Checkbox.ts
+var TYPE2 = "Checkbox";
+var Checkbox = createSnapComponent(TYPE2);
+
 // src/jsx/components/form/Dropdown.ts
-var TYPE2 = "Dropdown";
-var Dropdown = createSnapComponent(TYPE2);
+var TYPE3 = "Dropdown";
+var Dropdown = createSnapComponent(TYPE3);
 
 // src/jsx/components/form/Option.ts
-var TYPE3 = "Option";
-var Option = createSnapComponent(TYPE3);
+var TYPE4 = "Option";
+var Option = createSnapComponent(TYPE4);
 
 // src/jsx/components/form/Field.ts
-var TYPE4 = "Field";
-var Field = createSnapComponent(TYPE4);
+var TYPE5 = "Field";
+var Field = createSnapComponent(TYPE5);
+
+// src/jsx/components/form/FileInput.ts
+var TYPE6 = "FileInput";
+var FileInput = createSnapComponent(TYPE6);
 
 // src/jsx/components/form/Form.ts
-var TYPE5 = "Form";
-var Form = createSnapComponent(TYPE5);
+var TYPE7 = "Form";
+var Form = createSnapComponent(TYPE7);
 
 // src/jsx/components/form/Input.ts
-var TYPE6 = "Input";
-var Input = createSnapComponent(TYPE6);
+var TYPE8 = "Input";
+var Input = createSnapComponent(TYPE8);
 
 // src/jsx/components/formatting/Bold.ts
-var TYPE7 = "Bold";
-var Bold = createSnapComponent(TYPE7);
+var TYPE9 = "Bold";
+var Bold = createSnapComponent(TYPE9);
 
 // src/jsx/components/formatting/Italic.ts
-var TYPE8 = "Italic";
-var Italic = createSnapComponent(TYPE8);
+var TYPE10 = "Italic";
+var Italic = createSnapComponent(TYPE10);
 
 // src/jsx/components/Address.ts
-var TYPE9 = "Address";
-var Address = createSnapComponent(TYPE9);
+var TYPE11 = "Address";
+var Address = createSnapComponent(TYPE11);
 
 // src/jsx/components/Box.ts
-var TYPE10 = "Box";
-var Box = createSnapComponent(TYPE10);
+var TYPE12 = "Box";
+var Box = createSnapComponent(TYPE12);
+
+// src/jsx/components/Card.ts
+var TYPE13 = "Card";
+var Card = createSnapComponent(TYPE13);
 
 // src/jsx/components/Copyable.ts
-var TYPE11 = "Copyable";
-var Copyable = createSnapComponent(TYPE11);
+var TYPE14 = "Copyable";
+var Copyable = createSnapComponent(TYPE14);
 
 // src/jsx/components/Divider.ts
-var TYPE12 = "Divider";
-var Divider = createSnapComponent(TYPE12);
+var TYPE15 = "Divider";
+var Divider = createSnapComponent(TYPE15);
 
 // src/jsx/components/Value.ts
-var TYPE13 = "Value";
-var Value = createSnapComponent(TYPE13);
+var TYPE16 = "Value";
+var Value = createSnapComponent(TYPE16);
 
 // src/jsx/components/Heading.ts
-var TYPE14 = "Heading";
-var Heading = createSnapComponent(TYPE14);
+var TYPE17 = "Heading";
+var Heading = createSnapComponent(TYPE17);
 
 // src/jsx/components/Image.ts
-var TYPE15 = "Image";
-var Image = createSnapComponent(TYPE15);
+var TYPE18 = "Image";
+var Image = createSnapComponent(TYPE18);
 
 // src/jsx/components/Link.ts
-var TYPE16 = "Link";
-var Link = createSnapComponent(TYPE16);
+var TYPE19 = "Link";
+var Link = createSnapComponent(TYPE19);
 
 // src/jsx/components/Row.ts
-var TYPE17 = "Row";
-var Row = createSnapComponent(TYPE17);
+var TYPE20 = "Row";
+var Row = createSnapComponent(TYPE20);
 
 // src/jsx/components/Spinner.ts
-var TYPE18 = "Spinner";
-var Spinner = createSnapComponent(TYPE18);
+var TYPE21 = "Spinner";
+var Spinner = createSnapComponent(TYPE21);
 
 // src/jsx/components/Text.ts
-var TYPE19 = "Text";
-var Text = createSnapComponent(TYPE19);
+var TYPE22 = "Text";
+var Text = createSnapComponent(TYPE22);
+
+// src/jsx/components/Tooltip.ts
+var TYPE23 = "Tooltip";
+var Tooltip = createSnapComponent(TYPE23);
+
+// src/jsx/components/Footer.ts
+var TYPE24 = "Footer";
+var Footer = createSnapComponent(TYPE24);
+
+// src/jsx/components/Container.ts
+var TYPE25 = "Container";
+var Container = createSnapComponent(TYPE25);
 
 // src/jsx/jsx-runtime.ts
 function jsx(component, props, key) {
@@ -113,13 +137,7 @@ function jsxs(component, props, key) {
 
 // src/jsx/validation.ts
 import {
-  hasProperty,
-  HexChecksumAddressStruct,
-  isPlainObject,
-  JsonStruct
-} from "@metamask/utils";
-import {
-  is,
+  is as is2,
   boolean,
   optional,
   array,
@@ -130,15 +148,23 @@ import {
   record,
   string as string2,
   tuple
-} from "superstruct";
+} from "@metamask/superstruct";
+import {
+  hasProperty as hasProperty2,
+  HexChecksumAddressStruct,
+  isPlainObject as isPlainObject2,
+  JsonStruct
+} from "@metamask/utils";
 
 // src/internals/structs.ts
 import {
   Struct,
   define,
+  is,
   literal as superstructLiteral,
   union as superstructUnion
-} from "superstruct";
+} from "@metamask/superstruct";
+import { hasProperty, isPlainObject } from "@metamask/utils";
 function literal(value) {
   return define(
     JSON.stringify(value),
@@ -155,6 +181,41 @@ function union([
     schema: [head, ...tail]
   });
 }
+function typedUnion(structs) {
+  return new Struct({
+    type: "union",
+    schema: null,
+    *entries(value, context) {
+      if (!isPlainObject(value) || !hasProperty(value, "type")) {
+        return;
+      }
+      const { type } = value;
+      const struct = structs.find(({ schema }) => is(type, schema.type));
+      if (!struct) {
+        return;
+      }
+      for (const entry of struct.entries(value, context)) {
+        yield entry;
+      }
+    },
+    validator(value, context) {
+      const types = structs.map(({ schema }) => schema.type.type);
+      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 = structs.find(({ schema }) => is(type, schema.type));
+      if (struct) {
+        return struct.validator(value, context);
+      }
+      return `Expected type to be one of: ${types.join(
+        ", "
+      )}, but received: "${type}"`;
+    }
+  });
+}
 
 // src/internals/jsx.ts
 function nullUnion(structs) {
@@ -162,7 +223,7 @@ function nullUnion(structs) {
 }
 
 // src/internals/svg.ts
-import { refine, string } from "superstruct";
+import { refine, string } from "@metamask/superstruct";
 function svg() {
   return refine(string(), "SVG", (value) => {
     if (!value.includes("<svg")) {
@@ -174,9 +235,9 @@ function svg() {
 
 // src/jsx/validation.ts
 var KeyStruct = nullUnion([string2(), number()]);
-var StringElementStruct = maybeArray(
+var StringElementStruct = children([
   string2()
-);
+]);
 var ElementStruct = object({
   type: string2(),
   props: record(string2(), JsonStruct),
@@ -189,8 +250,8 @@ function nestable(struct) {
   ]);
   return nestableStruct;
 }
-function maybeArray(struct) {
-  return nestable(struct);
+function children(structs) {
+  return nestable(nullable(nullUnion([...structs, boolean()])));
 }
 function element(name, props = {}) {
   return object({
@@ -206,6 +267,12 @@ var ButtonStruct = element("Button", {
   variant: optional(nullUnion([literal("primary"), literal("destructive")])),
   disabled: optional(boolean())
 });
+var CheckboxStruct = element("Checkbox", {
+  name: string2(),
+  checked: optional(boolean()),
+  label: optional(string2()),
+  variant: optional(nullUnion([literal("default"), literal("toggle")]))
+});
 var InputStruct = element("Input", {
   name: string2(),
   type: optional(
@@ -221,42 +288,57 @@ var OptionStruct = element("Option", {
 var DropdownStruct = element("Dropdown", {
   name: string2(),
   value: optional(string2()),
-  children: maybeArray(OptionStruct)
+  children: children([OptionStruct])
 });
+var FileInputStruct = element(
+  "FileInput",
+  {
+    name: string2(),
+    accept: nullUnion([optional(array(string2()))]),
+    compact: optional(boolean())
+  }
+);
+var BUTTON_INPUT = [InputStruct, ButtonStruct];
+var FIELD_CHILDREN_ARRAY = [
+  InputStruct,
+  DropdownStruct,
+  FileInputStruct,
+  CheckboxStruct
+];
+var FieldChildUnionStruct = nullUnion([
+  ...FIELD_CHILDREN_ARRAY,
+  ...BUTTON_INPUT
+]);
+var FieldChildStruct = nullUnion([
+  tuple(BUTTON_INPUT),
+  ...FIELD_CHILDREN_ARRAY
+]);
 var FieldStruct = element("Field", {
   label: optional(string2()),
   error: optional(string2()),
-  children: nullUnion([
-    tuple([InputStruct, ButtonStruct]),
-    InputStruct,
-    DropdownStruct
-  ])
+  children: FieldChildStruct
 });
+var FormChildStruct = children(
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  [FieldStruct, lazy(() => BoxChildStruct)]
+);
 var FormStruct = element("Form", {
-  children: maybeArray(nullUnion([FieldStruct, ButtonStruct])),
+  children: FormChildStruct,
   name: string2()
 });
 var BoldStruct = element("Bold", {
-  children: maybeArray(
-    nullable(
-      nullUnion([
-        string2(),
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        lazy(() => ItalicStruct)
-      ])
-    )
-  )
+  children: children([
+    string2(),
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    lazy(() => ItalicStruct)
+  ])
 });
 var ItalicStruct = element("Italic", {
-  children: maybeArray(
-    nullable(
-      nullUnion([
-        string2(),
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        lazy(() => BoldStruct)
-      ])
-    )
-  )
+  children: children([
+    string2(),
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    lazy(() => BoldStruct)
+  ])
 });
 var FormattingStruct = nullUnion([
   BoldStruct,
@@ -265,11 +347,12 @@ var FormattingStruct = nullUnion([
 var AddressStruct = element("Address", {
   address: HexChecksumAddressStruct
 });
+var BoxChildrenStruct = children(
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  [lazy(() => BoxChildStruct)]
+);
 var BoxStruct = element("Box", {
-  children: maybeArray(
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    nullable(lazy(() => BoxChildStruct))
-  ),
+  children: BoxChildrenStruct,
   direction: optional(nullUnion([literal("horizontal"), literal("vertical")])),
   alignment: optional(
     nullUnion([
@@ -281,6 +364,23 @@ var BoxStruct = element("Box", {
     ])
   )
 });
+var FooterChildStruct = nullUnion([
+  tuple([ButtonStruct, ButtonStruct]),
+  ButtonStruct
+]);
+var FooterStruct = element("Footer", {
+  children: FooterChildStruct
+});
+var ContainerChildStruct = nullUnion([
+  tuple([BoxStruct, FooterStruct]),
+  BoxStruct
+]);
+var ContainerStruct = element(
+  "Container",
+  {
+    children: ContainerChildStruct
+  }
+);
 var CopyableStruct = element("Copyable", {
   value: string2(),
   sensitive: optional(boolean())
@@ -290,6 +390,13 @@ var ValueStruct = element("Value", {
   value: string2(),
   extra: string2()
 });
+var CardStruct = element("Card", {
+  image: optional(string2()),
+  title: string2(),
+  description: optional(string2()),
+  value: string2(),
+  extra: optional(string2())
+});
 var HeadingStruct = element("Heading", {
   children: StringElementStruct
 });
@@ -299,13 +406,33 @@ var ImageStruct = element("Image", {
 });
 var LinkStruct = element("Link", {
   href: string2(),
-  children: maybeArray(nullable(nullUnion([FormattingStruct, string2()])))
+  children: children([FormattingStruct, string2()])
 });
 var TextStruct = element("Text", {
-  children: maybeArray(
-    nullable(nullUnion([string2(), BoldStruct, ItalicStruct, LinkStruct]))
+  children: children([string2(), BoldStruct, ItalicStruct, LinkStruct]),
+  alignment: optional(
+    nullUnion([literal("start"), literal("center"), literal("end")])
   )
 });
+var TooltipChildStruct = nullUnion([
+  TextStruct,
+  BoldStruct,
+  ItalicStruct,
+  LinkStruct,
+  ImageStruct,
+  boolean()
+]);
+var TooltipContentStruct = nullUnion([
+  TextStruct,
+  BoldStruct,
+  ItalicStruct,
+  LinkStruct,
+  string2()
+]);
+var TooltipStruct = element("Tooltip", {
+  children: nullable(TooltipChildStruct),
+  content: TooltipContentStruct
+});
 var RowStruct = element("Row", {
   label: string2(),
   children: nullUnion([AddressStruct, ImageStruct, TextStruct, ValueStruct]),
@@ -315,28 +442,36 @@ var RowStruct = element("Row", {
   tooltip: optional(string2())
 });
 var SpinnerStruct = element("Spinner");
-var BoxChildStruct = nullUnion([
-  ButtonStruct,
-  InputStruct,
-  FormStruct,
-  BoldStruct,
-  ItalicStruct,
+var BoxChildStruct = typedUnion([
   AddressStruct,
+  BoldStruct,
   BoxStruct,
+  ButtonStruct,
   CopyableStruct,
   DividerStruct,
+  DropdownStruct,
+  FileInputStruct,
+  FormStruct,
   HeadingStruct,
+  InputStruct,
   ImageStruct,
+  ItalicStruct,
   LinkStruct,
   RowStruct,
   SpinnerStruct,
   TextStruct,
-  DropdownStruct
+  TooltipStruct,
+  CheckboxStruct,
+  CardStruct
+]);
+var RootJSXElementStruct = nullUnion([
+  BoxChildStruct,
+  ContainerStruct
 ]);
-var RootJSXElementStruct = BoxChildStruct;
-var JSXElementStruct = nullUnion([
+var JSXElementStruct = typedUnion([
   ButtonStruct,
   InputStruct,
+  FileInputStruct,
   FieldStruct,
   FormStruct,
   BoldStruct,
@@ -353,13 +488,18 @@ var JSXElementStruct = nullUnion([
   TextStruct,
   DropdownStruct,
   OptionStruct,
-  ValueStruct
+  ValueStruct,
+  TooltipStruct,
+  CheckboxStruct,
+  FooterStruct,
+  ContainerStruct,
+  CardStruct
 ]);
 function isJSXElement(value) {
-  return is(value, JSXElementStruct);
+  return is2(value, JSXElementStruct);
 }
 function isJSXElementUnsafe(value) {
-  return isPlainObject(value) && hasProperty(value, "type") && hasProperty(value, "props") && hasProperty(value, "key");
+  return isPlainObject2(value) && hasProperty2(value, "type") && hasProperty2(value, "props") && hasProperty2(value, "key");
 }
 function assertJSXElement(value) {
   if (!isJSXElement(value)) {
@@ -381,12 +521,20 @@ export {
   Address,
   Bold,
   Box,
+  BoxChildStruct,
   Button,
+  Card,
+  Checkbox,
+  Container,
   Copyable,
   Divider,
   Dropdown,
   Field,
+  FieldChildUnionStruct,
+  FileInput,
+  Footer,
   Form,
+  FormChildStruct,
   Heading,
   Image,
   Input,
@@ -398,6 +546,7 @@ export {
   Row,
   Spinner,
   Text,
+  Tooltip,
   Value,
   assertJSXElement,
   createSnapComponent,