@zerohash-sdk/crypto-account-link-js 1.1.0

package/README.md

@@ -0,0 +1,125 @@
+# @zerohash-sdk/crypto-account-link-js
+
+A JavaScript SDK that enables frontend applications to seamlessly integrate with the Connect Crypto Account Link product.
+
+Connect Crypto Account Link provides a secure, customizable flow for linking external crypto accounts (for deposits or payouts) directly within your application.
+
+## Installation
+
+### Via NPM (recommended)
+
+```bash
+npm install @zerohash-sdk/crypto-account-link-js
+```
+
+```javascript
+import { CryptoAccountLink } from '@zerohash-sdk/crypto-account-link-js';
+```
+
+### Via CDN
+
+```html
+<script
+  type="module"
+  src="https://sdk.connect.xyz/crypto-account-link-web/index.js"
+></script>
+```
+
+Or import directly in your JavaScript code:
+
+```javascript
+import { CryptoAccountLink } from 'https://sdk.connect.xyz/crypto-account-link-web/index.js';
+```
+
+## Getting Started
+
+### 1. Import the CryptoAccountLink module
+
+```javascript
+import { CryptoAccountLink } from '@zerohash-sdk/crypto-account-link-js';
+```
+
+### 2. Initialize and render the widget
+
+```javascript
+const cryptoAccountLink = new CryptoAccountLink({
+  jwt: 'your-jwt-token',
+  env: 'prod',
+  theme: 'auto',
+  isPayouts: false, // true for payouts/withdrawals, false for deposits
+  onCompleted: ({ externalAccountId, address, nickname, asset, network }) => {
+    console.log('Account linked:', externalAccountId, address);
+  },
+  onExternalAccountCreated: () => {
+    console.log('External account created');
+  },
+  onError: ({ errorCode, reason }) => {
+    console.error('Error:', errorCode, 'Reason:', reason);
+  },
+  onClose: () => console.log('Widget closed'),
+  onEvent: ({ type, data }) => console.log('Event:', type, data),
+  onLoaded: () => console.log('Widget loaded and ready'),
+});
+
+await cryptoAccountLink.render(document.getElementById('crypto-account-link-container'));
+
+cryptoAccountLink.destroy();
+```
+
+### 2.1 Using TypeScript (optional)
+
+```typescript
+import { CryptoAccountLink, CryptoAccountLinkConfig } from '@zerohash-sdk/crypto-account-link-js';
+
+const config: CryptoAccountLinkConfig = {
+  jwt: 'your-jwt-token',
+  env: 'cert',
+  isPayouts: false,
+  onCompleted: ({ externalAccountId, address }) => {
+    console.log(externalAccountId, address);
+  },
+};
+
+const cryptoAccountLink = new CryptoAccountLink(config);
+await cryptoAccountLink.render(document.getElementById('container')!);
+```
+
+## API Reference
+
+### Configuration
+
+| Prop                       | Type                                                                      | Required | Default  | Description                                                 |
+| -------------------------- | ------------------------------------------------------------------------- | -------- | -------- | ----------------------------------------------------------- |
+| `jwt`                      | `string`                                                                  | Yes      | -        | JWT token for authentication with Connect                   |
+| `env`                      | `"prod" \| "cert" \| "dev" \| "local"`                                    | No       | `"prod"` | Target environment                                          |
+| `theme`                    | `"auto" \| "light" \| "dark"`                                             | No       | `"auto"` | Theme mode for the interface                                |
+| `isPayouts`                | `boolean`                                                                 | No       | `false`  | Set to `true` for payouts/withdrawals, `false` for deposits |
+| `onCompleted`              | `({ externalAccountId?, address?, nickname?, asset?, network? }) => void` | No       | -        | Callback when account linking completes successfully        |
+| `onExternalAccountCreated` | `() => void`                                                              | No       | -        | Callback when an external account is created                |
+| `onError`                  | `({ errorCode, reason }) => void`                                         | No       | -        | Callback for error events                                   |
+| `onClose`                  | `() => void`                                                              | No       | -        | Callback when the widget is closed                          |
+| `onEvent`                  | `({ type, data }) => void`                                                | No       | -        | Callback for general events                                 |
+| `onLoaded`                 | `() => void`                                                              | No       | -        | Callback when the widget is loaded and ready                |
+
+### Methods
+
+#### `render(container: HTMLElement): Promise<void>`
+
+#### `updateConfig(config: Partial<CryptoAccountLinkConfig>): void`
+
+#### `destroy(): void`
+
+#### `isRendered(): boolean`
+
+#### `getConfig(): CryptoAccountLinkConfig`
+
+## Browser Support
+
+- Chrome/Edge 90+
+- Firefox 88+
+- Safari 14+
+- All modern browsers with Web Components support
+
+## More Information & Support
+
+For comprehensive documentation or support about Connect, visit our [Documentation Page](https://docs.zerohash.com/).

package/dist/index.d.ts

@@ -0,0 +1,488 @@
+/**
+ * Zerohash Crypto Account Link JavaScript SDK
+ *
+ * A programmatic JavaScript SDK for integrating the Crypto Account Link widget
+ * into web applications without requiring HTML custom elements.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Generic app event structure
+ * @template TType - Event type string
+ * @template TData - Event data payload
+ */
+declare type AppEvent<TType extends string = string, TData = Record<string, unknown>> = {
+    /** The type of event that occurred */
+    type: TType;
+    /** Data associated with the event */
+    data: TData;
+};
+
+/**
+ * Configuration options for the SDK
+ */
+declare interface BaseConfig<TEvent = AppEvent> extends CommonCallbacks<TEvent> {
+    /**
+     * JWT token used for authentication
+     */
+    jwt: string;
+
+    /**
+     * Target environment
+     * @default 'production'
+     */
+    env?: Environment;
+
+    /**
+     * Theme mode
+     * @default 'auto'
+     *
+     * Available themes:
+     * - `'auto'` - Automatically detect system preference (light/dark mode)
+     * - `'light'` - Force light theme
+     * - `'dark'` - Force dark theme
+     */
+    theme?: Theme;
+}
+
+declare type BaseErrorMessageKeys =
+| 'ALREADY_RENDERED'
+| 'NOT_RENDERED'
+| 'INVALID_CONTAINER'
+| 'SCRIPT_LOAD_FAILED'
+| 'WEB_COMPONENT_NOT_DEFINED';
+
+declare abstract class BaseJsSdk<Config extends BaseConfig<never> = BaseConfig> {
+    private config: Config;
+    private state: SdkState;
+    private scriptLoadingPromise?: Promise<void>;
+
+    protected abstract errorMessages: Record<BaseErrorMessageKeys, string>;
+    protected abstract scriptUrls: Record<string, string>;
+    protected abstract webComponentTag: string;
+
+    constructor(config: Config) {
+        if (!config.jwt || typeof config.jwt !== 'string') {
+            throw new Error(INVALID_JWT_ERROR_MESSAGE);
+        }
+
+        this.config = {
+            ...config,
+            env: config.env || DEFAULT_ENVIRONMENT,
+            theme: config.theme,
+        };
+
+        this.state = {
+            initialized: false,
+            scriptLoaded: false,
+            container: null,
+            element: null,
+        };
+    }
+
+    /**
+     * Render the widget to a container element
+     * @param container - The container element to render the widget into
+     * @returns Promise that resolves when the widget is rendered
+     */
+    async render(container: HTMLElement): Promise<void> {
+        // Validate container
+        if (!container || !(container instanceof HTMLElement)) {
+            throw new Error(this.errorMessages.INVALID_CONTAINER);
+        }
+
+        // Check if already rendered
+        if (this.state.initialized) {
+            throw new Error(this.errorMessages.ALREADY_RENDERED);
+        }
+
+        try {
+            // Ensure script is loaded
+            await this.ensureScriptLoaded();
+
+            // Create and append the web component
+            const element = this.createWebComponent();
+
+            // Clear the container and append the element
+            container.innerHTML = '';
+            container.appendChild(element);
+
+            // Update state
+            this.state.container = container;
+            this.state.element = element;
+            this.state.initialized = true;
+        } catch (error) {
+            console.error('Failed to render widget:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update the configuration of the widget
+     * @param config - Partial configuration to update
+     * @returns void
+     */
+    updateConfig(config: Partial<Config>): void {
+        if (!this.state.initialized || !this.state.element) {
+            throw new Error(this.errorMessages.NOT_RENDERED);
+        }
+
+        const element = this.state.element as SdkElement<Config>;
+
+        Object.entries(config).forEach(([key, value]) => {
+            if (value) {
+                this.config[key as keyof Config] = value;
+                element[key as keyof Config] = value;
+            }
+        });
+    }
+
+    /**
+     * Destroy the widget and clean up resources
+     */
+    destroy(): void {
+        if (!this.state.initialized) {
+            return; // Nothing to destroy
+        }
+
+        // Remove the element from the container
+        if (this.state.element && this.state.element.parentNode) {
+            this.state.element.parentNode.removeChild(this.state.element);
+        }
+
+        // Clear the container
+        if (this.state.container) {
+            this.state.container.innerHTML = '';
+        }
+
+        // Reset state
+        this.state.container = null;
+        this.state.element = null;
+        this.state.initialized = false;
+    }
+
+    /**
+     * Check if the widget is currently rendered
+     * @returns True if the widget is rendered, false otherwise
+     */
+    isRendered(): boolean {
+        return this.state.initialized;
+    }
+
+    /**
+     * Get the current configuration
+     * @returns The current configuration object
+     */
+    getConfig(): Readonly<Config> {
+        return { ...this.config };
+    }
+
+    private getEnvironment(): Environment {
+        return this.config.env || DEFAULT_ENVIRONMENT;
+    }
+
+    private getScriptId() {
+        return `${this.webComponentTag}-script-${this.getEnvironment()}`;
+    }
+
+    private isScriptLoaded() {
+        return !!document.getElementById(this.getScriptId());
+    }
+
+    private getWebComponent() {
+        return customElements.get(this.webComponentTag);
+    }
+
+    private getScriptUrl() {
+        // Support local development with Vite
+        if (typeof import.meta !== 'undefined' && import.meta.env?.['VITE_INTERNAL_BUILD'] === 'true') {
+            return import.meta.env['VITE_SCRIPT_URL'] || this.scriptUrls[this.getEnvironment()];
+        }
+
+        return this.scriptUrls[this.getEnvironment()];
+    }
+
+    private async loadScript() {
+        if (this.isScriptLoaded()) {
+            return;
+        }
+
+        if (this.scriptLoadingPromise) {
+            return this.scriptLoadingPromise;
+        }
+
+        this.scriptLoadingPromise = new Promise<void>((resolve, reject) => {
+            const script = document.createElement('script');
+            script.id = this.getScriptId();
+            script.src = this.getScriptUrl();
+            script.type = 'module';
+            script.async = true;
+
+            script.onload = () => {
+                setTimeout(() => {
+                    if (this.getWebComponent()) {
+                        resolve();
+                    } else {
+                        reject(new Error(this.errorMessages.WEB_COMPONENT_NOT_DEFINED));
+                    }
+                }, 0);
+            };
+
+            script.onerror = () => {
+                this.scriptLoadingPromise = undefined;
+                reject(new Error(`${this.errorMessages.SCRIPT_LOAD_FAILED} (${this.getEnvironment()})`));
+            };
+
+            document.head.appendChild(script);
+        });
+
+        try {
+            await this.scriptLoadingPromise;
+        } catch (error) {
+            this.scriptLoadingPromise = undefined;
+            throw error;
+        }
+
+        return this.scriptLoadingPromise;
+    }
+
+    private async waitForWebComponent(timeout = 5000) {
+        if (this.getWebComponent()) {
+            return;
+        }
+
+        return new Promise<void>((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`Timeout waiting for ${this.webComponentTag} to be defined`));
+            }, timeout);
+
+            customElements
+            .whenDefined(this.webComponentTag)
+            .then(() => {
+                clearTimeout(timeoutId);
+                resolve();
+            })
+            .catch((error) => {
+                clearTimeout(timeoutId);
+                reject(error);
+            });
+        });
+    }
+
+    /**
+     * Load the web component script if not already loaded
+     */
+    protected async ensureScriptLoaded(): Promise<void> {
+        if (this.state.scriptLoaded) {
+            return;
+        }
+
+        try {
+            await this.loadScript();
+            await this.waitForWebComponent();
+            this.state.scriptLoaded = true;
+        } catch (error) {
+            console.error('Failed to load Connect script:', error);
+            throw error;
+        }
+    }
+
+    private createWebComponent() {
+        const element = document.createElement(this.webComponentTag) as SdkElement<Config>;
+
+        Object.entries(this.config).forEach(([key, value]) => {
+            if (value) {
+                element[key as keyof Config] = value;
+            }
+        });
+
+        return element;
+    }
+}
+
+/**
+ * Common callback function types shared across all Connect apps
+ * @template TEvent - The event type for onEvent callback
+ */
+declare type CommonCallbacks<TEvent = AppEvent> = {
+    /** Called when an error occurs */
+    onError?: (error: ErrorPayload) => void;
+    /** Called when the component is closed */
+    onClose?: () => void;
+    /** Called when a general event occurs */
+    onEvent?: (event: TEvent) => void;
+    /** Called when the widget has loaded and is ready */
+    onLoaded?: () => void;
+};
+
+/**
+ * CryptoAccountLink SDK class for programmatic control of the Connect Crypto Account Link widget.
+ *
+ * Renders the `zerohash-crypto-account-link` web component, which handles the iframe
+ * and postMessage communication internally.
+ *
+ * @example
+ * ```javascript
+ * const cryptoAccountLink = new CryptoAccountLink({
+ *   jwt: 'your-jwt-token',
+ *   env: 'prod',
+ *   theme: 'auto',
+ *   isPayouts: false,
+ *   onCompleted: (data) => console.log('Completed', data),
+ *   onClose: () => console.log('Closed'),
+ *   onError: ({ errorCode, reason }) => console.error(errorCode, reason),
+ *   onExternalAccountCreated: () => console.log('External account created'),
+ * });
+ *
+ * // Render to a container
+ * await cryptoAccountLink.render(document.getElementById('crypto-account-link-container'));
+ *
+ * // Update configuration
+ * cryptoAccountLink.updateConfig({ jwt: 'new-token', theme: 'dark' });
+ *
+ * // Clean up
+ * cryptoAccountLink.destroy();
+ * ```
+ */
+declare class CryptoAccountLink extends BaseJsSdk<CryptoAccountLinkConfig> {
+    protected errorMessages: {
+        ALREADY_RENDERED: string;
+        NOT_RENDERED: string;
+        INVALID_CONTAINER: string;
+        SCRIPT_LOAD_FAILED: string;
+        WEB_COMPONENT_NOT_DEFINED: string;
+    };
+    protected scriptUrls: {
+        local: string;
+        dev: string;
+        cert: string;
+        prod: string;
+        sandbox: string;
+        production: string;
+    };
+    protected webComponentTag: string;
+    /**
+     * Render the CryptoAccountLink widget to a container element
+     * @param container - The container element to render the widget into
+     * @returns Promise that resolves when the widget is rendered
+     */
+    render(container: HTMLElement): Promise<void>;
+    /**
+     * Update the configuration of the CryptoAccountLink widget
+     * @param config - Partial configuration to update
+     */
+    updateConfig(config: Partial<CryptoAccountLinkConfig>): void;
+    /**
+     * Get the current configuration
+     * @returns The current configuration object
+     */
+    getConfig(): Readonly<CryptoAccountLinkConfig>;
+    /**
+     * Check if the CryptoAccountLink widget is currently rendered
+     * @returns True if the widget is rendered, false otherwise
+     */
+    isRendered(): boolean;
+    /**
+     * Destroy the CryptoAccountLink widget and clean up resources
+     */
+    destroy(): void;
+}
+export { CryptoAccountLink }
+export default CryptoAccountLink;
+
+declare type CryptoAccountLinkCallbacks = CommonCallbacks<CryptoAccountLinkEvent> & {
+    /** Called when an external account is created */
+    onExternalAccountCreated?: () => void;
+    /** Called when the account linking is successfully completed */
+    onCompleted?: (data: CryptoAccountLinkCompletedData) => void;
+};
+
+declare interface CryptoAccountLinkCompletedData {
+    externalAccountId?: string;
+    address?: string;
+    nickname?: string;
+    asset?: string;
+    network?: string;
+}
+
+export declare interface CryptoAccountLinkConfig extends BaseConfig<CryptoAccountLinkEvent>, CryptoAccountLinkCallbacks {
+    isPayouts?: boolean;
+}
+
+/**
+ * Crypto account link event structure
+ */
+declare type CryptoAccountLinkEvent = AppEvent<CryptoAccountLinkEventType>;
+
+/**
+ * Crypto account link event type literals
+ */
+declare type CryptoAccountLinkEventType = string;
+
+/**
+ * Environment configuration for the SDK
+ */
+export declare type Environment = 'local' | 'dev' | 'cert' | 'prod' | 'sandbox' | 'production';
+
+/**
+ * Generic error codes for all Connect applications
+ */
+export declare enum ErrorCode {
+    /** Network connectivity error */
+    NETWORK_ERROR = 'network_error',
+    /** Authentication or session expired error */
+    AUTH_ERROR = 'auth_error',
+    /** Resource not found error */
+    NOT_FOUND_ERROR = 'not_found_error',
+    /** Validation error from user input */
+    VALIDATION_ERROR = 'validation_error',
+    /** Server error (5xx) */
+    SERVER_ERROR = 'server_error',
+    /** Client error (4xx) */
+    CLIENT_ERROR = 'client_error',
+    /** Unknown or unexpected error */
+    UNKNOWN_ERROR = 'unknown_error',
+}
+
+/**
+ * Generic error payload structure for error callbacks
+ */
+declare type ErrorPayload = {
+    /** Error code indicating the type of error */
+    errorCode: ErrorCode;
+    /** Human-readable reason for the error */
+    reason: string;
+};
+
+/**
+ * Generic HTMLElement representing a web component with custom config
+ */
+declare type SdkElement<Config extends BaseConfig<never>> = HTMLElement & Config;
+
+/**
+ * Internal state of the SDK
+ */
+declare interface SdkState {
+    /** Whether the SDK is initialized */
+    initialized: boolean;
+    /** Whether the web component script is loaded */
+    scriptLoaded: boolean;
+    /** The container element where the widget is rendered */
+    container: HTMLElement | null;
+    /** The web component element */
+    element: HTMLElement | null;
+}
+
+/**
+ * Theme configuration for the SDK
+ *
+ * - `"auto"` - Automatically detect system preference (light/dark mode)
+ * - `"light"` - Force light theme
+ * - `"dark"` - Force dark theme
+ */
+declare type Theme = 'auto' | 'light' | 'dark';
+
+export declare type ZerohashCryptoAccountLinkElement = SdkElement<CryptoAccountLinkConfig>;
+
+export { }

package/dist/index.js

@@ -0,0 +1,200 @@
+const s = "production", c = "JWT token is required and must be a string.";
+class d {
+  config;
+  state;
+  scriptLoadingPromise;
+  constructor(e) {
+    if (!e.jwt || typeof e.jwt != "string")
+      throw new Error(c);
+    this.config = {
+      ...e,
+      env: e.env || s,
+      theme: e.theme
+    }, this.state = {
+      initialized: !1,
+      scriptLoaded: !1,
+      container: null,
+      element: null
+    };
+  }
+  /**
+   * Render the widget to a container element
+   * @param container - The container element to render the widget into
+   * @returns Promise that resolves when the widget is rendered
+   */
+  async render(e) {
+    if (!e || !(e instanceof HTMLElement))
+      throw new Error(this.errorMessages.INVALID_CONTAINER);
+    if (this.state.initialized)
+      throw new Error(this.errorMessages.ALREADY_RENDERED);
+    try {
+      await this.ensureScriptLoaded();
+      const r = this.createWebComponent();
+      e.innerHTML = "", e.appendChild(r), this.state.container = e, this.state.element = r, this.state.initialized = !0;
+    } catch (r) {
+      throw console.error("Failed to render widget:", r), r;
+    }
+  }
+  /**
+   * Update the configuration of the widget
+   * @param config - Partial configuration to update
+   * @returns void
+   */
+  updateConfig(e) {
+    if (!this.state.initialized || !this.state.element)
+      throw new Error(this.errorMessages.NOT_RENDERED);
+    const r = this.state.element;
+    Object.entries(e).forEach(([t, i]) => {
+      i && (this.config[t] = i, r[t] = i);
+    });
+  }
+  /**
+   * Destroy the widget and clean up resources
+   */
+  destroy() {
+    this.state.initialized && (this.state.element && this.state.element.parentNode && this.state.element.parentNode.removeChild(this.state.element), this.state.container && (this.state.container.innerHTML = ""), this.state.container = null, this.state.element = null, this.state.initialized = !1);
+  }
+  /**
+   * Check if the widget is currently rendered
+   * @returns True if the widget is rendered, false otherwise
+   */
+  isRendered() {
+    return this.state.initialized;
+  }
+  /**
+   * Get the current configuration
+   * @returns The current configuration object
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  getEnvironment() {
+    return this.config.env || s;
+  }
+  getScriptId() {
+    return `${this.webComponentTag}-script-${this.getEnvironment()}`;
+  }
+  isScriptLoaded() {
+    return !!document.getElementById(this.getScriptId());
+  }
+  getWebComponent() {
+    return customElements.get(this.webComponentTag);
+  }
+  getScriptUrl() {
+    return this.scriptUrls[this.getEnvironment()];
+  }
+  async loadScript() {
+    if (!this.isScriptLoaded()) {
+      if (this.scriptLoadingPromise)
+        return this.scriptLoadingPromise;
+      this.scriptLoadingPromise = new Promise((e, r) => {
+        const t = document.createElement("script");
+        t.id = this.getScriptId(), t.src = this.getScriptUrl(), t.type = "module", t.async = !0, t.onload = () => {
+          setTimeout(() => {
+            this.getWebComponent() ? e() : r(new Error(this.errorMessages.WEB_COMPONENT_NOT_DEFINED));
+          }, 0);
+        }, t.onerror = () => {
+          this.scriptLoadingPromise = void 0, r(new Error(`${this.errorMessages.SCRIPT_LOAD_FAILED} (${this.getEnvironment()})`));
+        }, document.head.appendChild(t);
+      });
+      try {
+        await this.scriptLoadingPromise;
+      } catch (e) {
+        throw this.scriptLoadingPromise = void 0, e;
+      }
+      return this.scriptLoadingPromise;
+    }
+  }
+  async waitForWebComponent(e = 5e3) {
+    if (!this.getWebComponent())
+      return new Promise((r, t) => {
+        const i = setTimeout(() => {
+          t(new Error(`Timeout waiting for ${this.webComponentTag} to be defined`));
+        }, e);
+        customElements.whenDefined(this.webComponentTag).then(() => {
+          clearTimeout(i), r();
+        }).catch((a) => {
+          clearTimeout(i), t(a);
+        });
+      });
+  }
+  /**
+   * Load the web component script if not already loaded
+   */
+  async ensureScriptLoaded() {
+    if (!this.state.scriptLoaded)
+      try {
+        await this.loadScript(), await this.waitForWebComponent(), this.state.scriptLoaded = !0;
+      } catch (e) {
+        throw console.error("Failed to load Connect script:", e), e;
+      }
+  }
+  createWebComponent() {
+    const e = document.createElement(this.webComponentTag);
+    return Object.entries(this.config).forEach(([r, t]) => {
+      t && (e[r] = t);
+    }), e;
+  }
+}
+var o;
+(function(n) {
+  n.NETWORK_ERROR = "network_error", n.AUTH_ERROR = "auth_error", n.NOT_FOUND_ERROR = "not_found_error", n.VALIDATION_ERROR = "validation_error", n.SERVER_ERROR = "server_error", n.CLIENT_ERROR = "client_error", n.UNKNOWN_ERROR = "unknown_error";
+})(o || (o = {}));
+class h extends d {
+  errorMessages = {
+    ALREADY_RENDERED: "CryptoAccountLink widget is already rendered. Call destroy() before rendering again.",
+    NOT_RENDERED: "CryptoAccountLink widget is not rendered. Call render() first.",
+    INVALID_CONTAINER: "Invalid container element provided.",
+    SCRIPT_LOAD_FAILED: "Failed to load the Connect CryptoAccountLink script.",
+    WEB_COMPONENT_NOT_DEFINED: "Web component is not defined. Script may not be loaded."
+  };
+  scriptUrls = {
+    local: "http://localhost:5173/crypto-account-link-web/index.js",
+    dev: "https://connect-sdk.dev.0hash.com/crypto-account-link-web/index.js",
+    cert: "https://sdk.sandbox.connect.xyz/crypto-account-link-web/index.js",
+    prod: "https://sdk.connect.xyz/crypto-account-link-web/index.js",
+    sandbox: "https://sdk.sandbox.connect.xyz/crypto-account-link-web/index.js",
+    production: "https://sdk.connect.xyz/crypto-account-link-web/index.js"
+  };
+  webComponentTag = "zerohash-crypto-account-link";
+  /**
+   * Render the CryptoAccountLink widget to a container element
+   * @param container - The container element to render the widget into
+   * @returns Promise that resolves when the widget is rendered
+   */
+  render(e) {
+    return super.render(e);
+  }
+  /**
+   * Update the configuration of the CryptoAccountLink widget
+   * @param config - Partial configuration to update
+   */
+  updateConfig(e) {
+    return super.updateConfig(e);
+  }
+  /**
+   * Get the current configuration
+   * @returns The current configuration object
+   */
+  getConfig() {
+    return super.getConfig();
+  }
+  /**
+   * Check if the CryptoAccountLink widget is currently rendered
+   * @returns True if the widget is rendered, false otherwise
+   */
+  isRendered() {
+    return super.isRendered();
+  }
+  /**
+   * Destroy the CryptoAccountLink widget and clean up resources
+   */
+  destroy() {
+    return super.destroy();
+  }
+}
+export {
+  h as CryptoAccountLink,
+  o as ErrorCode,
+  h as default
+};

package/dist/index.umd.cjs

@@ -0,0 +1 @@
+(function(i,o){typeof exports=="object"&&typeof module<"u"?o(exports):typeof define=="function"&&define.amd?define(["exports"],o):(i=typeof globalThis<"u"?globalThis:i||self,o(i.CryptoAccountLink={}))})(this,(function(i){"use strict";const o="production",c="JWT token is required and must be a string.";class d{config;state;scriptLoadingPromise;constructor(e){if(!e.jwt||typeof e.jwt!="string")throw new Error(c);this.config={...e,env:e.env||o,theme:e.theme},this.state={initialized:!1,scriptLoaded:!1,container:null,element:null}}async render(e){if(!e||!(e instanceof HTMLElement))throw new Error(this.errorMessages.INVALID_CONTAINER);if(this.state.initialized)throw new Error(this.errorMessages.ALREADY_RENDERED);try{await this.ensureScriptLoaded();const n=this.createWebComponent();e.innerHTML="",e.appendChild(n),this.state.container=e,this.state.element=n,this.state.initialized=!0}catch(n){throw console.error("Failed to render widget:",n),n}}updateConfig(e){if(!this.state.initialized||!this.state.element)throw new Error(this.errorMessages.NOT_RENDERED);const n=this.state.element;Object.entries(e).forEach(([t,s])=>{s&&(this.config[t]=s,n[t]=s)})}destroy(){this.state.initialized&&(this.state.element&&this.state.element.parentNode&&this.state.element.parentNode.removeChild(this.state.element),this.state.container&&(this.state.container.innerHTML=""),this.state.container=null,this.state.element=null,this.state.initialized=!1)}isRendered(){return this.state.initialized}getConfig(){return{...this.config}}getEnvironment(){return this.config.env||o}getScriptId(){return`${this.webComponentTag}-script-${this.getEnvironment()}`}isScriptLoaded(){return!!document.getElementById(this.getScriptId())}getWebComponent(){return customElements.get(this.webComponentTag)}getScriptUrl(){return this.scriptUrls[this.getEnvironment()]}async loadScript(){if(!this.isScriptLoaded()){if(this.scriptLoadingPromise)return this.scriptLoadingPromise;this.scriptLoadingPromise=new Promise((e,n)=>{const t=document.createElement("script");t.id=this.getScriptId(),t.src=this.getScriptUrl(),t.type="module",t.async=!0,t.onload=()=>{setTimeout(()=>{this.getWebComponent()?e():n(new Error(this.errorMessages.WEB_COMPONENT_NOT_DEFINED))},0)},t.onerror=()=>{this.scriptLoadingPromise=void 0,n(new Error(`${this.errorMessages.SCRIPT_LOAD_FAILED} (${this.getEnvironment()})`))},document.head.appendChild(t)});try{await this.scriptLoadingPromise}catch(e){throw this.scriptLoadingPromise=void 0,e}return this.scriptLoadingPromise}}async waitForWebComponent(e=5e3){if(!this.getWebComponent())return new Promise((n,t)=>{const s=setTimeout(()=>{t(new Error(`Timeout waiting for ${this.webComponentTag} to be defined`))},e);customElements.whenDefined(this.webComponentTag).then(()=>{clearTimeout(s),n()}).catch(h=>{clearTimeout(s),t(h)})})}async ensureScriptLoaded(){if(!this.state.scriptLoaded)try{await this.loadScript(),await this.waitForWebComponent(),this.state.scriptLoaded=!0}catch(e){throw console.error("Failed to load Connect script:",e),e}}createWebComponent(){const e=document.createElement(this.webComponentTag);return Object.entries(this.config).forEach(([n,t])=>{t&&(e[n]=t)}),e}}i.ErrorCode=void 0,(function(r){r.NETWORK_ERROR="network_error",r.AUTH_ERROR="auth_error",r.NOT_FOUND_ERROR="not_found_error",r.VALIDATION_ERROR="validation_error",r.SERVER_ERROR="server_error",r.CLIENT_ERROR="client_error",r.UNKNOWN_ERROR="unknown_error"})(i.ErrorCode||(i.ErrorCode={}));class a extends d{errorMessages={ALREADY_RENDERED:"CryptoAccountLink widget is already rendered. Call destroy() before rendering again.",NOT_RENDERED:"CryptoAccountLink widget is not rendered. Call render() first.",INVALID_CONTAINER:"Invalid container element provided.",SCRIPT_LOAD_FAILED:"Failed to load the Connect CryptoAccountLink script.",WEB_COMPONENT_NOT_DEFINED:"Web component is not defined. Script may not be loaded."};scriptUrls={local:"http://localhost:5173/crypto-account-link-web/index.js",dev:"https://connect-sdk.dev.0hash.com/crypto-account-link-web/index.js",cert:"https://sdk.sandbox.connect.xyz/crypto-account-link-web/index.js",prod:"https://sdk.connect.xyz/crypto-account-link-web/index.js",sandbox:"https://sdk.sandbox.connect.xyz/crypto-account-link-web/index.js",production:"https://sdk.connect.xyz/crypto-account-link-web/index.js"};webComponentTag="zerohash-crypto-account-link";render(e){return super.render(e)}updateConfig(e){return super.updateConfig(e)}getConfig(){return super.getConfig()}isRendered(){return super.isRendered()}destroy(){return super.destroy()}}i.CryptoAccountLink=a,i.default=a,Object.defineProperties(i,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}));

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@zerohash-sdk/crypto-account-link-js",
+  "version": "1.1.0",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "nx": {
+    "name": "crypto-account-link-js"
+  }
+}