@rango-dev/wallets-react 0.0.0-experimental-99f1781b-20260920 → 0.0.0-experimental-a84f27a7-20260921

package/dist/errors.d.ts

@@ -1,60 +0,0 @@
-import type { NamespaceInputForConnect } from './legacy/types.js';
-import type { Option, Result } from 'ts-results';
-import { WalletConnectionError } from '@hub3js/std/utils';
-export type WalletConnectionAttemptErrorOptions = {
-    errors: unknown[];
-    requestedNamespaces: NamespaceInputForConnect[];
-    message?: string;
-};
-/**
- * A connection attempt that failed.
- *
- * - `errors` holds every failed namespace's `WalletConnectionError`, in request order,
- *   followed by any other value thrown during the attempt.
- * - `requestedNamespaces` lists every namespace the attempt requested, in request
- *   order, cancelled ones included, with the network and derivation path passed for it.
- * - `message` is the `message` passed in, or else the first entry's.
- *
- * It has no `code` and no `cause`: read them from each entry.
- */
-export declare class WalletConnectionAttemptError extends AggregateError {
-    name: string;
-    errors: unknown[];
-    readonly requestedNamespaces: NamespaceInputForConnect[];
-    constructor(options: WalletConnectionAttemptErrorOptions);
-}
-/**
- * An auto-connect attempt that failed. Auto-connect sends it with
- * `Events.AUTO_CONNECT_FAILED`.
- */
-export declare class AutoConnectionAttemptError extends WalletConnectionAttemptError {
-    name: string;
-}
-export type NamespaceConnectAttempt<T = unknown> = {
-    input: NamespaceInputForConnect;
-    result: Result<T, unknown>;
-    cancelled?: boolean;
-};
-/**
- * Lists each failed namespace's `WalletConnectionError` in request order, leaving
- * cancelled namespaces out. A failure that isn't one yet (e.g. from an integrator's
- * provider, or a before-hook) is wrapped in one for its namespace.
- */
-export declare function collectConnectionFailures(attempts: NamespaceConnectAttempt[]): WalletConnectionError[];
-/**
- * Builds the error `connect` throws, or returns `undefined` when every namespace
- * connected and nothing else was thrown. `nonNamespaceError` holds the value thrown
- * outside any namespace, if any, such as a config error; it's added after the
- * namespace failures, unchanged.
- */
-export declare function buildConnectionAttemptError(params: {
-    requestedNamespaces: NamespaceInputForConnect[];
-    attempts: NamespaceConnectAttempt[];
-    nonNamespaceError: Option<unknown>;
-}): WalletConnectionAttemptError | undefined;
-/**
- * Builds the value of `Events.AUTO_CONNECT_FAILED` from the namespaces auto-connect
- * tried to connect for a wallet. Returns `undefined` when none of them failed.
- */
-export declare function buildAutoConnectionAttemptError(attempts: NamespaceConnectAttempt[]): AutoConnectionAttemptError | undefined;
-//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,MAAM,MAAM,mCAAmC,GAAG;IAChD,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,mBAAmB,EAAE,wBAAwB,EAAE,CAAC;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAcF;;;;;;;;;;GAUG;AACH,qBAAa,4BAA6B,SAAQ,cAAc;IAC9D,IAAI,SAAkC;IAC9B,MAAM,EAAE,OAAO,EAAE,CAAC;IAC1B,QAAQ,CAAC,mBAAmB,EAAE,wBAAwB,EAAE,CAAC;gBAE7C,OAAO,EAAE,mCAAmC;CAKzD;AAED;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,4BAA4B;IAC1E,IAAI,SAAgC;CACrC;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,GAAG,OAAO,IAAI;IACjD,KAAK,EAAE,wBAAwB,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAE3B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,uBAAuB,EAAE,GAClC,qBAAqB,EAAE,CAczB;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAClD,mBAAmB,EAAE,wBAAwB,EAAE,CAAC;IAChD,QAAQ,EAAE,uBAAuB,EAAE,CAAC;IACpC,iBAAiB,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;CACpC,GAAG,4BAA4B,GAAG,SAAS,CAW3C;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,uBAAuB,EAAE,GAClC,0BAA0B,GAAG,SAAS,CAUxC"}

package/dist/errors.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=errors.test.d.ts.map

package/dist/errors.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.test.d.ts","sourceRoot":"","sources":["../src/errors.test.ts"],"names":[],"mappings":""}

package/dist/hub/autoConnect.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=autoConnect.test.d.ts.map

package/dist/hub/autoConnect.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"autoConnect.test.d.ts","sourceRoot":"","sources":["../../src/hub/autoConnect.test.ts"],"names":[],"mappings":""}

package/dist/hub/helpers.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=helpers.test.d.ts.map

package/dist/hub/helpers.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.test.d.ts","sourceRoot":"","sources":["../../src/hub/helpers.test.ts"],"names":[],"mappings":""}

package/dist/hub/useHubAdapter.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=useHubAdapter.test.d.ts.map

package/dist/hub/useHubAdapter.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHubAdapter.test.d.ts","sourceRoot":"","sources":["../../src/hub/useHubAdapter.test.ts"],"names":[],"mappings":""}

package/src/errors.test.ts

@@ -1,349 +0,0 @@
-import type { NamespaceInputForConnect } from './legacy/types.js';
-
-import {
-  USER_REJECTION_ERROR_CODE,
-  WalletConnectionError,
-} from '@hub3js/std/utils';
-import { Err, None, Ok, Some } from 'ts-results';
-import { describe, expect, it } from 'vitest';
-
-import {
-  AutoConnectionAttemptError,
-  buildAutoConnectionAttemptError,
-  buildConnectionAttemptError,
-  WalletConnectionAttemptError,
-} from './errors.js';
-
-const connected = new Ok({ accounts: [], network: null });
-
-const SOLANA_DERIVATION_PATH = "m/44'/501'/0'/0'";
-const evm: NamespaceInputForConnect = { namespace: 'EVM', network: 'ETH' };
-const solana: NamespaceInputForConnect = {
-  namespace: 'Solana',
-  network: undefined,
-  derivationPath: SOLANA_DERIVATION_PATH,
-};
-const sui: NamespaceInputForConnect = { namespace: 'Sui', network: undefined };
-const requestedNamespaces = [evm, solana, sui];
-
-function rejection() {
-  return Object.assign(new Error('User rejected the request.'), {
-    code: USER_REJECTION_ERROR_CODE,
-  });
-}
-
-describe('WalletConnectionAttemptError', () => {
-  it('keep its entries and requested namespaces', () => {
-    const entry = new Error('EVM failed');
-
-    const error = new WalletConnectionAttemptError({
-      errors: [entry],
-      requestedNamespaces,
-    });
-
-    expect(error).toBeInstanceOf(AggregateError);
-    expect(error.errors).toEqual([entry]);
-    expect(error.errors[0]).toBe(entry);
-    expect(error.requestedNamespaces).toEqual(requestedNamespaces);
-  });
-
-  it('take its message from the first entry', () => {
-    const error = new WalletConnectionAttemptError({
-      errors: [new Error('first'), new Error('second')],
-      requestedNamespaces: [],
-    });
-
-    expect(error.message).toBe('first');
-  });
-
-  it('use the string form of a first entry without a string message', () => {
-    expect(
-      new WalletConnectionAttemptError({
-        errors: ['thrown string'],
-        requestedNamespaces: [],
-      }).message
-    ).toBe('thrown string');
-    expect(
-      new WalletConnectionAttemptError({
-        errors: [{ message: 123 }],
-        requestedNamespaces: [],
-      }).message
-    ).toBe('[object Object]');
-    expect(
-      new WalletConnectionAttemptError({
-        errors: [undefined],
-        requestedNamespaces: [],
-      }).message
-    ).toBe('undefined');
-  });
-
-  it('prefer a message passed in over the first entry', () => {
-    const error = new WalletConnectionAttemptError({
-      errors: [new Error('first')],
-      requestedNamespaces: [],
-      message: 'Wallet connection still pending after 3 minutes',
-    });
-
-    expect(error.message).toBe(
-      'Wallet connection still pending after 3 minutes'
-    );
-  });
-
-  it('have an empty message with no entries and no message passed in', () => {
-    const error = new WalletConnectionAttemptError({
-      errors: [],
-      requestedNamespaces: [],
-    });
-
-    expect(error.message).toBe('');
-  });
-
-  it('have its own name instead of the aggregate error name', () => {
-    const error = new WalletConnectionAttemptError({
-      errors: [rejection()],
-      requestedNamespaces: [],
-    });
-
-    expect(error.name).toBe('WalletConnectionAttemptError');
-  });
-
-  it('have no code even when an entry has one', () => {
-    const error = new WalletConnectionAttemptError({
-      errors: [rejection()],
-      requestedNamespaces: [],
-    });
-
-    expect(error).not.toHaveProperty('code');
-  });
-
-  it('have no cause even when it has an entry', () => {
-    const error = new WalletConnectionAttemptError({
-      errors: [rejection()],
-      requestedNamespaces: [],
-    });
-
-    expect(error).not.toHaveProperty('cause');
-  });
-});
-
-describe('AutoConnectionAttemptError', () => {
-  it('extend the wallet connection attempt error with its own name', () => {
-    const entry = new Error('EVM failed');
-
-    const error = new AutoConnectionAttemptError({
-      errors: [entry],
-      requestedNamespaces: [{ namespace: 'EVM', network: 'ETH' }],
-    });
-
-    expect(error).toBeInstanceOf(WalletConnectionAttemptError);
-    expect(error.name).toBe('AutoConnectionAttemptError');
-    expect(error.message).toBe('EVM failed');
-    expect(error.errors).toEqual([entry]);
-    expect(error.requestedNamespaces).toEqual([
-      { namespace: 'EVM', network: 'ETH' },
-    ]);
-  });
-});
-
-describe('buildConnectionAttemptError', () => {
-  it('list every failed namespace in request order', () => {
-    const evmError = new WalletConnectionError({
-      namespace: 'EVM',
-      cause: new Error('EVM failed'),
-    });
-    const suiError = new WalletConnectionError({
-      namespace: 'Sui',
-      cause: new Error('Sui failed'),
-    });
-
-    const error = buildConnectionAttemptError({
-      requestedNamespaces,
-      attempts: [
-        { input: evm, result: new Err(evmError) },
-        { input: solana, result: connected },
-        { input: sui, result: new Err(suiError) },
-      ],
-      nonNamespaceError: None,
-    });
-
-    expect(error).toBeInstanceOf(WalletConnectionAttemptError);
-    expect(error?.errors).toEqual([evmError, suiError]);
-    expect(error?.errors[0]).toBe(evmError);
-    expect(error?.errors[1]).toBe(suiError);
-    expect(error?.message).toBe('EVM failed');
-  });
-
-  it('leave namespaces marked as cancelled out of errors', () => {
-    const rejectionError = rejection();
-
-    const error = buildConnectionAttemptError({
-      requestedNamespaces,
-      attempts: [
-        { input: evm, result: new Err(rejectionError) },
-        { input: solana, result: new Err(rejectionError), cancelled: true },
-        { input: sui, result: new Err(rejectionError), cancelled: true },
-      ],
-      nonNamespaceError: None,
-    });
-
-    expect(error?.errors).toHaveLength(1);
-    expect(error?.errors[0]).toMatchObject({ namespace: 'EVM' });
-  });
-
-  it('keep a failure that shares its error object with an earlier one when it is not cancelled', () => {
-    const sharedError = new Error('Wallet is not available');
-
-    const error = buildConnectionAttemptError({
-      requestedNamespaces,
-      attempts: [
-        { input: evm, result: new Err(sharedError) },
-        { input: solana, result: new Err(sharedError) },
-      ],
-      nonNamespaceError: None,
-    });
-
-    expect(error?.errors).toHaveLength(2);
-    expect(error?.errors[0]).toMatchObject({ namespace: 'EVM' });
-    expect(error?.errors[1]).toMatchObject({ namespace: 'Solana' });
-  });
-
-  it('wrap a failure that is not a wallet connection error in one for its namespace', () => {
-    const error = buildConnectionAttemptError({
-      requestedNamespaces,
-      attempts: [{ input: solana, result: new Err(rejection()) }],
-      nonNamespaceError: None,
-    });
-
-    const [entry] = error?.errors ?? [];
-    expect(entry).toBeInstanceOf(WalletConnectionError);
-    expect(entry).toMatchObject({
-      name: 'WalletConnectionError',
-      namespace: 'Solana',
-      message: 'User rejected the request.',
-    });
-  });
-
-  it('keep the raw failure as the cause of its wrapper and copy its code', () => {
-    const rawError = rejection();
-
-    const error = buildConnectionAttemptError({
-      requestedNamespaces,
-      attempts: [{ input: solana, result: new Err(rawError) }],
-      nonNamespaceError: None,
-    });
-
-    const [entry] = error?.errors ?? [];
-    expect((entry as WalletConnectionError).cause).toBe(rawError);
-    expect(entry).toMatchObject({ code: USER_REJECTION_ERROR_CODE });
-  });
-
-  it('wrap a thrown value that is not an error object for its namespace', () => {
-    const error = buildConnectionAttemptError({
-      requestedNamespaces,
-      attempts: [{ input: evm, result: new Err('User closed the popup') }],
-      nonNamespaceError: None,
-    });
-
-    const [entry] = error?.errors ?? [];
-    expect(entry).toBeInstanceOf(WalletConnectionError);
-    expect(entry).toMatchObject({
-      namespace: 'EVM',
-      message: 'User closed the popup',
-    });
-    expect((entry as WalletConnectionError).cause).toBe(
-      'User closed the popup'
-    );
-  });
-
-  it('add a value thrown outside any namespace after the namespace failures unchanged', () => {
-    const storageError = new Error('QuotaExceededError');
-
-    const error = buildConnectionAttemptError({
-      requestedNamespaces,
-      attempts: [
-        { input: evm, result: new Err(new Error('EVM failed')) },
-        { input: solana, result: connected },
-      ],
-      nonNamespaceError: new Some(storageError),
-    });
-
-    expect(error?.errors).toHaveLength(2);
-    expect(error?.errors[0]).toMatchObject({ namespace: 'EVM' });
-    expect(error?.errors[1]).toBe(storageError);
-  });
-
-  it('add a thrown undefined as an entry', () => {
-    const error = buildConnectionAttemptError({
-      requestedNamespaces,
-      attempts: [],
-      nonNamespaceError: new Some(undefined),
-    });
-
-    expect(error).toBeInstanceOf(WalletConnectionAttemptError);
-    expect(error?.errors).toEqual([undefined]);
-  });
-
-  it('return nothing when every namespace connected', () => {
-    expect(
-      buildConnectionAttemptError({
-        requestedNamespaces,
-        attempts: [
-          { input: evm, result: connected },
-          { input: solana, result: connected },
-        ],
-        nonNamespaceError: None,
-      })
-    ).toBeUndefined();
-  });
-
-  it('return an error with no entries when every namespace that did not connect was cancelled', () => {
-    const error = buildConnectionAttemptError({
-      requestedNamespaces,
-      attempts: [{ input: evm, result: new Err(rejection()), cancelled: true }],
-      nonNamespaceError: None,
-    });
-
-    expect(error).toBeInstanceOf(WalletConnectionAttemptError);
-    expect(error?.errors).toEqual([]);
-  });
-});
-
-describe('buildAutoConnectionAttemptError', () => {
-  it('return nothing when every attempted namespace connected', () => {
-    expect(
-      buildAutoConnectionAttemptError([
-        { input: evm, result: connected },
-        { input: sui, result: connected },
-      ])
-    ).toBeUndefined();
-  });
-
-  it('list the attempted namespaces with their networks', () => {
-    const error = buildAutoConnectionAttemptError([
-      { input: evm, result: connected },
-      { input: sui, result: new Err(new Error('Sui failed')) },
-    ]);
-
-    expect(error).toBeInstanceOf(AutoConnectionAttemptError);
-    expect(error?.requestedNamespaces).toEqual([
-      { namespace: 'EVM', network: 'ETH' },
-      { namespace: 'Sui', network: undefined },
-    ]);
-  });
-
-  it('wrap each failure in a wallet connection error for its namespace', () => {
-    const rawError = new Error('Sui failed');
-
-    const error = buildAutoConnectionAttemptError([
-      { input: evm, result: connected },
-      { input: sui, result: new Err(rawError) },
-    ]);
-
-    expect(error?.errors).toHaveLength(1);
-    expect(error?.errors[0]).toBeInstanceOf(WalletConnectionError);
-    expect(error?.errors[0]).toMatchObject({
-      namespace: 'Sui',
-      cause: rawError,
-    });
-  });
-});

package/src/errors.ts

@@ -1,124 +0,0 @@
-import type { NamespaceInputForConnect } from './legacy/types.js';
-import type { Option, Result } from 'ts-results';
-
-import { WalletConnectionError } from '@hub3js/std/utils';
-
-export type WalletConnectionAttemptErrorOptions = {
-  errors: unknown[];
-  requestedNamespaces: NamespaceInputForConnect[];
-  message?: string;
-};
-
-function messageOf(value: unknown): string {
-  if (
-    typeof value === 'object' &&
-    value !== null &&
-    'message' in value &&
-    typeof value.message === 'string'
-  ) {
-    return value.message;
-  }
-  return String(value);
-}
-
-/**
- * A connection attempt that failed.
- *
- * - `errors` holds every failed namespace's `WalletConnectionError`, in request order,
- *   followed by any other value thrown during the attempt.
- * - `requestedNamespaces` lists every namespace the attempt requested, in request
- *   order, cancelled ones included, with the network and derivation path passed for it.
- * - `message` is the `message` passed in, or else the first entry's.
- *
- * It has no `code` and no `cause`: read them from each entry.
- */
-export class WalletConnectionAttemptError extends AggregateError {
-  name = 'WalletConnectionAttemptError';
-  declare errors: unknown[];
-  readonly requestedNamespaces: NamespaceInputForConnect[];
-
-  constructor(options: WalletConnectionAttemptErrorOptions) {
-    const { errors, requestedNamespaces, message } = options;
-    super(errors, message ?? (errors.length > 0 ? messageOf(errors[0]) : ''));
-    this.requestedNamespaces = requestedNamespaces;
-  }
-}
-
-/**
- * An auto-connect attempt that failed. Auto-connect sends it with
- * `Events.AUTO_CONNECT_FAILED`.
- */
-export class AutoConnectionAttemptError extends WalletConnectionAttemptError {
-  name = 'AutoConnectionAttemptError';
-}
-
-export type NamespaceConnectAttempt<T = unknown> = {
-  input: NamespaceInputForConnect;
-  result: Result<T, unknown>;
-  // The connect queue abandoned the namespace after another one was rejected.
-  cancelled?: boolean;
-};
-
-/**
- * Lists each failed namespace's `WalletConnectionError` in request order, leaving
- * cancelled namespaces out. A failure that isn't one yet (e.g. from an integrator's
- * provider, or a before-hook) is wrapped in one for its namespace.
- */
-export function collectConnectionFailures(
-  attempts: NamespaceConnectAttempt[]
-): WalletConnectionError[] {
-  return attempts.flatMap(({ input, result, cancelled }) => {
-    if (cancelled || result.ok) {
-      return [];
-    }
-    return result.val instanceof WalletConnectionError
-      ? [result.val]
-      : [
-          new WalletConnectionError({
-            namespace: input.namespace,
-            cause: result.val,
-          }),
-        ];
-  });
-}
-
-/**
- * Builds the error `connect` throws, or returns `undefined` when every namespace
- * connected and nothing else was thrown. `nonNamespaceError` holds the value thrown
- * outside any namespace, if any, such as a config error; it's added after the
- * namespace failures, unchanged.
- */
-export function buildConnectionAttemptError(params: {
-  requestedNamespaces: NamespaceInputForConnect[];
-  attempts: NamespaceConnectAttempt[];
-  nonNamespaceError: Option<unknown>;
-}): WalletConnectionAttemptError | undefined {
-  const { requestedNamespaces, attempts, nonNamespaceError } = params;
-  if (attempts.every(({ result }) => result.ok) && nonNamespaceError.none) {
-    return undefined;
-  }
-
-  const errors: unknown[] = collectConnectionFailures(attempts);
-  if (nonNamespaceError.some) {
-    errors.push(nonNamespaceError.val);
-  }
-  return new WalletConnectionAttemptError({ errors, requestedNamespaces });
-}
-
-/**
- * Builds the value of `Events.AUTO_CONNECT_FAILED` from the namespaces auto-connect
- * tried to connect for a wallet. Returns `undefined` when none of them failed.
- */
-export function buildAutoConnectionAttemptError(
-  attempts: NamespaceConnectAttempt[]
-): AutoConnectionAttemptError | undefined {
-  const errors = collectConnectionFailures(attempts);
-  if (!errors.length) {
-    return undefined;
-  }
-
-  return new AutoConnectionAttemptError({
-    errors,
-    requestedNamespaces: attempts.map(({ input }) => input),
-  });
-}