@dynamic-labs/wallet-book 4.25.5 → 4.25.6

package/src/schemas/walletGroup.cjs

@@ -3,25 +3,44 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var zod = require('zod');
+var z = require('zod/mini');
 var nonEmptyString = require('./utils/nonEmptyString.cjs');
 var walletSchema = require('./walletSchema.cjs');
 
-const WalletOverrideEntrySchema = zod.z.object({
-    brand: walletSchema.brandSchema.optional(),
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespace(z);
+
+// eslint-disable-next-line import/no-extraneous-dependencies, import/no-namespace
+const WalletOverrideEntrySchema = z__namespace.object({
+    brand: z__namespace.optional(walletSchema.brandSchema),
     name: nonEmptyString.nonEmptyString,
 });
-const walletGroupSchema = zod.z.object({
-    brand: zod.z
-        .object({
+const walletGroupSchema = z__namespace.object({
+    brand: z__namespace.optional(z__namespace.object({
         alt: nonEmptyString.nonEmptyString,
         primaryColor: nonEmptyString.nonEmptyString,
         spriteId: nonEmptyString.nonEmptyString,
-    })
-        .optional(),
-    key: zod.z.string(),
-    name: zod.z.string(),
-    walletOverrides: zod.z.record(WalletOverrideEntrySchema).optional(),
+    })),
+    key: z__namespace.string(),
+    name: z__namespace.string(),
+    walletOverrides: z__namespace.optional(z__namespace.record(z__namespace.string(), WalletOverrideEntrySchema)),
 });
 
 exports.walletGroupSchema = walletGroupSchema;

package/src/schemas/walletGroup.d.ts

@@ -1,113 +1,29 @@
-import { z } from 'zod';
-declare const WalletOverrideEntrySchema: z.ZodObject<{
-    brand: z.ZodOptional<z.ZodObject<{
-        alt: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-        primaryColor: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-        spriteId: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-    }, "strip", z.ZodTypeAny, {
-        alt?: string | undefined;
-        primaryColor?: string | undefined;
-        spriteId?: string | undefined;
-    }, {
-        alt?: unknown;
-        primaryColor?: unknown;
-        spriteId?: unknown;
-    }>>;
-    name: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-}, "strip", z.ZodTypeAny, {
-    brand?: {
-        alt?: string | undefined;
-        primaryColor?: string | undefined;
-        spriteId?: string | undefined;
-    } | undefined;
-    name?: string | undefined;
-}, {
-    brand?: {
-        alt?: unknown;
-        primaryColor?: unknown;
-        spriteId?: unknown;
-    } | undefined;
-    name?: unknown;
-}>;
-export declare const walletGroupSchema: z.ZodObject<{
-    brand: z.ZodOptional<z.ZodObject<{
-        alt: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-        primaryColor: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-        spriteId: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-    }, "strip", z.ZodTypeAny, {
-        alt?: string | undefined;
-        primaryColor?: string | undefined;
-        spriteId?: string | undefined;
-    }, {
-        alt?: unknown;
-        primaryColor?: unknown;
-        spriteId?: unknown;
-    }>>;
-    key: z.ZodString;
-    name: z.ZodString;
-    walletOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        brand: z.ZodOptional<z.ZodObject<{
-            alt: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-            primaryColor: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-            spriteId: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-        }, "strip", z.ZodTypeAny, {
-            alt?: string | undefined;
-            primaryColor?: string | undefined;
-            spriteId?: string | undefined;
-        }, {
-            alt?: unknown;
-            primaryColor?: unknown;
-            spriteId?: unknown;
-        }>>;
-        name: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, unknown>;
-    }, "strip", z.ZodTypeAny, {
-        brand?: {
-            alt?: string | undefined;
-            primaryColor?: string | undefined;
-            spriteId?: string | undefined;
-        } | undefined;
-        name?: string | undefined;
-    }, {
-        brand?: {
-            alt?: unknown;
-            primaryColor?: unknown;
-            spriteId?: unknown;
-        } | undefined;
-        name?: unknown;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    key: string;
-    brand?: {
-        alt?: string | undefined;
-        primaryColor?: string | undefined;
-        spriteId?: string | undefined;
-    } | undefined;
-    walletOverrides?: Record<string, {
-        brand?: {
-            alt?: string | undefined;
-            primaryColor?: string | undefined;
-            spriteId?: string | undefined;
-        } | undefined;
-        name?: string | undefined;
-    }> | undefined;
-}, {
-    name: string;
-    key: string;
-    brand?: {
-        alt?: unknown;
-        primaryColor?: unknown;
-        spriteId?: unknown;
-    } | undefined;
-    walletOverrides?: Record<string, {
-        brand?: {
-            alt?: unknown;
-            primaryColor?: unknown;
-            spriteId?: unknown;
-        } | undefined;
-        name?: unknown;
-    }> | undefined;
-}>;
+import * as z from 'zod/mini';
+declare const WalletOverrideEntrySchema: z.ZodMiniObject<{
+    brand: z.ZodMiniOptional<z.ZodMiniObject<{
+        alt: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+        primaryColor: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+        spriteId: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+    }, z.core.$strip>>;
+    name: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+}, z.core.$strip>;
+export declare const walletGroupSchema: z.ZodMiniObject<{
+    brand: z.ZodMiniOptional<z.ZodMiniObject<{
+        alt: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+        primaryColor: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+        spriteId: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+    }, z.core.$strip>>;
+    key: z.ZodMiniString<string>;
+    name: z.ZodMiniString<string>;
+    walletOverrides: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+        brand: z.ZodMiniOptional<z.ZodMiniObject<{
+            alt: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+            primaryColor: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+            spriteId: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+        }, z.core.$strip>>;
+        name: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTransform<{} | undefined, unknown>, z.ZodMiniOptional<z.ZodMiniString<string>>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export type WalletGroupSchema = z.infer<typeof walletGroupSchema>;
 export type WalletGroupOverride = z.infer<typeof WalletOverrideEntrySchema>;
 export {};

package/src/schemas/walletGroup.js

@@ -1,23 +1,22 @@
 'use client'
-import { z } from 'zod';
+import * as z from 'zod/mini';
 import { nonEmptyString } from './utils/nonEmptyString.js';
 import { brandSchema } from './walletSchema.js';
 
+// eslint-disable-next-line import/no-extraneous-dependencies, import/no-namespace
 const WalletOverrideEntrySchema = z.object({
-    brand: brandSchema.optional(),
+    brand: z.optional(brandSchema),
     name: nonEmptyString,
 });
 const walletGroupSchema = z.object({
-    brand: z
-        .object({
+    brand: z.optional(z.object({
         alt: nonEmptyString,
         primaryColor: nonEmptyString,
         spriteId: nonEmptyString,
-    })
-        .optional(),
+    })),
     key: z.string(),
     name: z.string(),
-    walletOverrides: z.record(WalletOverrideEntrySchema).optional(),
+    walletOverrides: z.optional(z.record(z.string(), WalletOverrideEntrySchema)),
 });
 
 export { walletGroupSchema };

package/src/schemas/walletSchema.cjs

@@ -3,7 +3,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var zod = require('zod');
+var z = require('zod/mini');
 var filterEmptyObject = require('./utils/filterEmptyObject.cjs');
 var nonEmptyString = require('./utils/nonEmptyString.cjs');
 var nonEmptyStringArray = require('./utils/nonEmptyStringArray.cjs');
@@ -13,36 +13,50 @@ var transformEdgeExtensionId = require('./utils/transformEdgeExtensionId.cjs');
 var transformFirefoxExtensionId = require('./utils/transformFirefoxExtensionId.cjs');
 var transformIosId = require('./utils/transformIosId.cjs');
 
-const injectedConfigSchema = zod.z.object({
-    chain: zod.z.string(),
-    extensionLocators: zod.z.array(zod.z.object({
-        flag: zod.z.string(),
-        value: zod.z.boolean().optional().default(true),
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespace(z);
+
+// eslint-disable-next-line import/no-extraneous-dependencies, import/no-namespace
+const injectedConfigSchema = z__namespace.object({
+    chain: z__namespace.string(),
+    extensionLocators: z__namespace.array(z__namespace.object({
+        flag: z__namespace.string(),
+        value: z__namespace._default(z__namespace.optional(z__namespace.boolean()), true),
     })),
     /**
      * Allows declaring which interface, if any, this wallet's implementation follows
      * ex. Leather with https://btckit.org/
      */
-    providerInterface: zod.z.string().optional(),
+    providerInterface: z__namespace.optional(z__namespace.string()),
     /**
      * Allows declaring that this wallet is discoverable through the the Wallet Standard
      * See https://github.com/wallet-standard/wallet-standard
      * Also allows ignoring wallets that don't support the provided features
      */
-    walletStandard: zod.z
-        .object({
-        features: zod.z.array(zod.z.string()),
-        name: zod.z.string(),
-        providerId: zod.z.string().optional(),
-    })
-        .optional(),
-    walletStandardLocators: zod.z
-        .array(zod.z.object({ locator: zod.z.string(), name: zod.z.string() }))
-        .optional(),
-    windowLocations: zod.z
-        .array(zod.z.string())
-        .optional()
-        .refine((val) => {
+    walletStandard: z__namespace.optional(z__namespace.object({
+        features: z__namespace.array(z__namespace.string()),
+        name: z__namespace.string(),
+        providerId: z__namespace.optional(z__namespace.string()),
+    })),
+    walletStandardLocators: z__namespace.optional(z__namespace.array(z__namespace.object({ locator: z__namespace.string(), name: z__namespace.string() }))),
+    windowLocations: z__namespace.optional(z__namespace.array(z__namespace.string())).check(z__namespace.refine((val) => {
         if (!val)
             return true;
         if (!val.some((v) => ['ethereum', 'ethereum.providers'].includes(v)))
@@ -51,87 +65,70 @@ const injectedConfigSchema = zod.z.object({
     }, {
         message: 'windowLocations cannot include ethereum or ethereum.providers as they are included by default',
         path: ['config'],
-    }),
+    })),
 });
-const brandSchema = zod.z.object({
+const brandSchema = z__namespace.object({
     alt: nonEmptyString.nonEmptyString,
     primaryColor: nonEmptyString.nonEmptyString,
     spriteId: nonEmptyString.nonEmptyString,
 });
-const walletSchema = zod.z
-    .preprocess((val) => val, zod.z.object({
-    brand: brandSchema.optional(),
-    chainGroup: zod.z.string().optional(),
-    chains: zod.z.array(zod.z.string()).optional(),
-    desktop: zod.z
-        .object({
-        chromeId: nonEmptyString.nonEmptyString.transform(transformChromeExtensionId.transformChromeExtensionId),
-        edgeId: nonEmptyString.nonEmptyString.transform(transformEdgeExtensionId.transformEdgeExtensionId),
-        firefoxId: nonEmptyString.nonEmptyString.transform(transformFirefoxExtensionId.transformFirefoxExtensionId),
+const walletSchema = z__namespace.pipe(z__namespace.pipe(z__namespace.transform((val) => val), z__namespace.object({
+    brand: z__namespace.optional(brandSchema),
+    chainGroup: z__namespace.optional(z__namespace.string()),
+    chains: z__namespace.optional(z__namespace.array(z__namespace.string())),
+    desktop: z__namespace.optional(z__namespace.pipe(z__namespace.object({
+        chromeId: z__namespace.optional(z__namespace.pipe(nonEmptyString.nonEmptyString, z__namespace.transform(transformChromeExtensionId.transformChromeExtensionId))),
+        edgeId: z__namespace.optional(z__namespace.pipe(nonEmptyString.nonEmptyString, z__namespace.transform(transformEdgeExtensionId.transformEdgeExtensionId))),
+        firefoxId: z__namespace.optional(z__namespace.pipe(nonEmptyString.nonEmptyString, z__namespace.transform(transformFirefoxExtensionId.transformFirefoxExtensionId))),
         native: nonEmptyString.nonEmptyString,
         operaId: nonEmptyString.nonEmptyString,
         safariId: nonEmptyString.nonEmptyString,
         universal: nonEmptyString.nonEmptyString,
-    })
-        .optional()
-        .transform(filterEmptyObject.filterEmptyObject),
-    eip6963Config: zod.z.object({ rdns: zod.z.string() }).optional(),
-    filterFromWalletConnect: zod.z.boolean().optional(),
-    group: zod.z.string().optional(),
+    }), z__namespace.transform(filterEmptyObject.filterEmptyObject))),
+    eip6963Config: z__namespace.optional(z__namespace.object({ rdns: z__namespace.string() })),
+    filterFromWalletConnect: z__namespace.optional(z__namespace.boolean()),
+    group: z__namespace.optional(z__namespace.string()),
     /**
      * Indicates which hardware wallets are enabled for this wallet
      */
-    hardwareWallets: zod.z.array(zod.z.string()).optional(),
-    injectedConfig: zod.z.array(injectedConfigSchema).optional(),
-    mobile: zod.z
-        .object({
-        android: zod.string().nullish(),
-        androidId: nonEmptyString.nonEmptyString.transform(transformAndroidId.transformAndroidId),
+    hardwareWallets: z__namespace.optional(z__namespace.array(z__namespace.string())),
+    injectedConfig: z__namespace.optional(z__namespace.array(injectedConfigSchema)),
+    mobile: z__namespace.optional(z__namespace.pipe(z__namespace.optional(z__namespace.object({
+        android: z__namespace.nullish(z__namespace.string()),
+        androidId: z__namespace.optional(z__namespace.pipe(nonEmptyString.nonEmptyString, z__namespace.transform(transformAndroidId.transformAndroidId))),
         /**
          * @deprecated Use inAppBrowserV2 instead for EVM wallet deep linking
          */
-        inAppBrowser: zod.string().nullish(),
-        inAppBrowserV2: zod.string().nullish(),
-        ios: zod.string().nullish(),
-        iosId: nonEmptyString.nonEmptyString.transform(transformIosId.transformIosId),
+        inAppBrowser: z__namespace.nullish(z__namespace.string()),
+        inAppBrowserV2: z__namespace.nullish(z__namespace.string()),
+        ios: z__namespace.nullish(z__namespace.string()),
+        iosId: z__namespace.optional(z__namespace.pipe(nonEmptyString.nonEmptyString, z__namespace.transform(transformIosId.transformIosId))),
         native: nonEmptyString.nonEmptyString,
         universal: nonEmptyString.nonEmptyString,
-    })
-        .optional()
-        .transform(filterEmptyObject.filterEmptyObject),
-    mobileExperience: zod.z.enum(['in-app-browser', 'redirect']).optional(),
-    name: zod.z.string(),
+    })), z__namespace.transform(filterEmptyObject.filterEmptyObject))),
+    mobileExperience: z__namespace.optional(z__namespace.enum(['in-app-browser', 'redirect'])),
+    name: z__namespace.string(),
     shortName: nonEmptyString.nonEmptyString,
-    showOnlyIfInstalled: zod.z.boolean().optional(),
-    switchNetworkOnlyFromWallet: zod.z.boolean().optional(),
-    walletConnect: zod.z
-        .object({
+    showOnlyIfInstalled: z__namespace.optional(z__namespace.boolean()),
+    switchNetworkOnlyFromWallet: z__namespace.optional(z__namespace.boolean()),
+    walletConnect: z__namespace.optional(z__namespace.pipe(z__namespace.optional(z__namespace.object({
         sdks: nonEmptyStringArray.nonEmptyStringArray,
-    })
-        .optional()
-        .transform(filterEmptyObject.filterEmptyObject),
-    walletGroup: zod.z.string().optional(),
+    })), z__namespace.transform(filterEmptyObject.filterEmptyObject))),
+    walletGroup: z__namespace.optional(z__namespace.string()),
     /**
      * Indicates which connector methods/events are not supported, keyed by wallet type
      */
-    walletLimitations: zod.z
-        .object({
-        browserExtension: zod.z
-            .object({
-            unsupportedEvents: zod.z.array(zod.z.string()).optional(),
-            unsupportedMethods: zod.z.array(zod.z.string()).optional(),
-        })
-            .optional(),
-        mobile: zod.z
-            .object({
-            unsupportedEvents: zod.z.array(zod.z.string()).optional(),
-            unsupportedMethods: zod.z.array(zod.z.string()).optional(),
-        })
-            .optional(),
-    })
-        .optional(),
-}))
-    .transform((val) => {
+    walletLimitations: z__namespace.optional(z__namespace.object({
+        browserExtension: z__namespace.optional(z__namespace.object({
+            unsupportedEvents: z__namespace.optional(z__namespace.array(z__namespace.string())),
+            unsupportedMethods: z__namespace.optional(z__namespace.array(z__namespace.string())),
+        })),
+        mobile: z__namespace.optional(z__namespace.object({
+            unsupportedEvents: z__namespace.optional(z__namespace.array(z__namespace.string())),
+            unsupportedMethods: z__namespace.optional(z__namespace.array(z__namespace.string())),
+        })),
+    })),
+})), z__namespace.transform((val) => {
     var _a, _b, _c, _d, _e, _f;
     if (val.group) {
         val.chainGroup = val.group;
@@ -143,7 +140,7 @@ const walletSchema = zod.z
         (_f = val.mobile) === null || _f === void 0 ? true : delete _f.android;
     }
     return val;
-});
+}));
 
 exports.brandSchema = brandSchema;
 exports.walletSchema = walletSchema;