@getpara/graz-connector 2.0.0-dev.11 → 2.0.0

package/__tests__/connector.test.tsx

@@ -1,491 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { ParaGrazConnector, ParaGrazConfig, ParaOfflineSigner } from '../src/connector';
-import type { SignDoc } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
-import ParaWeb from '@getpara/react-sdk';
-import { renderModal } from '../src/connectorModal.js';
-
-vi.mock('styled-components', () => ({
-  default: {
-    div: () => 'div',
-    button: () => 'button',
-    a: () => 'a',
-    span: () => 'span',
-    input: () => 'input',
-    form: () => 'form',
-  },
-  createGlobalStyle: vi.fn(),
-  css: vi.fn(),
-  keyframes: vi.fn(),
-  ThemeProvider: vi.fn(),
-}));
-
-const mockParaWebInstance = {
-  isFullyLoggedIn: vi.fn().mockResolvedValue(false),
-  getWalletsByType: vi.fn().mockReturnValue([]),
-  logout: vi.fn().mockResolvedValue(undefined),
-};
-
-vi.mock('@getpara/react-sdk', () => ({
-  __esModule: true,
-  default: vi.fn(() => mockParaWebInstance),
-  Environment: { BETA: 'BETA', DEVELOPMENT: 'DEV', PRODUCTION: 'PROD' },
-  ParaModal: vi.fn(props => ({ type: 'div', props })),
-}));
-
-import type { AccountData, AminoSignResponse, StdSignDoc } from '@keplr-wallet/types';
-import type { DirectSignResponse } from '@cosmjs/proto-signing';
-import Long from 'long';
-
-function createProtoSignerMock() {
-  const directRes: DirectSignResponse = {
-    signed: {
-      bodyBytes: new Uint8Array(),
-      authInfoBytes: new Uint8Array(),
-      chainId: 'chain-1',
-      accountNumber: Long.fromString('0'),
-    },
-    signature: {
-      pub_key: { type: 'tendermint/PubKeySecp256k1', value: 'pk' },
-      signature: 'proto-sig',
-    },
-  };
-  return {
-    getAccounts: vi.fn().mockResolvedValue([account as unknown as AccountData]),
-    signDirect: vi.fn().mockResolvedValue(directRes),
-  };
-}
-
-function createAminoSignerMock() {
-  const aminoRes: AminoSignResponse = {
-    signed: {
-      chain_id: 'chain-1',
-      account_number: '0',
-      sequence: '0',
-      fee: { amount: [], gas: '0' },
-      msgs: [],
-      memo: '',
-    },
-    signature: {
-      pub_key: { type: 'tendermint/PubKeySecp256k1', value: 'pk' },
-      signature: 'amino-sig',
-    },
-  };
-  return {
-    getAccounts: vi.fn().mockResolvedValue([account as unknown as AccountData]),
-    signAmino: vi.fn().mockResolvedValue(aminoRes),
-  };
-}
-
-vi.mock('@getpara/cosmjs-v0-integration', () => ({
-  __esModule: true,
-  ParaAminoSigner: vi.fn(() => createAminoSignerMock()),
-  ParaProtoSigner: vi.fn(() => createProtoSignerMock()),
-}));
-
-vi.mock('long', () => ({ __esModule: true, default: { fromString: vi.fn().mockReturnValue({ toString: () => '1' }) } }));
-vi.mock('@cosmjs/encoding', () => ({
-  __esModule: true,
-  fromBech32: vi.fn().mockReturnValue({ data: new Uint8Array([1, 2, 3]) }),
-}));
-vi.mock('../src/connectorModal.js', () => ({ __esModule: true, renderModal: vi.fn() }));
-
-const account: AccountData = { address: 'test1qqq', algo: 'secp256k1', pubkey: new Uint8Array([9]) };
-const wallet = { id: 'wallet-1', type: 'COSMOS' } as const;
-const chains = [{ chainId: 'chain-1', bech32Config: { bech32PrefixAccAddr: 'pref' } }] as any;
-
-function cfg(p: Partial<ParaGrazConfig> = {}): ParaGrazConfig {
-  return { paraWeb: mockParaWebInstance as any, ...p };
-}
-function newConnector(conf: Partial<ParaGrazConfig> = {}, cs = chains) {
-  return new ParaGrazConnector(cfg(conf), cs);
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(false);
-  mockParaWebInstance.getWalletsByType.mockReturnValue([]);
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-});
-
-describe('ParaGrazConnector', () => {
-  describe('constructor', () => {
-    it('constructs with valid config', () => {
-      expect(() => newConnector()).not.toThrow();
-    });
-
-    it('constructor validation errors', () => {
-      expect(() => newConnector({ paraWeb: undefined as any })).toThrow('Para connector: missing paraWeb instance in config');
-    });
-  });
-
-  describe('getBech32Prefix', () => {
-    it('returns correct prefix for known chain', () => {
-      expect(newConnector().getBech32Prefix('chain-1')).toBe('pref');
-    });
-    it('returns default prefix for unknown chain', () => {
-      expect(newConnector().getBech32Prefix('x')).toBe('cosmos');
-    });
-    it('returns default prefix when chains is null', () => {
-      expect(new ParaGrazConnector(cfg(), null).getBech32Prefix('chain-1')).toBe('cosmos');
-    });
-  });
-
-  describe('private methods', () => {
-    describe('waitForLogin', () => {
-      it('returns immediately when already logged in', async () => {
-        mockParaWebInstance.isFullyLoggedIn.mockResolvedValueOnce(true);
-        await newConnector()['waitForLogin']();
-      });
-
-      it('throws error when modal is closed', async () => {
-        mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(false);
-        const c = newConnector();
-        c['isModalClosed'] = true;
-        await expect(c['waitForLogin']()).rejects.toThrow('User closed modal');
-      });
-
-      it('throws error on timeout', async () => {
-        mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(false);
-        const c = newConnector();
-        c['isModalClosed'] = false;
-        vi.spyOn(global, 'setTimeout').mockImplementation((cb: any) => {
-          cb();
-          return 0 as any;
-        });
-        await expect(c['waitForLogin'](1)).rejects.toThrow('Timed out waiting for user to log in');
-      });
-    });
-
-    describe('waitForAccounts', () => {
-      it('returns immediately when accounts are available', async () => {
-        mockParaWebInstance.getWalletsByType.mockReturnValueOnce([wallet]);
-        const res = await newConnector()['waitForAccounts']();
-        expect(res).toEqual([wallet]);
-      });
-
-      it('throws error on timeout', async () => {
-        mockParaWebInstance.getWalletsByType.mockReturnValue([]);
-        const c = newConnector();
-        vi.spyOn(global, 'setTimeout').mockImplementation((cb: any) => {
-          cb();
-          return 0 as any;
-        });
-        await expect(c['waitForAccounts'](1)).rejects.toThrow('Timed out waiting for accounts to load');
-      });
-    });
-
-    describe('hasCosmosWallet', () => {
-      it('returns false when not logged in', async () => {
-        expect(await newConnector()['hasCosmosWallet']()).toBe(false);
-      });
-      it('returns false when logged in but no COSMOS wallets', async () => {
-        mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(true);
-        mockParaWebInstance.getWalletsByType.mockReturnValue([]);
-        expect(await newConnector()['hasCosmosWallet']()).toBe(false);
-      });
-      it('returns true when logged in with COSMOS wallets', async () => {
-        mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(true);
-        mockParaWebInstance.getWalletsByType.mockReturnValue([wallet]);
-        expect(await newConnector()['hasCosmosWallet']()).toBe(true);
-      });
-    });
-
-    describe('ensureConnected', () => {
-      it('throws when not connected', async () => {
-        await expect(newConnector()['ensureConnected']()).rejects.toThrow();
-      });
-      it('does not throw when connected', async () => {
-        mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(true);
-        await newConnector()['ensureConnected']();
-      });
-    });
-  });
-
-  describe('enable', () => {
-    it('early exit when wallet already present', async () => {
-      mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(true);
-      mockParaWebInstance.getWalletsByType.mockReturnValue([wallet]);
-      await newConnector().enable('chain-1');
-      expect(renderModal).not.toHaveBeenCalled();
-    });
-
-    it('opens modal then resolves on login + wallets', async () => {
-      mockParaWebInstance.isFullyLoggedIn.mockResolvedValueOnce(false).mockResolvedValue(true);
-      mockParaWebInstance.getWalletsByType.mockReturnValueOnce([]).mockReturnValue([wallet]);
-      vi.spyOn(global, 'setTimeout').mockImplementation((cb: any) => {
-        cb();
-        return 0 as any;
-      });
-      await newConnector().enable('chain-1');
-      expect(renderModal).toHaveBeenCalled();
-    });
-
-    it('handles array of chain IDs', async () => {
-      mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(true);
-      mockParaWebInstance.getWalletsByType.mockReturnValue([wallet]);
-      await newConnector().enable(['chain-1', 'chain-2']);
-    });
-
-    it('handles login failure and cleans up', async () => {
-      mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(false);
-      const c = newConnector();
-      vi.spyOn(c as any, 'waitForLogin').mockRejectedValueOnce(new Error('Login error'));
-      await expect(c.enable('chain-1')).rejects.toThrow('Login error');
-      expect(c['isModalClosed']).toBe(true);
-    });
-
-    it('onClose callback sets isModalClosed', async () => {
-      mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(false);
-      const c = newConnector();
-      vi.spyOn(c as any, 'waitForLogin').mockResolvedValue(undefined);
-      vi.spyOn(c as any, 'waitForAccounts').mockResolvedValue([wallet]);
-
-      await c.enable('chain-1');
-      const onClose = (renderModal as any).mock.calls[0][2] as () => void;
-      c['isModalClosed'] = false;
-      onClose();
-      expect(c['isModalClosed']).toBe(true);
-    });
-  });
-
-  describe('public methods', () => {
-    describe('getFirstWallet', () => {
-      it('returns first wallet from waitForAccounts', async () => {
-        mockParaWebInstance.getWalletsByType.mockReturnValue([wallet]);
-        expect(await newConnector().getFirstWallet()).toBe(wallet);
-      });
-    });
-
-    describe('getKey', () => {
-      it('returns key for wallet', async () => {
-        mockParaWebInstance.getWalletsByType.mockReturnValue([wallet]);
-        const res = await newConnector().getKey('chain-1');
-        expect(res.bech32Address).toBe('test1qqq');
-      });
-      it('throws error when no account', async () => {
-        mockParaWebInstance.getWalletsByType.mockReturnValue([wallet]);
-        const ParaProtoSigner = (await import('@getpara/cosmjs-v0-integration')).ParaProtoSigner as any;
-        ParaProtoSigner.mockImplementationOnce(() => ({ getAccounts: vi.fn().mockResolvedValue([]) }));
-        await expect(newConnector().getKey('chain-1')).rejects.toThrow('has no accounts');
-      });
-    });
-
-    describe('getParaWebClient and getConfig', () => {
-      it('getParaWebClient returns client', () => {
-        expect(newConnector().getParaWebClient()).toBe(mockParaWebInstance);
-      });
-      it('getConfig returns config', () => {
-        const cfgObj = cfg();
-        expect(new ParaGrazConnector(cfgObj).getConfig()).toBe(cfgObj);
-      });
-    });
-
-    describe('getOfflineSigner methods', () => {
-      it('getOfflineSignerOnlyAmino returns signer & can sign', async () => {
-        mockParaWebInstance.getWalletsByType.mockReturnValue([wallet]);
-        const aminoSigner: any = newConnector().getOfflineSignerOnlyAmino('chain-1');
-
-        await expect(
-          aminoSigner.signAmino('test1qqq', {
-            chain_id: 'chain-1',
-            account_number: '0',
-            sequence: '0',
-            fee: { amount: [], gas: '0' },
-            msgs: [],
-            memo: '',
-          } as StdSignDoc),
-        ).resolves.toBeDefined();
-      });
-
-      it('getOfflineSignerOnlyAmino throws when no wallets available', async () => {
-        mockParaWebInstance.getWalletsByType.mockReturnValue([]);
-        const connector = newConnector();
-        expect(() => connector.getOfflineSignerOnlyAmino('chain-1')).toThrow('No wallets found');
-      });
-
-      it('getOfflineSigner returns combined signer and can sign directly', async () => {
-        mockParaWebInstance.getWalletsByType.mockReturnValue([wallet]);
-        const signer = newConnector().getOfflineSigner('chain-1');
-
-        await expect(
-          signer.signDirect('test1qqq', {
-            bodyBytes: new Uint8Array(),
-            authInfoBytes: new Uint8Array(),
-            chainId: 'chain-1',
-            accountNumber: Long.fromString('1'),
-          } as SignDoc),
-        ).resolves.toBeDefined();
-      });
-
-      it('getOfflineSignerAuto resolves to amino signer', async () => {
-        mockParaWebInstance.getWalletsByType.mockReturnValue([wallet]);
-        const signer = await newConnector().getOfflineSignerAuto('chain-1');
-        expect(signer.getAccounts).toBeDefined();
-      });
-    });
-
-    describe('signing methods', () => {
-      beforeEach(() => {
-        mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(true);
-        mockParaWebInstance.getWalletsByType.mockReturnValue([wallet]);
-      });
-
-      it('signAmino success path', async () => {
-        await expect(
-          newConnector().signAmino('chain-1', 'test1qqq', {
-            chain_id: 'chain-1',
-            account_number: '1',
-            sequence: '1',
-            fee: { amount: [], gas: '0' },
-            msgs: [],
-            memo: '',
-          }),
-        ).resolves.toBeDefined();
-      });
-
-      it('signDirect success path', async () => {
-        await expect(
-          newConnector().signDirect('chain-1', 'test1qqq', {
-            bodyBytes: new Uint8Array([1]),
-            authInfoBytes: new Uint8Array([1]),
-            chainId: 'chain-1',
-            accountNumber: BigInt(1),
-          } as any),
-        ).resolves.toBeDefined();
-      });
-
-      it('signDirect handles null fields', async () => {
-        await expect(
-          newConnector().signDirect('chain-1', 'test1qqq', {
-            bodyBytes: null,
-            authInfoBytes: null,
-            chainId: null,
-            accountNumber: null,
-          } as any),
-        ).resolves.toBeDefined();
-      });
-
-      it('signArbitrary with string data', async () => {
-        await expect(newConnector().signArbitrary('chain-1', 'test1qqq', 'data')).resolves.toBeDefined();
-      });
-      it('signArbitrary with Uint8Array data', async () => {
-        await expect(newConnector().signArbitrary('chain-1', 'test1qqq', new Uint8Array([1, 2]))).resolves.toBeDefined();
-      });
-
-      it('signing methods throw when wallet not connected', async () => {
-        mockParaWebInstance.isFullyLoggedIn.mockResolvedValue(false);
-        const c = newConnector();
-        await expect(c.signAmino('chain-1', 'a', {} as any)).rejects.toThrow();
-        await expect(c.signDirect('chain-1', 'a', {} as any)).rejects.toThrow();
-        await expect(c.signArbitrary('chain-1', 'a', 'x')).rejects.toThrow();
-      });
-    });
-
-    it('disconnect calls logout', async () => {
-      await newConnector().disconnect();
-      expect(mockParaWebInstance.logout).toHaveBeenCalled();
-    });
-  });
-});
-
-describe('ParaOfflineSigner', () => {
-  const mockChainId = 'chain-1';
-  let mockConnector: any;
-  let offlineSigner: ParaOfflineSigner;
-
-  beforeEach(() => {
-    mockConnector = {
-      getParaWebClient: vi.fn().mockReturnValue(mockParaWebInstance),
-      getBech32Prefix: vi.fn().mockReturnValue('cosmos'),
-      getFirstWallet: vi.fn().mockResolvedValue(wallet),
-      getKey: vi.fn().mockResolvedValue({
-        bech32Address: 'test1qqq',
-        algo: 'secp256k1',
-        pubKey: new Uint8Array([1, 2, 3]),
-      }),
-    };
-    offlineSigner = new ParaOfflineSigner(mockChainId, mockConnector);
-  });
-
-  describe('private methods', () => {
-    it('para getter returns client', () => {
-      expect(offlineSigner['para']).toBe(mockParaWebInstance);
-      expect(mockConnector.getParaWebClient).toHaveBeenCalled();
-    });
-
-    it('prefix getter returns bech32 prefix', () => {
-      expect(offlineSigner['prefix']).toBe('cosmos');
-      expect(mockConnector.getBech32Prefix).toHaveBeenCalledWith(mockChainId);
-    });
-
-    it('wallet method returns first wallet', async () => {
-      const result = await offlineSigner['wallet']();
-      expect(result).toBe(wallet);
-      expect(mockConnector.getFirstWallet).toHaveBeenCalled();
-    });
-  });
-
-  describe('getAccounts', () => {
-    it('returns accounts', async () => {
-      expect(await offlineSigner.getAccounts()).toEqual([
-        {
-          address: 'test1qqq',
-          algo: 'secp256k1',
-          pubkey: new Uint8Array([1, 2, 3]),
-        },
-      ]);
-    });
-  });
-
-  describe('signDirect validation', () => {
-    it('throws when chain ID does not match', async () => {
-      await expect(
-        offlineSigner.signDirect('test1qqq', {
-          bodyBytes: new Uint8Array(),
-          authInfoBytes: new Uint8Array(),
-          chainId: 'wrong',
-          accountNumber: Long.fromString('1'),
-        } as SignDoc),
-      ).rejects.toThrow('Chain ID does not match');
-    });
-
-    it('throws when signer address does not match', async () => {
-      vi.spyOn(offlineSigner, 'getAccounts').mockResolvedValueOnce([
-        { address: 'test1qqq', algo: 'secp256k1', pubkey: new Uint8Array([1, 2, 3]) },
-      ] as any);
-      await expect(
-        offlineSigner.signDirect('other', {
-          bodyBytes: new Uint8Array(),
-          authInfoBytes: new Uint8Array(),
-          chainId: mockChainId,
-          accountNumber: Long.fromString('1'),
-        } as SignDoc),
-      ).rejects.toThrow('Signer address does not match');
-    });
-
-    it('signDirect success path', async () => {
-      await expect(
-        offlineSigner.signDirect('test1qqq', {
-          bodyBytes: new Uint8Array(),
-          authInfoBytes: new Uint8Array(),
-          chainId: mockChainId,
-          accountNumber: Long.fromString('1'),
-        } as SignDoc),
-      ).resolves.toBeDefined();
-    });
-
-    it('signDirect handles string accountNumber', async () => {
-      await expect(
-        offlineSigner.signDirect('test1qqq', {
-          bodyBytes: new Uint8Array(),
-          authInfoBytes: new Uint8Array(),
-          chainId: mockChainId,
-          accountNumber: '42' as any,
-        }),
-      ).resolves.toBeDefined();
-    });
-  });
-});

package/__tests__/connectorModal.test.tsx

@@ -1,148 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest';
-import React from 'react';
-import type ParaWeb from '@getpara/react-sdk';
-
-const mockRootRender = vi.fn();
-const mockRootUnmount = vi.fn();
-const mockRoot = { render: mockRootRender, unmount: mockRootUnmount };
-
-const mockCreateRoot = vi.fn().mockReturnValue(mockRoot);
-const mockLegacyRender = vi.fn();
-const mockLegacyUnmount = vi.fn();
-
-vi.mock('react-dom/client', () => ({
-  __esModule: true,
-  default: { createRoot: mockCreateRoot },
-  createRoot: mockCreateRoot,
-}));
-
-vi.mock('react-dom', () => ({
-  __esModule: true,
-  default: { render: mockLegacyRender, unmountComponentAtNode: mockLegacyUnmount },
-  render: mockLegacyRender,
-  unmountComponentAtNode: mockLegacyUnmount,
-}));
-
-vi.mock('@getpara/react-sdk', () => ({
-  __esModule: true,
-  default: vi.fn(),
-  ParaModal: vi.fn(props => React.createElement('div', props)),
-}));
-
-const originalCreateElement = document.createElement.bind(document);
-let mockContainer!: HTMLDivElement;
-
-function stubDom() {
-  mockContainer = originalCreateElement('div');
-  mockContainer.remove = vi.fn();
-
-  document.createElement = vi.fn().mockReturnValue(mockContainer) as any;
-  document.getElementById = vi.fn().mockReturnValue(null) as any;
-  document.body.appendChild = vi.fn();
-}
-
-function restoreDom() {
-  document.createElement = originalCreateElement;
-}
-
-import { renderModal as renderModalR18 } from '../src/connectorModal';
-
-beforeEach(() => {
-  document.body.innerHTML = '';
-  vi.clearAllMocks();
-  stubDom();
-});
-
-afterEach(() => {
-  restoreDom();
-});
-
-describe('connectorModal', () => {
-  const para: ParaWeb = {} as ParaWeb;
-
-  describe('React 18 path', () => {
-    it('creates a container and renders with createRoot', async () => {
-      await renderModalR18(para, {}, vi.fn());
-
-      expect(document.createElement).toHaveBeenCalledWith('div');
-      expect(document.body.appendChild).toHaveBeenCalledWith(mockContainer);
-      expect(mockCreateRoot).toHaveBeenCalledWith(mockContainer);
-      expect(mockRootRender).toHaveBeenCalledTimes(1);
-
-      const el = mockRootRender.mock.calls[0][0];
-      expect(el.props.isOpen).toBe(true);
-      expect(el.props.para).toBe(para);
-      expect(el.props.appName).toBe('Test App');
-    });
-
-    it('handles undefined props', async () => {
-      await renderModalR18(para, undefined, vi.fn());
-
-      const el = mockRootRender.mock.calls[0][0];
-      expect(el.props.isOpen).toBe(true);
-      expect(el.props.para).toBe(para);
-    });
-
-    it('calls custom onClose and performs cleanup', async () => {
-      const custom = vi.fn();
-      const outer = vi.fn();
-
-      await renderModalR18(para, { onClose: custom }, outer);
-      mockRootRender.mock.calls[0][0].props.onClose();
-
-      expect(outer).toHaveBeenCalledTimes(1);
-      expect(custom).toHaveBeenCalledTimes(1);
-      expect(mockRootUnmount).toHaveBeenCalledTimes(1);
-      expect(mockContainer.remove).toHaveBeenCalled();
-    });
-
-    it('reuses existing container', async () => {
-      await renderModalR18(para, {}, vi.fn());
-
-      vi.clearAllMocks();
-      (document.getElementById as Mock).mockReturnValueOnce(mockContainer);
-
-      await renderModalR18(para, {}, vi.fn());
-
-      expect(document.createElement).not.toHaveBeenCalled();
-      expect(document.body.appendChild).not.toHaveBeenCalled();
-      expect(mockRootRender).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('Legacy React path', () => {
-    let renderModalLegacy: typeof renderModalR18;
-
-    beforeEach(async () => {
-      vi.resetModules();
-      stubDom();
-      const client = await import('react-dom/client');
-      delete (client as any).createRoot;
-      if (client.default) delete (client.default as any).createRoot;
-      ({ renderModal: renderModalLegacy } = await import('../src/connectorModal'));
-    });
-
-    it('falls back to legacy render when createRoot is unavailable', async () => {
-      await renderModalLegacy(para, {}, vi.fn());
-
-      expect(mockCreateRoot).not.toHaveBeenCalled();
-      expect(mockLegacyRender).toHaveBeenCalledTimes(1);
-
-      const [el, container] = mockLegacyRender.mock.calls[0];
-      expect(container).toBe(mockContainer);
-      expect(el.props.para).toBe(para);
-      expect(el.props.appName).toBe('Legacy App');
-    });
-
-    it('performs cleanup with legacy unmount', async () => {
-      const outer = vi.fn();
-
-      await renderModalLegacy(para, {}, outer);
-      mockLegacyRender.mock.calls[0][0].props.onClose();
-
-      expect(outer).toHaveBeenCalledTimes(1);
-      expect(mockLegacyUnmount).toHaveBeenCalledWith(mockContainer);
-      expect(mockContainer.remove).toHaveBeenCalled();
-    });
-  });
-});

package/scripts/build.mjs

@@ -1,36 +0,0 @@
-import * as esbuild from 'esbuild';
-import * as fs from 'fs/promises';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-import { glob } from 'glob';
-
-const entryPoints = await glob('src/**/*.{ts,tsx,js,jsx}');
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const distDir = resolve(__dirname, '../dist');
-
-await fs.mkdir(distDir, { recursive: true });
-await fs.writeFile(`${distDir}/package.json`, JSON.stringify({ type: 'module', sideEffects: false }, null, 2));
-
-/** @type {import('esbuild').BuildOptions} */
-await esbuild.build({
-  banner: {
-    js: '"use client";', // Required for Next 13 App Router
-  },
-  bundle: false,
-  write: true,
-  format: 'esm',
-  loader: {
-    '.png': 'dataurl',
-    '.svg': 'dataurl',
-    '.json': 'text',
-  },
-  platform: 'browser',
-  entryPoints,
-  outdir: distDir,
-  allowOverwrite: true,
-  splitting: true, // Required for tree shaking
-  minify: false,
-  target: ['es2015'],
-  packages: 'external',
-});