@getpara/graz-connector 0.1.0-alpha.6 → 2.0.0-dev.10

package/src/connector.ts

@@ -1,77 +1,66 @@
-import ParaWeb from '@getpara/react-sdk';
-import type { Environment, ParaModalProps } from '@getpara/react-sdk';
-import type { Wallet, Key as GrazKey } from 'graz';
-import { getChainInfo } from 'graz';
-import type {
-  OfflineAminoSigner,
-  OfflineDirectSigner,
-  AminoSignResponse,
-  StdSignDoc,
-  StdSignature,
-  DirectSignResponse,
-  AccountData,
-  Algo,
-  SignDoc as KeplrSignDoc,
-  SignDoc,
-} from '@keplr-wallet/types';
-import { ParaAminoSigner, ParaProtoSigner } from '@getpara/cosmjs-v0-integration';
 import { fromBech32 } from '@cosmjs/encoding';
-import { renderModal } from './connectorModal.js';
-import Long from 'long';
+import { SignDoc } from 'cosmjs-types/cosmos/tx/v1beta1/tx.js';
+import { Wallet, SignDoc as GrazSignDoc } from 'graz';
+import { ParaAminoSigner, ParaProtoSigner } from '@getpara/cosmjs-v0-integration';
+import { ParaWeb, Wallet as ParaWallet } from '@getpara/web-sdk';
+import { Algo, DirectSignResponse, OfflineDirectSigner } from '@cosmjs/proto-signing';
+import { AccountData, AminoSignResponse, OfflineAminoSigner, StdSignature, StdSignDoc } from '@cosmjs/amino';
+import { ChainInfo, KeplrSignOptions } from '@keplr-wallet/types';
 
-const TEN_MINUTES_MS = 600000;
+export type ParaGrazConnectorEvents = {
+  onEnabled?: (chainIds: string[], connector: ParaGrazConnector) => void;
+};
 
 export interface ParaGrazConfig {
-  apiKey: string;
-  env: Environment;
-  modalProps?: ParaModalProps;
+  paraWeb: ParaWeb;
+  events?: ParaGrazConnectorEvents;
+  noModal?: boolean;
 }
 
-export class ParaOfflineSigner implements OfflineDirectSigner {
-  private chainId: string;
-  private paraWebClient: ParaWeb;
+export function toArray<T>(v: T | T[]): T[] {
+  return Array.isArray(v) ? v : [v];
+}
 
-  constructor(chainId: string, paraWebClient: ParaWeb) {
-    this.chainId = chainId;
-    this.paraWebClient = paraWebClient;
+class ParaOfflineSigner implements OfflineDirectSigner {
+  constructor(
+    protected readonly chainId: string,
+    protected readonly connector: ParaGrazConnector,
+  ) {}
+  protected get para() {
+    return this.connector.getParaWebClient();
+  }
+  protected get prefix() {
+    return this.connector.getBech32Prefix(this.chainId);
+  }
+  protected async wallet() {
+    return this.connector.getFirstWallet();
   }
-
   async getAccounts(): Promise<readonly AccountData[]> {
-    const key = await getKey(this.paraWebClient, this.chainId);
+    const key = await this.connector.getKey(this.chainId);
     return [
       {
-        address: key.address,
+        address: key.bech32Address,
         algo: key.algo as Algo,
-        pubkey: key.pubkey,
+        pubkey: key.pubKey,
       },
     ];
   }
-
-  async signDirect(signerAddress: string, signDoc: KeplrSignDoc): Promise<DirectSignResponse> {
+  async signDirect(signerAddress: string, signDoc: SignDoc): Promise<DirectSignResponse> {
     if (this.chainId !== signDoc.chainId) {
-      throw new Error('Chain ID does not match signer chain ID');
+      throw new Error(`Para connector: signDirect chainId mismatch (expected ${this.chainId}, got ${signDoc.chainId})`);
     }
-
     const accounts = await this.getAccounts();
-    if (accounts.find(account => account.address !== signerAddress)) {
-      throw new Error('Signer address does not match wallet address');
+    if (accounts.every(a => a.address !== signerAddress)) {
+      throw new Error(`Para connector: signerAddress ${signerAddress} not found in wallet`);
     }
-
-    const convertedSignDoc = {
-      bodyBytes: signDoc.bodyBytes,
-      authInfoBytes: signDoc.authInfoBytes,
-      chainId: signDoc.chainId,
-      accountNumber: typeof signDoc.accountNumber === 'string' ? signDoc.accountNumber : signDoc.accountNumber.toString(),
-    };
-
-    const result = await requestSignature(this.paraWebClient, this.chainId, signerAddress, convertedSignDoc);
-
+    const signer = new ParaProtoSigner(this.para, this.prefix, (await this.wallet()).id);
+    const result = await signer.signDirect(signerAddress, signDoc);
     return {
       signed: {
         bodyBytes: result.signed.bodyBytes,
         authInfoBytes: result.signed.authInfoBytes,
         chainId: result.signed.chainId,
-        accountNumber: Long.fromString(result.signed.accountNumber.toString()),
+        accountNumber: result.signed.accountNumber,
       },
       signature: result.signature,
     };
@@ -79,292 +68,202 @@ export class ParaOfflineSigner implements OfflineDirectSigner {
 }
 
 export class ParaGrazConnector implements Omit<Wallet, 'experimentalSuggestChain'> {
-  private paraWebClient: ParaWeb;
-  private config: ParaGrazConfig;
-  private isModalClosed: boolean;
-
-  constructor(config: ParaGrazConfig) {
-    if (!config || !config.apiKey || !config.env) {
-      throw new Error('Para Connector: Missing API Key or Environment in config.');
+  protected paraWebClient: ParaWeb;
+  protected enabledChainIds = new Set<string>();
+  protected readonly events?: ParaGrazConnectorEvents;
+  protected noModal?: boolean;
+  constructor(
+    protected readonly config: ParaGrazConfig,
+    protected readonly chains: ChainInfo[] | null = null,
+  ) {
+    if (!config?.paraWeb) {
+      throw new Error('Para connector: missing paraWeb instance in config');
     }
-    this.config = config;
-    this.paraWebClient = new ParaWeb(config.env, config.apiKey);
-    this.isModalClosed = true;
+    this.events = config.events;
+    this.paraWebClient = config.paraWeb;
+    this.noModal = config.noModal;
   }
-
-  closeModal = () => {
-    this.isModalClosed = true;
-  };
-
-  private async waitForLogin(timeoutMs = TEN_MINUTES_MS): Promise<boolean> {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      if (await this.paraWebClient.isFullyLoggedIn()) {
-        return true;
-      }
-
-      if (this.isModalClosed) {
-        throw new Error('user closed modal');
-      }
-
-      await new Promise(resolve => setTimeout(resolve, 2000));
+  protected async ensureChainEnabled(chainId: string): Promise<void> {
+    if (!this.enabledChainIds.has(chainId)) {
+      throw new Error(`Para connector: chain ${chainId} was not enabled via wallet.enable()`);
+    }
+    if (!(await this.paraWebClient.isFullyLoggedIn())) {
+      throw new Error('Para connector: wallet is not connected – call enable() first');
     }
-
-    throw new Error('timed out waiting for user to log in');
   }
-
-  private async waitForAccounts(chainIds: string | string[], timeoutMs = 5000): Promise<boolean> {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-      if (wallets && wallets.length > 0) {
-        return true;
-      }
-      await new Promise(resolve => setTimeout(resolve, 500));
+  protected async waitForLogin(timeoutMs = 60_000): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    let delay = 500;
+    const MAX_DELAY = 5_000;
+    while (true) {
+      if (await this.paraWebClient.isFullyLoggedIn()) return;
+      if (Date.now() >= deadline) throw new Error('Para connector: login timeout');
+      await new Promise(r => setTimeout(r, delay));
+      delay = Math.min(delay * 1.5, MAX_DELAY);
     }
-
-    throw new Error('timed out waiting for accounts to load');
   }
 
-  async enable(chainIds: string | string[]): Promise<void> {
-    if (await this.paraWebClient.isFullyLoggedIn()) {
-      const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-      if (wallets && wallets.length > 0) {
-        return;
-      }
+  protected async waitForAccounts(timeoutMs = 5_000): Promise<ParaWallet[]> {
+    const deadline = Date.now() + timeoutMs;
+    let delay = 250;
+    const MAX_DELAY = 1_000;
+    while (true) {
+      const wallets = this.paraWebClient.getWalletsByType('COSMOS');
+      if (wallets.length) return wallets;
+      if (Date.now() >= deadline) throw new Error('Para connector: no COSMOS wallets found after login');
+      await new Promise(r => setTimeout(r, delay));
+      delay = Math.min(delay * 1.5, MAX_DELAY);
     }
-
-    this.isModalClosed = false;
-    renderModal(this.paraWebClient, this.config.modalProps, () => {
-      this.isModalClosed = true;
-    });
-
-    await this.waitForLogin();
-
+  }
+  protected async hasCosmosWallet(): Promise<boolean> {
+    return (await this.paraWebClient.isFullyLoggedIn()) && this.paraWebClient.getWalletsByType('COSMOS').length > 0;
+  }
+  async enable(chainIdsInput: string | string[]): Promise<void> {
+    const chainIds = toArray(chainIdsInput);
+    const previousEnabled = new Set(this.enabledChainIds);
     try {
-      await this.waitForAccounts(chainIds);
-    } catch (error) {
-      throw new Error('accounts not available after login');
+      chainIds.forEach(id => this.enabledChainIds.add(id));
+      if (await this.hasCosmosWallet()) {
+        this.events?.onEnabled?.(chainIds, this);
+        return;
+      }
+      if (!this.noModal) {
+        throw new Error('Modal rendering not supported in core library. Use @getpara/graz-integration for modal support.');
+      }
+      await this.waitForLogin();
+      await this.waitForAccounts();
+      this.events?.onEnabled?.(chainIds, this);
+    } catch (err) {
+      this.enabledChainIds = previousEnabled;
+      throw err;
     }
   }
 
+  async disconnect(): Promise<void> {
+    await this.paraWebClient.logout();
+    this.enabledChainIds.clear();
+  }
+  async getFirstWallet(): Promise<ParaWallet> {
+    const [wallet] = await this.waitForAccounts();
+    return wallet;
+  }
+  getBech32Prefix(chainId: string): string {
+    return this.chains?.find(c => c.chainId === chainId)?.bech32Config?.bech32PrefixAccAddr || 'cosmos';
+  }
   getParaWebClient(): ParaWeb {
     return this.paraWebClient;
   }
-
   getConfig(): ParaGrazConfig {
     return this.config;
   }
-
-  async getKey(chainId: string): Promise<GrazKey> {
-    const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-
-    if (wallets.length === 0) {
-      throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
-    }
-
-    // Get the bech32 prefix from chain info
-    const bech32Prefix = this.getBech32Prefix(chainId);
-
-    const walletSigner = new ParaProtoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
-    const accountData = await walletSigner.getAccounts();
-    if (accountData.length === 0) {
-      throw new Error(`Para Connector: No accounts found for wallet ${wallets[0].id}`);
-    }
-
-    const account = accountData[0];
+  protected buildHybridSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
+    const aminoSigner = this.getOfflineSignerOnlyAmino(chainId);
+    const directSigner = new ParaOfflineSigner(chainId, this);
     return {
-      address: fromBech32(account.address).data,
-      bech32Address: account.address,
+      getAccounts: () => directSigner.getAccounts(),
+      signAmino: (signer: string, signDoc: StdSignDoc) => aminoSigner.signAmino(signer, signDoc),
+      signDirect: (signer: string, signDoc: SignDoc) => directSigner.signDirect(signer, signDoc),
+    } as unknown as OfflineAminoSigner & OfflineDirectSigner;
+  }
+  async getKey(chainId: string) {
+    await this.ensureChainEnabled(chainId);
+    const wallet = await this.getFirstWallet();
+    const signer = new ParaProtoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+    const [account] = await signer.getAccounts();
+    if (!account) throw new Error(`Para connector: wallet ${wallet.id} has no Cosmos accounts`);
+    return {
+      name: 'Para Wallet',
       algo: account.algo,
-      name: account.address,
       pubKey: account.pubkey,
+      address: fromBech32(account.address).data,
+      bech32Address: account.address,
       isKeystone: false,
       isNanoLedger: false,
     };
   }
-
-  getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
-    const aminoSigner = this.getOfflineSignerOnlyAmino(chainId);
-    const directSigner = new ParaOfflineSigner(chainId, this.paraWebClient);
-
-    const combinedSigner = {
-      getAccounts: () => directSigner.getAccounts(),
-      signAmino: (signerAddress: string, signDoc: StdSignDoc) => aminoSigner.signAmino(signerAddress, signDoc),
-      signDirect: (signerAddress: string, signDoc: SignDoc) => directSigner.signDirect(signerAddress, signDoc),
-    };
-
-    return combinedSigner as unknown as OfflineAminoSigner & OfflineDirectSigner;
-  }
-
   getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner {
-    const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-    if (wallets.length === 0) {
-      throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
+    void this.ensureChainEnabled(chainId); // fire & forget – returns void
+    const wallet = this.paraWebClient.getWalletsByType('COSMOS')[0];
+    if (!wallet) {
+      throw new Error(`Para connector: no wallets found when requesting Amino signer for ${chainId}`);
     }
-
-    const bech32Prefix = this.getBech32Prefix(chainId);
-
-    return new ParaAminoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
+    return new ParaAminoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
   }
-
-  getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner> {
-    return Promise.resolve(this.getOfflineSignerOnlyAmino(chainId));
+  getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
+    void this.ensureChainEnabled(chainId);
+    return this.buildHybridSigner(chainId);
   }
-
-  async signAmino(chainId: string, signer: string, signDoc: StdSignDoc): Promise<AminoSignResponse> {
-    await this.ensureConnected();
-
-    const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-    if (wallets.length === 0) {
-      throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
+  async getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner> {
+    void this.ensureChainEnabled(chainId);
+    return this.buildHybridSigner(chainId);
+  }
+  async signAmino(
+    chainId: string,
+    signer: string,
+    signDoc: StdSignDoc,
+    _signOptions?: KeplrSignOptions,
+  ): Promise<AminoSignResponse> {
+    await this.ensureChainEnabled(chainId);
+    try {
+      const wallet = await this.getFirstWallet();
+      const signerImpl = new ParaAminoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+      return await signerImpl.signAmino(signer, signDoc);
+    } catch (err) {
+      throw new Error(`Para connector: signAmino failed – ${(err as Error).message}`);
     }
-
-    const bech32Prefix = this.getBech32Prefix(chainId);
-
-    const walletSigner = new ParaAminoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
-
-    return walletSigner.signAmino(signer, signDoc);
   }
-
   async signDirect(
     chainId: string,
     signer: string,
-    signDoc: {
-      bodyBytes?: Uint8Array;
-      authInfoBytes?: Uint8Array;
-      chainId?: string;
-      accountNumber?: Long;
-    },
+    signDoc: GrazSignDoc,
+    _signOptions?: KeplrSignOptions,
   ): Promise<DirectSignResponse> {
-    await this.ensureConnected();
-
-    const wallets = Object.values(this.paraWebClient.getWalletsByType('COSMOS'));
-    if (wallets.length === 0) {
-      throw new Error(`Para Connector: No wallets found for chainId ${chainId}`);
+    await this.ensureChainEnabled(chainId);
+    try {
+      const wallet = await this.getFirstWallet();
+      const signerImpl = new ParaProtoSigner(this.paraWebClient, this.getBech32Prefix(chainId), wallet.id);
+      const convertedSignDoc: SignDoc = {
+        bodyBytes: signDoc.bodyBytes ?? new Uint8Array(),
+        authInfoBytes: signDoc.authInfoBytes ?? new Uint8Array(),
+        chainId: signDoc.chainId,
+        accountNumber: typeof signDoc.accountNumber === 'bigint' ? signDoc.accountNumber : BigInt(signDoc.accountNumber),
+      };
+      const result = await signerImpl.signDirect(signer, convertedSignDoc);
+      return {
+        signed: {
+          bodyBytes: result.signed.bodyBytes,
+          authInfoBytes: result.signed.authInfoBytes,
+          chainId: result.signed.chainId,
+          accountNumber: result.signed.accountNumber,
+        },
+        signature: result.signature,
+      };
+    } catch (err) {
+      throw new Error(`Para connector: signDirect failed – ${(err as Error).message}`);
     }
-
-    const convertedSignDoc = {
-      bodyBytes: signDoc.bodyBytes || new Uint8Array(),
-      authInfoBytes: signDoc.authInfoBytes || new Uint8Array(),
-      chainId: signDoc.chainId || chainId,
-      accountNumber: signDoc.accountNumber ? signDoc.accountNumber.toString() : '0',
-    };
-
-    const bech32Prefix = this.getBech32Prefix(chainId);
-
-    const walletSigner = new ParaProtoSigner(this.paraWebClient, bech32Prefix, wallets[0].id);
-
-    const result = await walletSigner.signDirect(signer, {
-      ...convertedSignDoc,
-      accountNumber: BigInt(convertedSignDoc.accountNumber),
-    });
-
-    return {
-      signed: {
-        bodyBytes: result.signed.bodyBytes,
-        authInfoBytes: result.signed.authInfoBytes,
-        chainId: result.signed.chainId,
-        accountNumber: Long.fromString(result.signed.accountNumber.toString()),
-      },
-      signature: result.signature,
-    };
   }
-
   async signArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<StdSignature> {
-    await this.ensureConnected();
-
-    let encodedData: string;
-    let isADR36WithString = false;
-
-    if (typeof data === 'string') {
-      encodedData = Buffer.from(data).toString('base64');
-      isADR36WithString = true;
-    } else {
-      encodedData = Buffer.from(data).toString('base64');
-    }
-
+    await this.ensureChainEnabled(chainId);
+    const encodedData =
+      typeof data === 'string' ? Buffer.from(data, 'utf-8').toString('base64') : Buffer.from(data).toString('base64');
     const signDoc = {
       chain_id: '',
       account_number: '0',
       sequence: '0',
-      fee: {
-        gas: '0',
-        amount: [],
-      },
+      fee: { gas: '0', amount: [] },
       msgs: [
         {
           type: 'sign/MsgSignData',
-          value: {
-            signer,
-            data: encodedData,
-          },
+          value: { signer, data: encodedData },
         },
       ],
       memo: '',
     };
-
-    const response = await this.signAmino(chainId, signer, signDoc);
-
-    return response.signature;
-  }
-
-  async disconnect(): Promise<void> {
-    await this.paraWebClient.logout();
-  }
-
-  private async ensureConnected(): Promise<void> {
-    const isConnected = await this.paraWebClient.isFullyLoggedIn();
-    if (!isConnected) {
-      throw new Error('Wallet is not connected, please connect first');
-    }
-  }
-
-  private getBech32Prefix(chainId: string): string {
-    const chainInfo = getChainInfo({ chainId });
-    if (chainInfo?.bech32Config?.bech32PrefixAccAddr) {
-      return chainInfo.bech32Config.bech32PrefixAccAddr;
+    try {
+      const response = await this.signAmino(chainId, signer, signDoc);
+      return response.signature;
+    } catch (err) {
+      throw new Error(`Para connector: signArbitrary failed – ${(err as Error).message}`);
     }
-
-    return 'cosmos';
-  }
-}
-
-async function getKey(paraWebClient: ParaWeb, chainId: string) {
-  const wallets = Object.values(paraWebClient.getWalletsByType('COSMOS'));
-
-  if (wallets.length < 1) {
-    throw Error('No wallets available');
-  }
-
-  const chainInfo = getChainInfo({ chainId });
-  const bech32Prefix = chainInfo?.bech32Config?.bech32PrefixAccAddr || 'cosmos';
-
-  const walletSigner = new ParaProtoSigner(paraWebClient, bech32Prefix, wallets[0].id);
-
-  const accountData = (await walletSigner.getAccounts())[0];
-  if (!accountData) {
-    throw new Error('No account data found');
-  }
-
-  return accountData;
-}
-
-async function requestSignature(paraWebClient: ParaWeb, chainId: string, signerAddress: string, signDoc: any) {
-  const isConnected = await paraWebClient.isFullyLoggedIn();
-  if (!isConnected) {
-    throw new Error('Wallet is not connected, please connect first');
-  }
-
-  const wallets = Object.values(paraWebClient.getWalletsByType('COSMOS'));
-  if (wallets.length === 0) {
-    throw new Error('No wallets available');
   }
-
-  const chainInfo = getChainInfo({ chainId });
-  const bech32Prefix = chainInfo?.bech32Config?.bech32PrefixAccAddr || 'cosmos';
-
-  const walletSigner = new ParaProtoSigner(paraWebClient, bech32Prefix, wallets[0].id);
-
-  return walletSigner.signDirect(signerAddress, signDoc);
 }

package/src/index.ts

@@ -1,3 +1,2 @@
-export { WalletType, AuthLayout, AuthMethod, OAuthMethod, Environment } from '@getpara/react-sdk';
-export { ParaGrazConnector } from './connector.js';
+export { toArray, ParaGrazConnector } from './connector.js';
 export type { ParaGrazConfig } from './connector.js';

package/tsconfig.json

@@ -6,8 +6,8 @@
     "jsx": "react-jsx",
     "module": "ESNext",
     "declaration": true,
-    "declarationDir": "dist"
+    "declarationDir": "./dist"
   },
-  "include": ["**/*.ts", "**/*.tsx"],
-  "exclude": ["node_modules", "dist"]
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.test.tsx", "__tests__"]
 }

package/vitest.config.js

@@ -0,0 +1,22 @@
+import { mergeConfig } from 'vite';
+import baseConfig from '../../vitest.config.js';
+
+export default mergeConfig(baseConfig, {
+  test: {
+    environment: 'jsdom',
+    coverage: {
+      provider: 'v8',
+      reporter: ['html', 'text'],
+      all: true,
+      include: ['src/**/*.{ts,tsx,js,jsx}'],
+      thresholds: {
+        lines: 98,
+        functions: 90,
+        branches: 98,
+        statements: 98,
+      },
+      reportOnFailure: true,
+      exclude: ['src/index.ts'],
+    },
+  },
+});

package/dist/chunk-IV3L3JVM.js

@@ -1,46 +0,0 @@
-"use client";
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-export {
-  __spreadValues,
-  __spreadProps,
-  __async
-};

package/dist/connectorModal.d.ts

@@ -1,2 +0,0 @@
-import ParaWeb, { ParaModalProps } from '@getpara/react-sdk';
-export declare function renderModal(para: ParaWeb, modalProps: Partial<ParaModalProps>, onCloseArg: () => void): void;