feat: add exactOptional support in type struct (#38)

Add support of `exactOptional` with `superstruct.type`.

We plan to use `@metamask/superstruct` in `@metamask/keyring-api` and we
already use the combo `type` + `exactOptional` (our implementation)
there.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Low Risk**
> Small, localized change to `type()` entry iteration aligned with
existing `object()` semantics; covered by new tests with no auth or
data-path impact.
> 
> **Overview**
> Extends **`type()`** so **`exactOptional()`** fields behave like
TypeScript’s optional properties: the key may be **missing**, but an
explicit **`undefined`** value is still validated and rejected.
> 
> The **`type()`** `entries` generator now skips properties wrapped in
**`exactOptional`** when the key is **not** on the object
(`hasOwnProperty`), matching the existing **`object()`** behavior.
> 
> Adds typing coverage for **`type` + `exactOptional`**, plus validation
fixtures for absent keys, present values, and **`age: undefined`**
failing validation.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
e49b9ff. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: ccharly

src/structs/types.ts

@@ -684,6 +684,12 @@ export function type<Schema extends ObjectSchema>(
     *entries(value) {
       if (isObject(value)) {
         for (const k of keys) {
+          if (
+            ExactOptionalStruct.isExactOptional(schema[k]) &&
+            !Object.prototype.hasOwnProperty.call(value, k)
+          ) {
+            continue;
+          }
           yield [k, value[k], schema[k] as Struct<any>];
         }
       }

test/typings/exactOptional.ts

@@ -4,6 +4,7 @@ import {
   string,
   number,
   object,
+  type,
   enums,
   never,
   record,
@@ -60,3 +61,17 @@ test<{
   );
   return value;
 });
+
+test<{
+  a?: number;
+  b: string;
+}>((value) => {
+  assert(
+    value,
+    type({
+      a: exactOptional(number()),
+      b: string(),
+    }),
+  );
+  return value;
+});

test/validation/type/invalid-exact-optional-undefined.ts

@@ -0,0 +1,21 @@
+import { type, exactOptional, string, number } from '../../../src';
+
+export const Struct = type({
+  name: string(),
+  age: exactOptional(number()),
+});
+
+export const data = {
+  name: 'john',
+  age: undefined,
+};
+
+export const failures = [
+  {
+    value: undefined,
+    type: 'number',
+    refinement: undefined,
+    path: ['age'],
+    branch: [data, data.age],
+  },
+];

test/validation/type/valid-exact-optional-absent.ts

@@ -0,0 +1,12 @@
+import { type, exactOptional, string, number } from '../../../src';
+
+export const Struct = type({
+  name: string(),
+  age: exactOptional(number()),
+});
+
+export const data = {
+  name: 'john',
+};
+
+export const output = data;

test/validation/type/valid-exact-optional-present.ts

@@ -0,0 +1,13 @@
+import { type, exactOptional, string, number } from '../../../src';
+
+export const Struct = type({
+  name: string(),
+  age: exactOptional(number()),
+});
+
+export const data = {
+  name: 'john',
+  age: 42,
+};
+
+export const output = data;