@metamask-previews/keyring-utils 0.0.1-preview-46bb5ff → 1.0.0-4685a87

package/CHANGELOG.md

@@ -7,4 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-[Unreleased]: https://github.com/MetaMask/accounts/
+## [1.0.0]
+
+### Changed
+
+- Use `ts-bridge/cli@0.6.1` ([#118](https://github.com/MetaMask/accounts/pull/118))
+  - This new version fixes a bug with CJS re-exports.
+- Initial release ([#24](https://github.com/MetaMask/accounts/pull/24))
+
+[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-utils@1.0.0...HEAD
+[1.0.0]: https://github.com/MetaMask/accounts/releases/tag/@metamask/keyring-utils@1.0.0

package/dist/JsonRpcRequest.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcRequestStruct = void 0;
+const superstruct_1 = require("@metamask/superstruct");
+const utils_1 = require("@metamask/utils");
+const _1 = require("./index.cjs");
+exports.JsonRpcRequestStruct = (0, _1.object)({
+    jsonrpc: (0, superstruct_1.literal)('2.0'),
+    id: (0, superstruct_1.union)([(0, superstruct_1.string)(), (0, superstruct_1.number)(), (0, superstruct_1.literal)(null)]),
+    method: (0, superstruct_1.string)(),
+    params: (0, _1.exactOptional)((0, superstruct_1.union)([(0, superstruct_1.array)(utils_1.JsonStruct), (0, superstruct_1.record)((0, superstruct_1.string)(), utils_1.JsonStruct)])),
+});
+//# sourceMappingURL=JsonRpcRequest.cjs.map

package/dist/JsonRpcRequest.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcRequest.cjs","sourceRoot":"","sources":["../src/JsonRpcRequest.ts"],"names":[],"mappings":";;;AAAA,uDAO+B;AAE/B,2CAA6C;AAE7C,kCAA0C;AAE7B,QAAA,oBAAoB,GAAG,IAAA,SAAM,EAAC;IACzC,OAAO,EAAE,IAAA,qBAAO,EAAC,KAAK,CAAC;IACvB,EAAE,EAAE,IAAA,mBAAK,EAAC,CAAC,IAAA,oBAAM,GAAE,EAAE,IAAA,oBAAM,GAAE,EAAE,IAAA,qBAAO,EAAC,IAAI,CAAC,CAAC,CAAC;IAC9C,MAAM,EAAE,IAAA,oBAAM,GAAE;IAChB,MAAM,EAAE,IAAA,gBAAa,EACnB,IAAA,mBAAK,EAAC,CAAC,IAAA,mBAAK,EAAC,kBAAU,CAAC,EAAE,IAAA,oBAAM,EAAC,IAAA,oBAAM,GAAE,EAAE,kBAAU,CAAC,CAAC,CAAC,CACzD;CACF,CAAC,CAAC","sourcesContent":["import {\n  array,\n  literal,\n  number,\n  record,\n  string,\n  union,\n} from '@metamask/superstruct';\nimport type { Infer } from '@metamask/superstruct';\nimport { JsonStruct } from '@metamask/utils';\n\nimport { exactOptional, object } from '.';\n\nexport const JsonRpcRequestStruct = object({\n  jsonrpc: literal('2.0'),\n  id: union([string(), number(), literal(null)]),\n  method: string(),\n  params: exactOptional(\n    union([array(JsonStruct), record(string(), JsonStruct)]),\n  ),\n});\n\n/**\n * JSON-RPC request type.\n */\nexport type JsonRpcRequest = Infer<typeof JsonRpcRequestStruct>;\n"]}

package/dist/JsonRpcRequest.d.cts

@@ -0,0 +1,17 @@
+import type { Infer } from "@metamask/superstruct";
+export declare const JsonRpcRequestStruct: import("@metamask/superstruct").Struct<{
+    method: string;
+    id: string | number | null;
+    jsonrpc: "2.0";
+    params?: Record<string, import("@metamask/utils").Json> | import("@metamask/utils").Json[];
+}, {
+    jsonrpc: import("@metamask/superstruct").Struct<"2.0", "2.0">;
+    id: import("@metamask/superstruct").Struct<string | number | null, null>;
+    method: import("@metamask/superstruct").Struct<string, null>;
+    params: import("@metamask/superstruct").Struct<Record<string, import("@metamask/utils").Json> | import("@metamask/utils").Json[] | import("./superstruct.cjs").ExactOptionalTag, null>;
+}>;
+/**
+ * JSON-RPC request type.
+ */
+export type JsonRpcRequest = Infer<typeof JsonRpcRequestStruct>;
+//# sourceMappingURL=JsonRpcRequest.d.cts.map

package/dist/JsonRpcRequest.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcRequest.d.cts","sourceRoot":"","sources":["../src/JsonRpcRequest.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,8BAA8B;AAKnD,eAAO,MAAM,oBAAoB;;;;;;;;;;EAO/B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/JsonRpcRequest.d.mts

@@ -0,0 +1,17 @@
+import type { Infer } from "@metamask/superstruct";
+export declare const JsonRpcRequestStruct: import("@metamask/superstruct").Struct<{
+    method: string;
+    id: string | number | null;
+    jsonrpc: "2.0";
+    params?: Record<string, import("@metamask/utils").Json> | import("@metamask/utils").Json[];
+}, {
+    jsonrpc: import("@metamask/superstruct").Struct<"2.0", "2.0">;
+    id: import("@metamask/superstruct").Struct<string | number | null, null>;
+    method: import("@metamask/superstruct").Struct<string, null>;
+    params: import("@metamask/superstruct").Struct<Record<string, import("@metamask/utils").Json> | import("@metamask/utils").Json[] | import("./superstruct.mjs").ExactOptionalTag, null>;
+}>;
+/**
+ * JSON-RPC request type.
+ */
+export type JsonRpcRequest = Infer<typeof JsonRpcRequestStruct>;
+//# sourceMappingURL=JsonRpcRequest.d.mts.map

package/dist/JsonRpcRequest.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcRequest.d.mts","sourceRoot":"","sources":["../src/JsonRpcRequest.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,8BAA8B;AAKnD,eAAO,MAAM,oBAAoB;;;;;;;;;;EAO/B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/JsonRpcRequest.mjs

@@ -0,0 +1,10 @@
+import { array, literal, number, record, string, union } from "@metamask/superstruct";
+import { JsonStruct } from "@metamask/utils";
+import { exactOptional, object } from "./index.mjs";
+export const JsonRpcRequestStruct = object({
+    jsonrpc: literal('2.0'),
+    id: union([string(), number(), literal(null)]),
+    method: string(),
+    params: exactOptional(union([array(JsonStruct), record(string(), JsonStruct)])),
+});
+//# sourceMappingURL=JsonRpcRequest.mjs.map

package/dist/JsonRpcRequest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcRequest.mjs","sourceRoot":"","sources":["../src/JsonRpcRequest.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,OAAO,EACP,MAAM,EACN,MAAM,EACN,MAAM,EACN,KAAK,EACN,8BAA8B;AAE/B,OAAO,EAAE,UAAU,EAAE,wBAAwB;AAE7C,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,oBAAU;AAE1C,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC;IACzC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC;IACvB,EAAE,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9C,MAAM,EAAE,MAAM,EAAE;IAChB,MAAM,EAAE,aAAa,CACnB,KAAK,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,EAAE,UAAU,CAAC,CAAC,CAAC,CACzD;CACF,CAAC,CAAC","sourcesContent":["import {\n  array,\n  literal,\n  number,\n  record,\n  string,\n  union,\n} from '@metamask/superstruct';\nimport type { Infer } from '@metamask/superstruct';\nimport { JsonStruct } from '@metamask/utils';\n\nimport { exactOptional, object } from '.';\n\nexport const JsonRpcRequestStruct = object({\n  jsonrpc: literal('2.0'),\n  id: union([string(), number(), literal(null)]),\n  method: string(),\n  params: exactOptional(\n    union([array(JsonStruct), record(string(), JsonStruct)]),\n  ),\n});\n\n/**\n * JSON-RPC request type.\n */\nexport type JsonRpcRequest = Infer<typeof JsonRpcRequestStruct>;\n"]}

package/dist/{index.js → index.cjs}

@@ -14,7 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./typing"), exports);
-__exportStar(require("./superstruct"), exports);
-//# sourceMappingURL=index.js.map
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./typing.cjs"), exports);
+__exportStar(require("./superstruct.cjs"), exports);
+__exportStar(require("./JsonRpcRequest.cjs"), exports);
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAAwB;AACxB,+CAAyB;AACzB,oDAA8B;AAC9B,uDAAiC","sourcesContent":["export * from './types';\nexport * from './typing';\nexport * from './superstruct';\nexport * from './JsonRpcRequest';\n"]}

package/dist/index.d.cts

@@ -0,0 +1,5 @@
+export * from "./types.cjs";
+export * from "./typing.cjs";
+export * from "./superstruct.cjs";
+export * from "./JsonRpcRequest.cjs";
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4BAAwB;AACxB,6BAAyB;AACzB,kCAA8B;AAC9B,qCAAiC"}

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+export * from "./types.mjs";
+export * from "./typing.mjs";
+export * from "./superstruct.mjs";
+export * from "./JsonRpcRequest.mjs";
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4BAAwB;AACxB,6BAAyB;AACzB,kCAA8B;AAC9B,qCAAiC"}

package/dist/index.mjs

@@ -0,0 +1,5 @@
+export * from "./types.mjs";
+export * from "./typing.mjs";
+export * from "./superstruct.mjs";
+export * from "./JsonRpcRequest.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4BAAwB;AACxB,6BAAyB;AACzB,kCAA8B;AAC9B,qCAAiC","sourcesContent":["export * from './types';\nexport * from './typing';\nexport * from './superstruct';\nexport * from './JsonRpcRequest';\n"]}

package/dist/{superstruct.js → superstruct.cjs}

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.strictMask = exports.definePattern = exports.exactOptional = exports.object = void 0;
+exports.object = object;
+exports.exactOptional = exactOptional;
+exports.definePattern = definePattern;
+exports.strictMask = strictMask;
+exports.selectiveUnion = selectiveUnion;
 const superstruct_1 = require("@metamask/superstruct");
 /**
  * Change the return type of a superstruct object struct to support exact
@@ -12,7 +16,6 @@ const superstruct_1 = require("@metamask/superstruct");
 function object(schema) {
     return (0, superstruct_1.object)(schema);
 }
-exports.object = object;
 /**
  * Check if the current property is present in its parent object.
  *
@@ -44,7 +47,6 @@ function exactOptional(struct) {
         refiner: (value, ctx) => !hasOptional(ctx) || struct.refiner(value, ctx),
     });
 }
-exports.exactOptional = exactOptional;
 /**
  * Defines a new string-struct matching a regular expression.
  *
@@ -61,7 +63,6 @@ exports.exactOptional = exactOptional;
 function definePattern(name, pattern) {
     return (0, superstruct_1.define)(name, (value) => typeof value === 'string' && pattern.test(value));
 }
-exports.definePattern = definePattern;
 /**
  * Assert that a value is valid according to a struct.
  *
@@ -77,5 +78,32 @@ function strictMask(value, struct, message) {
     (0, superstruct_1.assert)(value, struct, message);
     return value;
 }
-exports.strictMask = strictMask;
-//# sourceMappingURL=superstruct.js.map
+/**
+ * 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) {
+            yield* selector(value).entries(value, context);
+        },
+        *refiner(value, context) {
+            yield* selector(value).refiner(value, context);
+        },
+        coercer(value, context) {
+            return selector(value).coercer(value, context);
+        },
+        validator(value, context) {
+            // This only validates the root of the struct, entries does the rest of
+            // the work.
+            return selector(value).validator(value, context);
+        },
+    });
+}
+//# sourceMappingURL=superstruct.cjs.map

package/dist/superstruct.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"superstruct.cjs","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":";;AAoEA,wBAIC;AA4BD,sCAYC;AAeD,sCASC;AAaD,gCAOC;AAwBD,wCAyBC;AA7MD,uDAK+B;AAwD/B;;;;;;GAMG;AACH,SAAgB,MAAM,CACpB,MAAc;IAEd,OAAO,IAAA,oBAAQ,EAAC,MAAM,CAAQ,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAW,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,MAAM,GAA4B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE1E,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAC3B,MAA4B;IAE5B,OAAO,IAAI,oBAAM,CAAC;QAChB,GAAG,MAAM;QAET,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACxB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAEnD,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,GAAG,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAC3B,IAAY,EACZ,OAAe;IAEf,OAAO,IAAA,oBAAM,EACX,IAAI,EACJ,CAAC,KAAc,EAAW,EAAE,CAC1B,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CACnD,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,UAAU,CACxB,KAAc,EACd,MAA4B,EAC5B,OAAgB;IAEhB,IAAA,oBAAM,EAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC;AAgBD;;;;;;;GAOG;AACH,SAAgB,cAAc,CAC5B,QAAkB;IAElB,OAAO,IAAI,oBAAM,CAAC;QAChB,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,IAAI;QAEZ,CAAC,OAAO,CAAC,KAAU,EAAE,OAAY;YAC/B,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO;YACrB,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,CAAC,KAAK,EAAE,OAAO;YACpB,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,SAAS,CAAC,KAAK,EAAE,OAAO;YACtB,uEAAuE;YACvE,YAAY;YACZ,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACnD,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {\n  Struct,\n  assert,\n  define,\n  object as stObject,\n} from '@metamask/superstruct';\nimport type {\n  Infer,\n  Context,\n  ObjectSchema,\n  OmitBy,\n  Optionalize,\n  PickBy,\n  Simplify,\n  AnyStruct,\n} from '@metamask/superstruct';\n\nimport type { Equals } from './types';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ndeclare const ExactOptionalSymbol: unique symbol;\n\nexport type ExactOptionalTag = {\n  type: typeof ExactOptionalSymbol;\n};\n\n/**\n * Exclude type `Type` from the properties of `Obj`.\n *\n * ```ts\n * type Foo = { a: string | null; b: number };\n * type Bar = ExcludeType<Foo, null>;\n * // Bar = { a: string, b: number }\n * ```\n */\nexport type ExcludeType<Obj, Type> = {\n  [K in keyof Obj]: Exclude<Obj[K], Type>;\n};\n\n/**\n * Make optional all properties that have the `ExactOptionalTag` type.\n *\n * ```ts\n * type Foo = { a: string | ExactOptionalTag; b: number};\n * type Bar = ExactOptionalize<Foo>;\n * // Bar = { a?: string; b: number}\n * ```\n */\nexport type ExactOptionalize<Schema extends object> = OmitBy<\n  Schema,\n  ExactOptionalTag\n> &\n  Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;\n\n/**\n * Infer a type from an superstruct object schema.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ExactOptionalize<Optionalize<{ [K in keyof Schema]: Infer<Schema[K]> }>>\n>;\n\n/**\n * Change the return type of a superstruct object struct to support exact\n * optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties.\n */\nexport function object<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stObject(schema) as any;\n}\n\n/**\n * Check if the current property is present in its parent object.\n *\n * @param ctx - The context to check.\n * @returns `true` if the property is present, `false` otherwise.\n */\nfunction hasOptional(ctx: Context): boolean {\n  const property: string = ctx.path[ctx.path.length - 1];\n  const parent: Record<string, unknown> = ctx.branch[ctx.branch.length - 2];\n\n  return property in parent;\n}\n\n/**\n * Augment a struct to allow exact-optional values. Exact-optional values can\n * be omitted but cannot be `undefined`.\n *\n * ```ts\n * const foo = object({ bar: exactOptional(string()) });\n * type Foo = Infer<typeof foo>;\n * // Foo = { bar?: string }\n * ```\n *\n * @param struct - The struct to augment.\n * @returns The augmented struct.\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type | ExactOptionalTag, Schema> {\n  return new Struct({\n    ...struct,\n\n    validator: (value, ctx) =>\n      !hasOptional(ctx) || struct.validator(value, ctx),\n\n    refiner: (value, ctx) =>\n      !hasOptional(ctx) || struct.refiner(value as Type, ctx),\n  });\n}\n\n/**\n * Defines a new string-struct matching a regular expression.\n *\n * Example:\n *\n * ```ts\n * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);\n * ```\n *\n * @param name - Type name.\n * @param pattern - Regular expression to match.\n * @returns A new string-struct that matches the given pattern.\n */\nexport function definePattern(\n  name: string,\n  pattern: RegExp,\n): Struct<string, null> {\n  return define<string>(\n    name,\n    (value: unknown): boolean =>\n      typeof value === 'string' && pattern.test(value),\n  );\n}\n\n/**\n * Assert that a value is valid according to a struct.\n *\n * It is similar to superstruct's mask function, but it does not ignore extra\n * properties.\n *\n * @param value - Value to check.\n * @param struct - Struct to validate the value against.\n * @param message - Error message to throw if the value is not valid.\n * @returns The value if it is valid.\n */\nexport function strictMask<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  message?: string,\n): Type {\n  assert(value, struct, message);\n  return value;\n}\n\n/**\n * Extracts the type from a struct definition and asserts that it matches the\n * expected type. If the types do not match, the type `never` is returned.\n *\n * @param StructType - The struct type to infer.\n * @param ExpectedType - The expected type.\n */\nexport type InferEquals<\n  StructType extends Struct<any, any>,\n  ExpectedType,\n> = Equals<Infer<StructType>, ExpectedType> extends true\n  ? Infer<StructType>\n  : never;\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\n    *entries(value: any, context: any): ReturnType<Struct['entries']> {\n      yield* selector(value).entries(value, context);\n    },\n\n    *refiner(value, context): ReturnType<Struct['refiner']> {\n      yield* selector(value).refiner(value, context);\n    },\n\n    coercer(value, context): ReturnType<Struct['coercer']> {\n      return selector(value).coercer(value, context);\n    },\n\n    validator(value, context): ReturnType<Struct['validator']> {\n      // This only validates the root of the struct, entries does the rest of\n      // the work.\n      return selector(value).validator(value, context);\n    },\n  });\n}\n"]}

package/dist/{superstruct.d.ts → superstruct.d.cts}

@@ -1,7 +1,8 @@
-import { Struct } from '@metamask/superstruct';
-import type { Infer, ObjectSchema, OmitBy, Optionalize, PickBy, Simplify } from '@metamask/superstruct';
+import { Struct } from "@metamask/superstruct";
+import type { Infer, ObjectSchema, OmitBy, Optionalize, PickBy, Simplify, AnyStruct } from "@metamask/superstruct";
+import type { Equals } from "./types.cjs";
 declare const ExactOptionalSymbol: unique symbol;
-export declare type ExactOptionalTag = {
+export type ExactOptionalTag = {
     type: typeof ExactOptionalSymbol;
 };
 /**
@@ -13,7 +14,7 @@ export declare type ExactOptionalTag = {
  * // Bar = { a: string, b: number }
  * ```
  */
-export declare type ExcludeType<Obj, Type> = {
+export type ExcludeType<Obj, Type> = {
     [K in keyof Obj]: Exclude<Obj[K], Type>;
 };
 /**
@@ -25,11 +26,11 @@ export declare type ExcludeType<Obj, Type> = {
  * // Bar = { a?: string; b: number}
  * ```
  */
-export declare type ExactOptionalize<Schema extends object> = OmitBy<Schema, ExactOptionalTag> & Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;
+export type ExactOptionalize<Schema extends object> = OmitBy<Schema, ExactOptionalTag> & Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;
 /**
  * Infer a type from an superstruct object schema.
  */
-export declare type ObjectType<Schema extends ObjectSchema> = Simplify<ExactOptionalize<Optionalize<{
+export type ObjectType<Schema extends ObjectSchema> = Simplify<ExactOptionalize<Optionalize<{
     [K in keyof Schema]: Infer<Schema[K]>;
 }>>>;
 /**
@@ -80,4 +81,22 @@ export declare function definePattern(name: string, pattern: RegExp): Struct<str
  * @returns The value if it is valid.
  */
 export declare function strictMask<Type, Schema>(value: unknown, struct: Struct<Type, Schema>, message?: string): Type;
+/**
+ * Extracts the type from a struct definition and asserts that it matches the
+ * expected type. If the types do not match, the type `never` is returned.
+ *
+ * @param StructType - The struct type to infer.
+ * @param ExpectedType - The expected type.
+ */
+export type InferEquals<StructType extends Struct<any, any>, ExpectedType> = Equals<Infer<StructType>, ExpectedType> extends true ? Infer<StructType> : never;
+/**
+ * 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>;
 export {};
+//# sourceMappingURL=superstruct.d.cts.map

package/dist/superstruct.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"superstruct.d.cts","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAIP,8BAA8B;AAC/B,OAAO,KAAK,EACV,KAAK,EAEL,YAAY,EACZ,MAAM,EACN,WAAW,EACX,MAAM,EACN,QAAQ,EACR,SAAS,EACV,8BAA8B;AAE/B,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAgB;AAGtC,OAAO,CAAC,MAAM,mBAAmB,EAAE,OAAO,MAAM,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,mBAAmB,CAAC;CAClC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,EAAE,IAAI,IAAI;KAClC,CAAC,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;CACxC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,MAAM,IAAI,MAAM,CAC1D,MAAM,EACN,gBAAgB,CACjB,GACC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,YAAY,IAAI,QAAQ,CAC5D,gBAAgB,CAAC,WAAW,CAAC;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAAC,CACzE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,YAAY,EAChD,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EACxC,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAC3B,MAAM,CAAC,IAAI,GAAG,gBAAgB,EAAE,MAAM,CAAC,CAUzC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAMtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EACrC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAGN;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CACrB,UAAU,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EACnC,YAAY,IACV,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,SAAS,IAAI,GACpD,KAAK,CAAC,UAAU,CAAC,GACjB,KAAK,CAAC;AAEV;;;;;;;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,CAuB3C"}

package/dist/superstruct.d.mts

@@ -0,0 +1,102 @@
+import { Struct } from "@metamask/superstruct";
+import type { Infer, ObjectSchema, OmitBy, Optionalize, PickBy, Simplify, AnyStruct } from "@metamask/superstruct";
+import type { Equals } from "./types.mjs";
+declare const ExactOptionalSymbol: unique symbol;
+export type ExactOptionalTag = {
+    type: typeof ExactOptionalSymbol;
+};
+/**
+ * Exclude type `Type` from the properties of `Obj`.
+ *
+ * ```ts
+ * type Foo = { a: string | null; b: number };
+ * type Bar = ExcludeType<Foo, null>;
+ * // Bar = { a: string, b: number }
+ * ```
+ */
+export type ExcludeType<Obj, Type> = {
+    [K in keyof Obj]: Exclude<Obj[K], Type>;
+};
+/**
+ * Make optional all properties that have the `ExactOptionalTag` type.
+ *
+ * ```ts
+ * type Foo = { a: string | ExactOptionalTag; b: number};
+ * type Bar = ExactOptionalize<Foo>;
+ * // Bar = { a?: string; b: number}
+ * ```
+ */
+export type ExactOptionalize<Schema extends object> = OmitBy<Schema, ExactOptionalTag> & Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;
+/**
+ * Infer a type from an superstruct object schema.
+ */
+export type ObjectType<Schema extends ObjectSchema> = Simplify<ExactOptionalize<Optionalize<{
+    [K in keyof Schema]: Infer<Schema[K]>;
+}>>>;
+/**
+ * Change the return type of a superstruct object struct to support exact
+ * optional properties.
+ *
+ * @param schema - The object schema.
+ * @returns A struct representing an object with a known set of properties.
+ */
+export declare function object<Schema extends ObjectSchema>(schema: Schema): Struct<ObjectType<Schema>, Schema>;
+/**
+ * Augment a struct to allow exact-optional values. Exact-optional values can
+ * be omitted but cannot be `undefined`.
+ *
+ * ```ts
+ * const foo = object({ bar: exactOptional(string()) });
+ * type Foo = Infer<typeof foo>;
+ * // Foo = { bar?: string }
+ * ```
+ *
+ * @param struct - The struct to augment.
+ * @returns The augmented struct.
+ */
+export declare function exactOptional<Type, Schema>(struct: Struct<Type, Schema>): Struct<Type | ExactOptionalTag, Schema>;
+/**
+ * Defines a new string-struct matching a regular expression.
+ *
+ * Example:
+ *
+ * ```ts
+ * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);
+ * ```
+ *
+ * @param name - Type name.
+ * @param pattern - Regular expression to match.
+ * @returns A new string-struct that matches the given pattern.
+ */
+export declare function definePattern(name: string, pattern: RegExp): Struct<string, null>;
+/**
+ * Assert that a value is valid according to a struct.
+ *
+ * It is similar to superstruct's mask function, but it does not ignore extra
+ * properties.
+ *
+ * @param value - Value to check.
+ * @param struct - Struct to validate the value against.
+ * @param message - Error message to throw if the value is not valid.
+ * @returns The value if it is valid.
+ */
+export declare function strictMask<Type, Schema>(value: unknown, struct: Struct<Type, Schema>, message?: string): Type;
+/**
+ * Extracts the type from a struct definition and asserts that it matches the
+ * expected type. If the types do not match, the type `never` is returned.
+ *
+ * @param StructType - The struct type to infer.
+ * @param ExpectedType - The expected type.
+ */
+export type InferEquals<StructType extends Struct<any, any>, ExpectedType> = Equals<Infer<StructType>, ExpectedType> extends true ? Infer<StructType> : never;
+/**
+ * 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>;
+export {};
+//# sourceMappingURL=superstruct.d.mts.map

package/dist/superstruct.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"superstruct.d.mts","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAIP,8BAA8B;AAC/B,OAAO,KAAK,EACV,KAAK,EAEL,YAAY,EACZ,MAAM,EACN,WAAW,EACX,MAAM,EACN,QAAQ,EACR,SAAS,EACV,8BAA8B;AAE/B,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAgB;AAGtC,OAAO,CAAC,MAAM,mBAAmB,EAAE,OAAO,MAAM,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,mBAAmB,CAAC;CAClC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,EAAE,IAAI,IAAI;KAClC,CAAC,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;CACxC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,MAAM,IAAI,MAAM,CAC1D,MAAM,EACN,gBAAgB,CACjB,GACC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,YAAY,IAAI,QAAQ,CAC5D,gBAAgB,CAAC,WAAW,CAAC;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAAC,CACzE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,YAAY,EAChD,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EACxC,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAC3B,MAAM,CAAC,IAAI,GAAG,gBAAgB,EAAE,MAAM,CAAC,CAUzC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAMtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EACrC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAGN;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CACrB,UAAU,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EACnC,YAAY,IACV,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,SAAS,IAAI,GACpD,KAAK,CAAC,UAAU,CAAC,GACjB,KAAK,CAAC;AAEV;;;;;;;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,CAuB3C"}

package/dist/superstruct.mjs

@@ -0,0 +1,102 @@
+import { Struct, assert, define, object as stObject } from "@metamask/superstruct";
+/**
+ * Change the return type of a superstruct object struct to support exact
+ * optional properties.
+ *
+ * @param schema - The object schema.
+ * @returns A struct representing an object with a known set of properties.
+ */
+export function object(schema) {
+    return stObject(schema);
+}
+/**
+ * Check if the current property is present in its parent object.
+ *
+ * @param ctx - The context to check.
+ * @returns `true` if the property is present, `false` otherwise.
+ */
+function hasOptional(ctx) {
+    const property = ctx.path[ctx.path.length - 1];
+    const parent = ctx.branch[ctx.branch.length - 2];
+    return property in parent;
+}
+/**
+ * Augment a struct to allow exact-optional values. Exact-optional values can
+ * be omitted but cannot be `undefined`.
+ *
+ * ```ts
+ * const foo = object({ bar: exactOptional(string()) });
+ * type Foo = Infer<typeof foo>;
+ * // Foo = { bar?: string }
+ * ```
+ *
+ * @param struct - The struct to augment.
+ * @returns The augmented struct.
+ */
+export function exactOptional(struct) {
+    return new Struct({
+        ...struct,
+        validator: (value, ctx) => !hasOptional(ctx) || struct.validator(value, ctx),
+        refiner: (value, ctx) => !hasOptional(ctx) || struct.refiner(value, ctx),
+    });
+}
+/**
+ * Defines a new string-struct matching a regular expression.
+ *
+ * Example:
+ *
+ * ```ts
+ * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);
+ * ```
+ *
+ * @param name - Type name.
+ * @param pattern - Regular expression to match.
+ * @returns A new string-struct that matches the given pattern.
+ */
+export function definePattern(name, pattern) {
+    return define(name, (value) => typeof value === 'string' && pattern.test(value));
+}
+/**
+ * Assert that a value is valid according to a struct.
+ *
+ * It is similar to superstruct's mask function, but it does not ignore extra
+ * properties.
+ *
+ * @param value - Value to check.
+ * @param struct - Struct to validate the value against.
+ * @param message - Error message to throw if the value is not valid.
+ * @returns The value if it is valid.
+ */
+export function strictMask(value, struct, message) {
+    assert(value, struct, message);
+    return value;
+}
+/**
+ * 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) {
+            yield* selector(value).entries(value, context);
+        },
+        *refiner(value, context) {
+            yield* selector(value).refiner(value, context);
+        },
+        coercer(value, context) {
+            return selector(value).coercer(value, context);
+        },
+        validator(value, context) {
+            // This only validates the root of the struct, entries does the rest of
+            // the work.
+            return selector(value).validator(value, context);
+        },
+    });
+}
+//# sourceMappingURL=superstruct.mjs.map

package/dist/superstruct.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"superstruct.mjs","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,MAAM,EACN,MAAM,EACN,MAAM,IAAI,QAAQ,EACnB,8BAA8B;AAwD/B;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CACpB,MAAc;IAEd,OAAO,QAAQ,CAAC,MAAM,CAAQ,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAW,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,MAAM,GAA4B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE1E,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAC3B,MAA4B;IAE5B,OAAO,IAAI,MAAM,CAAC;QAChB,GAAG,MAAM;QAET,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACxB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAEnD,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,GAAG,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAC3B,IAAY,EACZ,OAAe;IAEf,OAAO,MAAM,CACX,IAAI,EACJ,CAAC,KAAc,EAAW,EAAE,CAC1B,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CACnD,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,UAAU,CACxB,KAAc,EACd,MAA4B,EAC5B,OAAgB;IAEhB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC;AAgBD;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAC5B,QAAkB;IAElB,OAAO,IAAI,MAAM,CAAC;QAChB,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,IAAI;QAEZ,CAAC,OAAO,CAAC,KAAU,EAAE,OAAY;YAC/B,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO;YACrB,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,CAAC,KAAK,EAAE,OAAO;YACpB,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,SAAS,CAAC,KAAK,EAAE,OAAO;YACtB,uEAAuE;YACvE,YAAY;YACZ,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACnD,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {\n  Struct,\n  assert,\n  define,\n  object as stObject,\n} from '@metamask/superstruct';\nimport type {\n  Infer,\n  Context,\n  ObjectSchema,\n  OmitBy,\n  Optionalize,\n  PickBy,\n  Simplify,\n  AnyStruct,\n} from '@metamask/superstruct';\n\nimport type { Equals } from './types';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ndeclare const ExactOptionalSymbol: unique symbol;\n\nexport type ExactOptionalTag = {\n  type: typeof ExactOptionalSymbol;\n};\n\n/**\n * Exclude type `Type` from the properties of `Obj`.\n *\n * ```ts\n * type Foo = { a: string | null; b: number };\n * type Bar = ExcludeType<Foo, null>;\n * // Bar = { a: string, b: number }\n * ```\n */\nexport type ExcludeType<Obj, Type> = {\n  [K in keyof Obj]: Exclude<Obj[K], Type>;\n};\n\n/**\n * Make optional all properties that have the `ExactOptionalTag` type.\n *\n * ```ts\n * type Foo = { a: string | ExactOptionalTag; b: number};\n * type Bar = ExactOptionalize<Foo>;\n * // Bar = { a?: string; b: number}\n * ```\n */\nexport type ExactOptionalize<Schema extends object> = OmitBy<\n  Schema,\n  ExactOptionalTag\n> &\n  Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;\n\n/**\n * Infer a type from an superstruct object schema.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ExactOptionalize<Optionalize<{ [K in keyof Schema]: Infer<Schema[K]> }>>\n>;\n\n/**\n * Change the return type of a superstruct object struct to support exact\n * optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties.\n */\nexport function object<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stObject(schema) as any;\n}\n\n/**\n * Check if the current property is present in its parent object.\n *\n * @param ctx - The context to check.\n * @returns `true` if the property is present, `false` otherwise.\n */\nfunction hasOptional(ctx: Context): boolean {\n  const property: string = ctx.path[ctx.path.length - 1];\n  const parent: Record<string, unknown> = ctx.branch[ctx.branch.length - 2];\n\n  return property in parent;\n}\n\n/**\n * Augment a struct to allow exact-optional values. Exact-optional values can\n * be omitted but cannot be `undefined`.\n *\n * ```ts\n * const foo = object({ bar: exactOptional(string()) });\n * type Foo = Infer<typeof foo>;\n * // Foo = { bar?: string }\n * ```\n *\n * @param struct - The struct to augment.\n * @returns The augmented struct.\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type | ExactOptionalTag, Schema> {\n  return new Struct({\n    ...struct,\n\n    validator: (value, ctx) =>\n      !hasOptional(ctx) || struct.validator(value, ctx),\n\n    refiner: (value, ctx) =>\n      !hasOptional(ctx) || struct.refiner(value as Type, ctx),\n  });\n}\n\n/**\n * Defines a new string-struct matching a regular expression.\n *\n * Example:\n *\n * ```ts\n * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);\n * ```\n *\n * @param name - Type name.\n * @param pattern - Regular expression to match.\n * @returns A new string-struct that matches the given pattern.\n */\nexport function definePattern(\n  name: string,\n  pattern: RegExp,\n): Struct<string, null> {\n  return define<string>(\n    name,\n    (value: unknown): boolean =>\n      typeof value === 'string' && pattern.test(value),\n  );\n}\n\n/**\n * Assert that a value is valid according to a struct.\n *\n * It is similar to superstruct's mask function, but it does not ignore extra\n * properties.\n *\n * @param value - Value to check.\n * @param struct - Struct to validate the value against.\n * @param message - Error message to throw if the value is not valid.\n * @returns The value if it is valid.\n */\nexport function strictMask<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  message?: string,\n): Type {\n  assert(value, struct, message);\n  return value;\n}\n\n/**\n * Extracts the type from a struct definition and asserts that it matches the\n * expected type. If the types do not match, the type `never` is returned.\n *\n * @param StructType - The struct type to infer.\n * @param ExpectedType - The expected type.\n */\nexport type InferEquals<\n  StructType extends Struct<any, any>,\n  ExpectedType,\n> = Equals<Infer<StructType>, ExpectedType> extends true\n  ? Infer<StructType>\n  : never;\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\n    *entries(value: any, context: any): ReturnType<Struct['entries']> {\n      yield* selector(value).entries(value, context);\n    },\n\n    *refiner(value, context): ReturnType<Struct['refiner']> {\n      yield* selector(value).refiner(value, context);\n    },\n\n    coercer(value, context): ReturnType<Struct['coercer']> {\n      return selector(value).coercer(value, context);\n    },\n\n    validator(value, context): ReturnType<Struct['validator']> {\n      // This only validates the root of the struct, entries does the rest of\n      // the work.\n      return selector(value).validator(value, context);\n    },\n  });\n}\n"]}

package/dist/{types.js → types.cjs}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StringNumberStruct = exports.UrlStruct = exports.UuidStruct = void 0;
 const superstruct_1 = require("@metamask/superstruct");
-const superstruct_2 = require("./superstruct");
+const superstruct_2 = require("./superstruct.cjs");
 /**
  * UUIDv4 struct.
  */
@@ -18,7 +18,7 @@ exports.UrlStruct = (0, superstruct_1.define)('Url', (value) => {
         const url = new URL(value);
         return url.protocol === 'http:' || url.protocol === 'https:';
     }
-    catch (_) {
+    catch {
         return false;
     }
 });
@@ -26,4 +26,4 @@ exports.UrlStruct = (0, superstruct_1.define)('Url', (value) => {
  * A string which contains a positive float number.
  */
 exports.StringNumberStruct = (0, superstruct_2.definePattern)('StringNumber', /^\d+(\.\d+)?$/u);
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.cjs.map

package/dist/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAAA,uDAA2D;AAE3D,mDAA8C;AAE9C;;GAEG;AACU,QAAA,UAAU,GAAG,IAAA,2BAAa,EACrC,QAAQ,EACR,yEAAyE,CAC1E,CAAC;AAEF;;;;;GAKG;AACU,QAAA,SAAS,GAAG,IAAA,oBAAM,EAAS,KAAK,EAAE,CAAC,KAAc,EAAE,EAAE;IAChE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAe,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC,CAAC;AAEH;;GAEG;AACU,QAAA,kBAAkB,GAAG,IAAA,2BAAa,EAC7C,cAAc,EACd,gBAAgB,CACjB,CAAC","sourcesContent":["import { define, type Infer } from '@metamask/superstruct';\n\nimport { definePattern } from './superstruct';\n\n/**\n * UUIDv4 struct.\n */\nexport const UuidStruct = definePattern(\n  'UuidV4',\n  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,\n);\n\n/**\n * Validates if a given value is a valid URL.\n *\n * @param value - The value to be validated.\n * @returns A boolean indicating if the value is a valid URL.\n */\nexport const UrlStruct = define<string>('Url', (value: unknown) => {\n  try {\n    const url = new URL(value as string);\n    return url.protocol === 'http:' || url.protocol === 'https:';\n  } catch {\n    return false;\n  }\n});\n\n/**\n * A string which contains a positive float number.\n */\nexport const StringNumberStruct = definePattern(\n  'StringNumber',\n  /^\\d+(\\.\\d+)?$/u,\n);\nexport type StringNumber = Infer<typeof StringNumberStruct>;\n\n/**\n * This is a helper type used by the {@link Equals} type.\n */\ntype EqualsHelper<Type> = <Dummy>() => Dummy extends Type ? 1 : 2;\n\n/**\n * A utility type that checks whether two types are exactly the same.\n *\n * This type evaluates to `true` if `TypeA` and `TypeB` are identical,\n * otherwise it evaluates to `false`.\n *\n * @template TypeA - The first type to compare.\n * @template TypeB - The second type to compare.\n *\n * @example\n * ```ts\n * // Example usage:\n * type Test1 = Equals<number, number>; // true\n * type Test2 = Equals<number, string>; // false\n * type Test3 = Equals<{ a: string }, { a: string }>; // true\n * type Test4 = Equals<{ a: string }, { a: number }>; // false\n * ```\n */\nexport type Equals<TypeA, TypeB> =\n  EqualsHelper<TypeA> extends EqualsHelper<TypeB> ? true : false;\n"]}

package/dist/types.d.cts

@@ -0,0 +1,42 @@
+import { type Infer } from "@metamask/superstruct";
+/**
+ * UUIDv4 struct.
+ */
+export declare const UuidStruct: import("@metamask/superstruct").Struct<string, null>;
+/**
+ * Validates if a given value is a valid URL.
+ *
+ * @param value - The value to be validated.
+ * @returns A boolean indicating if the value is a valid URL.
+ */
+export declare const UrlStruct: import("@metamask/superstruct").Struct<string, null>;
+/**
+ * A string which contains a positive float number.
+ */
+export declare const StringNumberStruct: import("@metamask/superstruct").Struct<string, null>;
+export type StringNumber = Infer<typeof StringNumberStruct>;
+/**
+ * This is a helper type used by the {@link Equals} type.
+ */
+type EqualsHelper<Type> = <Dummy>() => Dummy extends Type ? 1 : 2;
+/**
+ * A utility type that checks whether two types are exactly the same.
+ *
+ * This type evaluates to `true` if `TypeA` and `TypeB` are identical,
+ * otherwise it evaluates to `false`.
+ *
+ * @template TypeA - The first type to compare.
+ * @template TypeB - The second type to compare.
+ *
+ * @example
+ * ```ts
+ * // Example usage:
+ * type Test1 = Equals<number, number>; // true
+ * type Test2 = Equals<number, string>; // false
+ * type Test3 = Equals<{ a: string }, { a: string }>; // true
+ * type Test4 = Equals<{ a: string }, { a: number }>; // false
+ * ```
+ */
+export type Equals<TypeA, TypeB> = EqualsHelper<TypeA> extends EqualsHelper<TypeB> ? true : false;
+export {};
+//# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,KAAK,EAAE,8BAA8B;AAI3D;;GAEG;AACH,eAAO,MAAM,UAAU,sDAGtB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,sDAOpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,sDAG9B,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE5D;;GAEG;AACH,KAAK,YAAY,CAAC,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,MAAM,CAAC,KAAK,EAAE,KAAK,IAC7B,YAAY,CAAC,KAAK,CAAC,SAAS,YAAY,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types.d.mts

@@ -0,0 +1,42 @@
+import { type Infer } from "@metamask/superstruct";
+/**
+ * UUIDv4 struct.
+ */
+export declare const UuidStruct: import("@metamask/superstruct").Struct<string, null>;
+/**
+ * Validates if a given value is a valid URL.
+ *
+ * @param value - The value to be validated.
+ * @returns A boolean indicating if the value is a valid URL.
+ */
+export declare const UrlStruct: import("@metamask/superstruct").Struct<string, null>;
+/**
+ * A string which contains a positive float number.
+ */
+export declare const StringNumberStruct: import("@metamask/superstruct").Struct<string, null>;
+export type StringNumber = Infer<typeof StringNumberStruct>;
+/**
+ * This is a helper type used by the {@link Equals} type.
+ */
+type EqualsHelper<Type> = <Dummy>() => Dummy extends Type ? 1 : 2;
+/**
+ * A utility type that checks whether two types are exactly the same.
+ *
+ * This type evaluates to `true` if `TypeA` and `TypeB` are identical,
+ * otherwise it evaluates to `false`.
+ *
+ * @template TypeA - The first type to compare.
+ * @template TypeB - The second type to compare.
+ *
+ * @example
+ * ```ts
+ * // Example usage:
+ * type Test1 = Equals<number, number>; // true
+ * type Test2 = Equals<number, string>; // false
+ * type Test3 = Equals<{ a: string }, { a: string }>; // true
+ * type Test4 = Equals<{ a: string }, { a: number }>; // false
+ * ```
+ */
+export type Equals<TypeA, TypeB> = EqualsHelper<TypeA> extends EqualsHelper<TypeB> ? true : false;
+export {};
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,KAAK,EAAE,8BAA8B;AAI3D;;GAEG;AACH,eAAO,MAAM,UAAU,sDAGtB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,sDAOpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,sDAG9B,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE5D;;GAEG;AACH,KAAK,YAAY,CAAC,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,MAAM,CAAC,KAAK,EAAE,KAAK,IAC7B,YAAY,CAAC,KAAK,CAAC,SAAS,YAAY,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types.mjs

@@ -0,0 +1,26 @@
+import { define } from "@metamask/superstruct";
+import { definePattern } from "./superstruct.mjs";
+/**
+ * UUIDv4 struct.
+ */
+export const UuidStruct = definePattern('UuidV4', /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu);
+/**
+ * Validates if a given value is a valid URL.
+ *
+ * @param value - The value to be validated.
+ * @returns A boolean indicating if the value is a valid URL.
+ */
+export const UrlStruct = define('Url', (value) => {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+});
+/**
+ * A string which contains a positive float number.
+ */
+export const StringNumberStruct = definePattern('StringNumber', /^\d+(\.\d+)?$/u);
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAc,8BAA8B;AAE3D,OAAO,EAAE,aAAa,EAAE,0BAAsB;AAE9C;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,aAAa,CACrC,QAAQ,EACR,yEAAyE,CAC1E,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAS,KAAK,EAAE,CAAC,KAAc,EAAE,EAAE;IAChE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAe,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,aAAa,CAC7C,cAAc,EACd,gBAAgB,CACjB,CAAC","sourcesContent":["import { define, type Infer } from '@metamask/superstruct';\n\nimport { definePattern } from './superstruct';\n\n/**\n * UUIDv4 struct.\n */\nexport const UuidStruct = definePattern(\n  'UuidV4',\n  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,\n);\n\n/**\n * Validates if a given value is a valid URL.\n *\n * @param value - The value to be validated.\n * @returns A boolean indicating if the value is a valid URL.\n */\nexport const UrlStruct = define<string>('Url', (value: unknown) => {\n  try {\n    const url = new URL(value as string);\n    return url.protocol === 'http:' || url.protocol === 'https:';\n  } catch {\n    return false;\n  }\n});\n\n/**\n * A string which contains a positive float number.\n */\nexport const StringNumberStruct = definePattern(\n  'StringNumber',\n  /^\\d+(\\.\\d+)?$/u,\n);\nexport type StringNumber = Infer<typeof StringNumberStruct>;\n\n/**\n * This is a helper type used by the {@link Equals} type.\n */\ntype EqualsHelper<Type> = <Dummy>() => Dummy extends Type ? 1 : 2;\n\n/**\n * A utility type that checks whether two types are exactly the same.\n *\n * This type evaluates to `true` if `TypeA` and `TypeB` are identical,\n * otherwise it evaluates to `false`.\n *\n * @template TypeA - The first type to compare.\n * @template TypeB - The second type to compare.\n *\n * @example\n * ```ts\n * // Example usage:\n * type Test1 = Equals<number, number>; // true\n * type Test2 = Equals<number, string>; // false\n * type Test3 = Equals<{ a: string }, { a: string }>; // true\n * type Test4 = Equals<{ a: string }, { a: number }>; // false\n * ```\n */\nexport type Equals<TypeA, TypeB> =\n  EqualsHelper<TypeA> extends EqualsHelper<TypeB> ? true : false;\n"]}

package/dist/{typing.js → typing.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectTrue = void 0;
+exports.expectTrue = expectTrue;
 /**
  * Assert that a type extends `true`. It can be used, for example, to assert
  * that a given type extends another type.
@@ -17,5 +17,4 @@ exports.expectTrue = void 0;
 function expectTrue() {
     // Intentionally empty
 }
-exports.expectTrue = expectTrue;
-//# sourceMappingURL=typing.js.map
+//# sourceMappingURL=typing.cjs.map

package/dist/{typing.js.map → typing.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"typing.js","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":";;;AAuBA;;;;;;;;;;;GAWG;AACH,6DAA6D;AAC7D,SAAgB,UAAU;IACxB,sBAAsB;AACxB,CAAC;AAFD,gCAEC","sourcesContent":["/**\n * Omit keys from a union type.\n *\n * The normal `Omit` type does not distribute over unions. So we use this\n * workaround that applies `Omit` to each member of the union.\n *\n * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>\n */\nexport type OmitUnion<Type, Key extends keyof any> = Type extends any\n  ? Omit<Type, Key>\n  : never;\n\n/**\n * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.\n *\n * @example\n * ```ts\n * type A = Extends<{a: string, b: string}, {a: string}>; // true\n * type B = Extends<{a: string}, {a: string, b: string}>; // false\n * ```\n */\nexport type Extends<Child, Base> = Child extends Base ? true : false;\n\n/**\n * Assert that a type extends `true`. It can be used, for example, to assert\n * that a given type extends another type.\n *\n * @example\n * ```ts\n * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok\n * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error\n * ```\n *\n * This function follows the naming pattern used on `tsd`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function expectTrue<Type extends true>(): void {\n  // Intentionally empty\n}\n"]}
+{"version":3,"file":"typing.cjs","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":";;AAoCA,gCAEC;AAfD;;;;;;;;;;;GAWG;AACH,6DAA6D;AAC7D,SAAgB,UAAU;IACxB,sBAAsB;AACxB,CAAC","sourcesContent":["/**\n * Omit keys from a union type.\n *\n * The normal `Omit` type does not distribute over unions. So we use this\n * workaround that applies `Omit` to each member of the union.\n *\n * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>\n */\nexport type OmitUnion<Type, Key extends keyof any> = Type extends any\n  ? Omit<Type, Key>\n  : never;\n\n/**\n * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.\n *\n * @example\n * ```ts\n * type A = Extends<{a: string, b: string}, {a: string}>; // true\n * type B = Extends<{a: string}, {a: string, b: string}>; // false\n * ```\n */\nexport type Extends<Child, Base> = Child extends Base ? true : false;\n\n/**\n * Assert that a type extends `true`. It can be used, for example, to assert\n * that a given type extends another type.\n *\n * @example\n * ```ts\n * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok\n * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error\n * ```\n *\n * This function follows the naming pattern used on `tsd`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function expectTrue<Type extends true>(): void {\n  // Intentionally empty\n}\n"]}

package/dist/{typing.d.ts → typing.d.cts}

@@ -6,7 +6,7 @@
  *
  * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>
  */
-export declare type OmitUnion<Type, Key extends keyof any> = Type extends any ? Omit<Type, Key> : never;
+export type OmitUnion<Type, Key extends keyof any> = Type extends any ? Omit<Type, Key> : never;
 /**
  * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.
  *
@@ -16,7 +16,7 @@ export declare type OmitUnion<Type, Key extends keyof any> = Type extends any ?
  * type B = Extends<{a: string}, {a: string, b: string}>; // false
  * ```
  */
-export declare type Extends<Child, Base> = Child extends Base ? true : false;
+export type Extends<Child, Base> = Child extends Base ? true : false;
 /**
  * Assert that a type extends `true`. It can be used, for example, to assert
  * that a given type extends another type.
@@ -30,3 +30,4 @@ export declare type Extends<Child, Base> = Child extends Base ? true : false;
  * This function follows the naming pattern used on `tsd`.
  */
 export declare function expectTrue<Type extends true>(): void;
+//# sourceMappingURL=typing.d.cts.map

package/dist/typing.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing.d.cts","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,CAAC,IAAI,EAAE,GAAG,SAAS,MAAM,GAAG,IAAI,IAAI,SAAS,GAAG,GACjE,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,GACf,KAAK,CAAC;AAEV;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,CAAC,KAAK,EAAE,IAAI,IAAI,KAAK,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC;AAErE;;;;;;;;;;;GAWG;AAEH,wBAAgB,UAAU,CAAC,IAAI,SAAS,IAAI,KAAK,IAAI,CAEpD"}

package/dist/typing.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Omit keys from a union type.
+ *
+ * The normal `Omit` type does not distribute over unions. So we use this
+ * workaround that applies `Omit` to each member of the union.
+ *
+ * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>
+ */
+export type OmitUnion<Type, Key extends keyof any> = Type extends any ? Omit<Type, Key> : never;
+/**
+ * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * type A = Extends<{a: string, b: string}, {a: string}>; // true
+ * type B = Extends<{a: string}, {a: string, b: string}>; // false
+ * ```
+ */
+export type Extends<Child, Base> = Child extends Base ? true : false;
+/**
+ * Assert that a type extends `true`. It can be used, for example, to assert
+ * that a given type extends another type.
+ *
+ * @example
+ * ```ts
+ * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok
+ * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error
+ * ```
+ *
+ * This function follows the naming pattern used on `tsd`.
+ */
+export declare function expectTrue<Type extends true>(): void;
+//# sourceMappingURL=typing.d.mts.map

package/dist/typing.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing.d.mts","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,CAAC,IAAI,EAAE,GAAG,SAAS,MAAM,GAAG,IAAI,IAAI,SAAS,GAAG,GACjE,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,GACf,KAAK,CAAC;AAEV;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,CAAC,KAAK,EAAE,IAAI,IAAI,KAAK,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC;AAErE;;;;;;;;;;;GAWG;AAEH,wBAAgB,UAAU,CAAC,IAAI,SAAS,IAAI,KAAK,IAAI,CAEpD"}

package/dist/typing.mjs

@@ -0,0 +1,17 @@
+/**
+ * Assert that a type extends `true`. It can be used, for example, to assert
+ * that a given type extends another type.
+ *
+ * @example
+ * ```ts
+ * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok
+ * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error
+ * ```
+ *
+ * This function follows the naming pattern used on `tsd`.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function expectTrue() {
+    // Intentionally empty
+}
+//# sourceMappingURL=typing.mjs.map

package/dist/typing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing.mjs","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":"AAuBA;;;;;;;;;;;GAWG;AACH,6DAA6D;AAC7D,MAAM,UAAU,UAAU;IACxB,sBAAsB;AACxB,CAAC","sourcesContent":["/**\n * Omit keys from a union type.\n *\n * The normal `Omit` type does not distribute over unions. So we use this\n * workaround that applies `Omit` to each member of the union.\n *\n * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>\n */\nexport type OmitUnion<Type, Key extends keyof any> = Type extends any\n  ? Omit<Type, Key>\n  : never;\n\n/**\n * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.\n *\n * @example\n * ```ts\n * type A = Extends<{a: string, b: string}, {a: string}>; // true\n * type B = Extends<{a: string}, {a: string, b: string}>; // false\n * ```\n */\nexport type Extends<Child, Base> = Child extends Base ? true : false;\n\n/**\n * Assert that a type extends `true`. It can be used, for example, to assert\n * that a given type extends another type.\n *\n * @example\n * ```ts\n * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok\n * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error\n * ```\n *\n * This function follows the naming pattern used on `tsd`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function expectTrue<Type extends true>(): void {\n  // Intentionally empty\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask-previews/keyring-utils",
-  "version": "0.0.1-preview-46bb5ff",
+  "version": "1.0.0-4685a87",
   "description": "MetaMask Keyring utils",
   "keywords": [
     "metamask",
@@ -14,49 +14,57 @@
     "type": "git",
     "url": "https://github.com/MetaMask/accounts.git"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
   "files": [
     "dist/"
   ],
   "scripts": {
-    "build": "tsc --build tsconfig.build.json",
-    "build:clean": "rimraf dist && yarn build",
+    "build": "ts-bridge --project tsconfig.build.json --no-references",
+    "build:clean": "yarn build --clean",
     "build:docs": "typedoc",
-    "build:force": "tsc --build tsconfig.build.json --force",
     "changelog:update": "../../scripts/update-changelog.sh @metamask/keyring-utils",
     "changelog:validate": "../../scripts/validate-changelog.sh @metamask/keyring-utils",
     "publish:preview": "yarn npm publish --tag preview",
     "test": "yarn test:source && yarn test:types",
     "test:clean": "jest --clearCache",
     "test:source": "jest && jest-it-up",
-    "test:types": "tsd",
-    "test:verbose": "jest --verbose",
+    "test:types": "../../scripts/tsd-test.sh ./src",
     "test:watch": "jest --watch"
   },
   "dependencies": {
     "@metamask/superstruct": "^3.1.0",
-    "@metamask/utils": "^9.1.0",
-    "@types/uuid": "^9.0.8",
-    "deepmerge": "^4.2.2",
-    "uuid": "^9.0.1"
+    "@metamask/utils": "^9.3.0"
   },
   "devDependencies": {
-    "@lavamoat/allow-scripts": "^3.0.4",
-    "@lavamoat/preinstall-always-fail": "^2.0.0",
+    "@lavamoat/allow-scripts": "^3.2.1",
+    "@lavamoat/preinstall-always-fail": "^2.1.0",
     "@metamask/auto-changelog": "^3.4.4",
-    "@metamask/providers": "^17.1.1",
+    "@ts-bridge/cli": "^0.6.1",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.12.12",
+    "deepmerge": "^4.2.2",
     "depcheck": "^1.4.7",
-    "jest": "^28.1.3",
+    "jest": "^29.5.0",
     "jest-it-up": "^3.1.0",
     "rimraf": "^5.0.7",
-    "ts-jest": "^28.0.8",
+    "ts-jest": "^29.0.5",
     "ts-node": "^10.9.2",
     "tsd": "^0.31.0",
     "typedoc": "^0.25.13",
-    "typescript": "~4.8.4"
+    "typescript": "~5.6.3"
   },
   "engines": {
     "node": "^18.18 || >=20"
@@ -71,6 +79,9 @@
     }
   },
   "tsd": {
-    "directory": "src"
+    "directory": "src",
+    "compilerOptions": {
+      "composite": "false"
+    }
   }
 }

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export * from './types';
-export * from './typing';
-export * from './superstruct';

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,2CAAyB;AACzB,gDAA8B","sourcesContent":["export * from './types';\nexport * from './typing';\nexport * from './superstruct';\n"]}

package/dist/superstruct.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"superstruct.js","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":";;;AAAA,uDAK+B;AAoD/B;;;;;;GAMG;AACH,SAAgB,MAAM,CACpB,MAAc;IAEd,OAAO,IAAA,oBAAQ,EAAC,MAAM,CAAQ,CAAC;AACjC,CAAC;AAJD,wBAIC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAW,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,MAAM,GAA4B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE1E,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAC3B,MAA4B;IAE5B,OAAO,IAAI,oBAAM,CAAC;QAChB,GAAG,MAAM;QAET,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACxB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAEnD,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,GAAG,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAZD,sCAYC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAC3B,IAAY,EACZ,OAAe;IAEf,OAAO,IAAA,oBAAM,EACX,IAAI,EACJ,CAAC,KAAc,EAAW,EAAE,CAC1B,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CACnD,CAAC;AACJ,CAAC;AATD,sCASC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,UAAU,CACxB,KAAc,EACd,MAA4B,EAC5B,OAAgB;IAEhB,IAAA,oBAAM,EAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC;AAPD,gCAOC","sourcesContent":["import {\n  Struct,\n  assert,\n  define,\n  object as stObject,\n} from '@metamask/superstruct';\nimport type {\n  Infer,\n  Context,\n  ObjectSchema,\n  OmitBy,\n  Optionalize,\n  PickBy,\n  Simplify,\n} from '@metamask/superstruct';\n\ndeclare const ExactOptionalSymbol: unique symbol;\n\nexport type ExactOptionalTag = {\n  type: typeof ExactOptionalSymbol;\n};\n\n/**\n * Exclude type `Type` from the properties of `Obj`.\n *\n * ```ts\n * type Foo = { a: string | null; b: number };\n * type Bar = ExcludeType<Foo, null>;\n * // Bar = { a: string, b: number }\n * ```\n */\nexport type ExcludeType<Obj, Type> = {\n  [K in keyof Obj]: Exclude<Obj[K], Type>;\n};\n\n/**\n * Make optional all properties that have the `ExactOptionalTag` type.\n *\n * ```ts\n * type Foo = { a: string | ExactOptionalTag; b: number};\n * type Bar = ExactOptionalize<Foo>;\n * // Bar = { a?: string; b: number}\n * ```\n */\nexport type ExactOptionalize<Schema extends object> = OmitBy<\n  Schema,\n  ExactOptionalTag\n> &\n  Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;\n\n/**\n * Infer a type from an superstruct object schema.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ExactOptionalize<Optionalize<{ [K in keyof Schema]: Infer<Schema[K]> }>>\n>;\n\n/**\n * Change the return type of a superstruct object struct to support exact\n * optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties.\n */\nexport function object<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stObject(schema) as any;\n}\n\n/**\n * Check if the current property is present in its parent object.\n *\n * @param ctx - The context to check.\n * @returns `true` if the property is present, `false` otherwise.\n */\nfunction hasOptional(ctx: Context): boolean {\n  const property: string = ctx.path[ctx.path.length - 1];\n  const parent: Record<string, unknown> = ctx.branch[ctx.branch.length - 2];\n\n  return property in parent;\n}\n\n/**\n * Augment a struct to allow exact-optional values. Exact-optional values can\n * be omitted but cannot be `undefined`.\n *\n * ```ts\n * const foo = object({ bar: exactOptional(string()) });\n * type Foo = Infer<typeof foo>;\n * // Foo = { bar?: string }\n * ```\n *\n * @param struct - The struct to augment.\n * @returns The augmented struct.\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type | ExactOptionalTag, Schema> {\n  return new Struct({\n    ...struct,\n\n    validator: (value, ctx) =>\n      !hasOptional(ctx) || struct.validator(value, ctx),\n\n    refiner: (value, ctx) =>\n      !hasOptional(ctx) || struct.refiner(value as Type, ctx),\n  });\n}\n\n/**\n * Defines a new string-struct matching a regular expression.\n *\n * Example:\n *\n * ```ts\n * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);\n * ```\n *\n * @param name - Type name.\n * @param pattern - Regular expression to match.\n * @returns A new string-struct that matches the given pattern.\n */\nexport function definePattern(\n  name: string,\n  pattern: RegExp,\n): Struct<string, null> {\n  return define<string>(\n    name,\n    (value: unknown): boolean =>\n      typeof value === 'string' && pattern.test(value),\n  );\n}\n\n/**\n * Assert that a value is valid according to a struct.\n *\n * It is similar to superstruct's mask function, but it does not ignore extra\n * properties.\n *\n * @param value - Value to check.\n * @param struct - Struct to validate the value against.\n * @param message - Error message to throw if the value is not valid.\n * @returns The value if it is valid.\n */\nexport function strictMask<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  message?: string,\n): Type {\n  assert(value, struct, message);\n  return value;\n}\n"]}

package/dist/types.d.ts

@@ -1,17 +0,0 @@
-import { type Infer } from '@metamask/superstruct';
-/**
- * UUIDv4 struct.
- */
-export declare const UuidStruct: import("@metamask/superstruct").Struct<string, null>;
-/**
- * Validates if a given value is a valid URL.
- *
- * @param value - The value to be validated.
- * @returns A boolean indicating if the value is a valid URL.
- */
-export declare const UrlStruct: import("@metamask/superstruct").Struct<string, null>;
-/**
- * A string which contains a positive float number.
- */
-export declare const StringNumberStruct: import("@metamask/superstruct").Struct<string, null>;
-export declare type StringNumber = Infer<typeof StringNumberStruct>;

package/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAAA,uDAA2D;AAE3D,+CAA8C;AAE9C;;GAEG;AACU,QAAA,UAAU,GAAG,IAAA,2BAAa,EACrC,QAAQ,EACR,yEAAyE,CAC1E,CAAC;AAEF;;;;;GAKG;AACU,QAAA,SAAS,GAAG,IAAA,oBAAM,EAAS,KAAK,EAAE,CAAC,KAAc,EAAE,EAAE;IAChE,IAAI;QACF,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAe,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;KAC9D;IAAC,OAAO,CAAC,EAAE;QACV,OAAO,KAAK,CAAC;KACd;AACH,CAAC,CAAC,CAAC;AAEH;;GAEG;AACU,QAAA,kBAAkB,GAAG,IAAA,2BAAa,EAC7C,cAAc,EACd,gBAAgB,CACjB,CAAC","sourcesContent":["import { define, type Infer } from '@metamask/superstruct';\n\nimport { definePattern } from './superstruct';\n\n/**\n * UUIDv4 struct.\n */\nexport const UuidStruct = definePattern(\n  'UuidV4',\n  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,\n);\n\n/**\n * Validates if a given value is a valid URL.\n *\n * @param value - The value to be validated.\n * @returns A boolean indicating if the value is a valid URL.\n */\nexport const UrlStruct = define<string>('Url', (value: unknown) => {\n  try {\n    const url = new URL(value as string);\n    return url.protocol === 'http:' || url.protocol === 'https:';\n  } catch (_) {\n    return false;\n  }\n});\n\n/**\n * A string which contains a positive float number.\n */\nexport const StringNumberStruct = definePattern(\n  'StringNumber',\n  /^\\d+(\\.\\d+)?$/u,\n);\nexport type StringNumber = Infer<typeof StringNumberStruct>;\n"]}