npm - @zerohash-sdk/travel-rule-js - Versions diffs - 0.1.0 - Mend

@zerohash-sdk/travel-rule-js 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,7 @@
+# @zerohash-sdk/travel-rule-js
+This library was generated with [Nx](https://nx.dev).
+## Running unit tests
+Run `nx test @zerohash-sdk/travel-rule-js` to execute the unit tests via [Vitest](https://vitest.dev/).

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,513 @@
+/**
+ * Zerohash Travel Rule JavaScript SDK
+ *
+ * A programmatic JavaScript SDK for integrating the Travel Rule 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 'light'
+     *
+     * 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 getEffectiveScriptUrls(): Record<string, string> {
+        // Support local development with Vite: an internal build pins the script
+        // URL for the configured env, bypassing the CDN maps entirely.
+        if (typeof import.meta !== 'undefined' && import.meta.env?.['VITE_INTERNAL_BUILD'] === 'true') {
+            const override = import.meta.env['VITE_SCRIPT_URL'];
+            if (override) return { [this.getEnvironment()]: override };
+        }
+        return this.scriptUrls;
+    }
+    private async loadScript() {
+        // When the element is already defined or another instance's script tag is
+        // in flight, defer to waitForWebComponent — the shared loader would no-op
+        // for those cases and never settle this promise.
+        if (this.getWebComponent() || this.isScriptLoaded()) {
+            return;
+        }
+        if (this.scriptLoadingPromise) {
+            return this.scriptLoadingPromise;
+        }
+        // The shared loader also reports failures to Faro (with JWT claims for
+        // partner/participant context) and removes a failed tag so a later
+        // render() call can retry cleanly.
+        this.scriptLoadingPromise = new Promise<void>((resolve, reject) => {
+            loadWebComponentScript({
+                webComponentTag: this.webComponentTag,
+                appName: this.webComponentTag,
+                scriptUrls: this.getEffectiveScriptUrls(),
+                collectorUrls: FARO_COLLECTOR_URLS,
+                env: this.getEnvironment(),
+                jwt: this.config.jwt,
+                onLoad: resolve,
+                onError: (info) => {
+                    reject(
+                    new Error(
+                    info.reason === 'not-defined'
+                    ? this.errorMessages.WEB_COMPONENT_NOT_DEFINED
+                    : `${this.errorMessages.SCRIPT_LOAD_FAILED} (${this.getEnvironment()})`
+                    )
+                    );
+                },
+            });
+        });
+        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;
+    /**
+     * Called when a deposit reaches a terminal state (success/failure/verifying).
+     * Optional — only SDKs that drive the integrations deposit flow emit it.
+     */
+    onDeposit?: (deposit: DepositCompletedPayload) => void;
+};
+/**
+ * Deposit completed payload — emitted by SDKs that drive a deposit through
+ * the integrations flow. Lives on `CommonCallbacks` because both Auth and
+ * any SDK embedding `@zerohash/integrations-flow` (e.g. fund with `useAuth`)
+ * resolve through the same deposit-status hook.
+ */
+declare type DepositCompletedPayload = {
+    data: {
+        depositId: string;
+        status: DepositStatus;
+        assetId: string;
+        networkId: string;
+        amount?: string;
+        accountMatchingValidation?: {
+            status: 'PENDING' | 'VALID' | 'INVALID' | 'ERROR';
+            reason?: string;
+        };
+    };
+};
+/**
+ * Deposit status object — shared across SDKs that surface deposit completion.
+ */
+declare type DepositStatus = {
+    value: string;
+    details: string;
+    occurredAt: 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';
+/**
+ * TravelRule SDK class for programmatic control of the Zerohash Travel Rule widget.
+ *
+ * Renders the `zerohash-travel-rule` web component, which handles the iframe
+ * and postMessage communication internally.
+ *
+ * @example
+ * ```javascript
+ * const travelRule = new TravelRule({
+ *   jwt: 'your-jwt-token',
+ *   depositId: 'deposit-abc123',
+ *   env: 'prod',
+ *   theme: 'light',
+ *   onCompleted: ({ deposit_id, submitted_at }) => console.log('Submitted', deposit_id, submitted_at),
+ *   onClose: () => console.log('Closed'),
+ *   onError: ({ errorCode, reason }) => console.error(errorCode, reason),
+ * });
+ *
+ * await travelRule.render(document.getElementById('travel-rule-container'));
+ * ```
+ */
+declare class TravelRule extends BaseJsSdk<TravelRuleConfig> {
+    protected errorMessages: {
+        ALREADY_RENDERED: string;
+        NOT_RENDERED: string;
+        INVALID_CONTAINER: string;
+        SCRIPT_LOAD_FAILED: string;
+        WEB_COMPONENT_NOT_DEFINED: string;
+    };
+    protected scriptUrls: Record<string, string>;
+    protected webComponentTag: string;
+    /**
+     * Render the TravelRule 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 TravelRule widget
+     * @param config - Partial configuration to update
+     */
+    updateConfig(config: Partial<TravelRuleConfig>): void;
+    /**
+     * Get the current configuration
+     * @returns The current configuration object
+     */
+    getConfig(): Readonly<TravelRuleConfig>;
+    /**
+     * Check if the TravelRule widget is currently rendered
+     * @returns True if the widget is rendered, false otherwise
+     */
+    isRendered(): boolean;
+    /**
+     * Destroy the TravelRule widget and clean up resources
+     */
+    destroy(): void;
+}
+export { TravelRule }
+export default TravelRule;
+declare type TravelRuleCallbacks = CommonCallbacks<TravelRuleEvent> & {
+    /** Called when the travel-rule flow is successfully completed */
+    onCompleted?: (data: TravelRuleCompletedData) => void;
+};
+declare type TravelRuleCompletedData = {
+    /** Deposit id the travel-rule submission is tied to */
+    deposit_id: string;
+    /** ISO-8601 timestamp of the travel-rule submission */
+    submitted_at: string;
+};
+export declare interface TravelRuleConfig extends BaseConfig<TravelRuleEvent>, TravelRuleCallbacks {
+    /**
+     * Deposit id the travel-rule submission is tied to. Required — every
+     * travel-rule submission is scoped to a specific deposit (TRD §4.1 host
+     * handoff contract). `BaseJsSdk.render` forwards it to the web component.
+     */
+    depositId: string;
+}
+/**
+ * Travel Rule event structure
+ */
+declare type TravelRuleEvent = AppEvent<TravelRuleEventType>;
+/**
+ * Travel Rule event type literals
+ */
+declare type TravelRuleEventType = string;
+export declare type ZerohashTravelRuleElement = SdkElement<TravelRuleConfig>;
+export { }

package/dist/index.js ADDED Viewed

@@ -0,0 +1,346 @@
+const C = "production", M = "JWT token is required and must be a string.", W = {
+  dev: "https://grafana-faro-collector.dev.0hash.com/collect",
+  cert: "https://grafana-faro-collector.cert.zerohash.com/collect",
+  prod: "https://grafana-faro-collector.zerohash.com/collect",
+  "eu-cert": "https://grafana-faro-collector.cert.zerohash.eu/collect",
+  "eu-prod": "https://grafana-faro-collector.zerohash.eu/collect",
+  sandbox: "https://grafana-faro-collector.cert.zerohash.com/collect",
+  production: "https://grafana-faro-collector.zerohash.com/collect"
+}, P = (e) => {
+  if (!e || typeof e != "string")
+    return null;
+  const t = e.split(".");
+  if (t.length < 2)
+    return null;
+  try {
+    const r = t[1].replace(/-/g, "+").replace(/_/g, "/"), o = r + "===".slice(0, (4 - r.length % 4) % 4), n = typeof atob < "u" ? atob(o) : Buffer.from(o, "base64").toString("utf-8"), i = JSON.parse(n)?.payload?.region;
+    if (typeof i != "string")
+      return null;
+    const s = i.toLowerCase();
+    return s === "us" || s === "eu" ? s : null;
+  } catch {
+    return null;
+  }
+}, S = (e, t) => P(t) !== "eu" ? e : e === "cert" ? "eu-cert" : e === "prod" ? "eu-prod" : e, U = (e) => {
+  if (!e || typeof e != "string")
+    return {};
+  const t = e.split(".");
+  if (t.length < 2)
+    return {};
+  try {
+    const r = t[1].replace(/-/g, "+").replace(/_/g, "/"), o = r + "===".slice(0, (4 - r.length % 4) % 4), n = typeof atob < "u" ? atob(o) : Buffer.from(o, "base64").toString("utf-8"), a = JSON.parse(n), i = a?.payload ?? {}, s = (c) => typeof c == "string" && c.length > 0 ? c : void 0;
+    return {
+      participantCode: s(i.participant_code),
+      platformName: s(i.platform_name),
+      platformCode: s(a.platform_code),
+      region: s(i.region)
+    };
+  } catch {
+    return {};
+  }
+}, N = (e, t, r) => {
+  const o = S(t, r);
+  return e[o] ?? e[t] ?? e.prod;
+}, k = (e, t, r) => {
+  const o = S(t, r);
+  return e[o] ?? e[t];
+}, w = () => {
+}, F = () => {
+  const e = new Uint8Array(8);
+  return globalThis.crypto.getRandomValues(e), Array.from(e, (t) => t.toString(16).padStart(2, "0")).join("");
+}, $ = (e, t) => {
+  const r = F(), o = globalThis.__ZH_WEB_SDK_VERSION__, n = {};
+  e.claims.participantCode && (n.participant_code = e.claims.participantCode), e.claims.platformName && (n.platform_name = e.claims.platformName), e.claims.platformCode && (n.platform_code = e.claims.platformCode), e.claims.region && (n.region = e.claims.region), o && (n.zh_web_sdk_version = o);
+  const a = {
+    meta: {
+      app: { name: e.appName, version: t ?? "unknown", environment: e.env },
+      session: { id: r, attributes: n },
+      browser: typeof navigator < "u" ? { userAgent: navigator.userAgent } : void 0,
+      page: typeof window < "u" ? { url: window.location.origin } : void 0
+    },
+    logs: [
+      {
+        message: `Failed to load the script for ${e.webComponentTag} from ${e.env} environment.`,
+        level: "error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        context: {
+          web_component: e.webComponentTag,
+          script_url: e.scriptUrl,
+          reason: e.reason,
+          tried_fallback: String(e.triedFallback),
+          elapsed_ms: String(e.elapsedMs)
+        }
+      }
+    ]
+  };
+  return { sessionId: r, payload: a };
+}, B = (e, t, r) => {
+  if (!e || typeof fetch > "u")
+    return;
+  const { sessionId: o, payload: n } = $(t, r);
+  try {
+    fetch(e, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-faro-session-id": o },
+      body: JSON.stringify(n),
+      keepalive: !0
+    }).catch(() => {
+    });
+  } catch {
+  }
+}, V = (e) => {
+  const { webComponentTag: t, appName: r, appVersion: o, scriptUrls: n, fallbackScriptUrls: a, collectorUrls: i, env: s, jwt: c, timeoutMs: O = 15e3, onLoad: L, onError: I } = e;
+  if (typeof document > "u")
+    return w;
+  const h = `${t}-script-${s}`;
+  if (customElements.get(t) || document.getElementById(h))
+    return w;
+  const A = U(c), D = e.report ?? ((l) => B(i && k(i, s, c), l, o));
+  let m = !1, R = 0, g;
+  const f = () => {
+    g !== void 0 && clearTimeout(g);
+  }, E = (l, u, d) => {
+    if (m)
+      return;
+    const z = Math.round(performance.now() - R), y = {
+      webComponentTag: t,
+      appName: r,
+      env: s,
+      scriptUrl: u,
+      reason: l,
+      triedFallback: d,
+      elapsedMs: z,
+      claims: A
+    };
+    D(y);
+    const _ = d ? void 0 : N(a ?? {}, s, c);
+    if (_ && _ !== u) {
+      b(_, !0);
+      return;
+    }
+    m = !0, f(), document.getElementById(h)?.remove(), I?.(y);
+  }, b = (l, u) => {
+    f(), R = performance.now();
+    const d = document.createElement("script");
+    d.id = h, d.src = l, d.type = "module", d.async = !0, d.onload = () => {
+      setTimeout(() => {
+        m || (customElements.get(t) ? (m = !0, f(), L?.()) : E("not-defined", l, u));
+      }, 0);
+    }, d.onerror = () => E("network", l, u), g = setTimeout(() => E("timeout", l, u), O), document.getElementById(h)?.remove(), document.head.appendChild(d);
+  }, T = N(n, s, c);
+  return T ? (b(T, !1), () => {
+    m = !0, f();
+  }) : w;
+};
+class j {
+  config;
+  state;
+  scriptLoadingPromise;
+  constructor(t) {
+    if (!t.jwt || typeof t.jwt != "string")
+      throw new Error(M);
+    this.config = {
+      ...t,
+      env: t.env || C,
+      theme: t.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(t) {
+    if (!t || !(t 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();
+      t.innerHTML = "", t.appendChild(r), this.state.container = t, 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(t) {
+    if (!this.state.initialized || !this.state.element)
+      throw new Error(this.errorMessages.NOT_RENDERED);
+    const r = this.state.element;
+    Object.entries(t).forEach(([o, n]) => {
+      n && (this.config[o] = n, r[o] = n);
+    });
+  }
+  /**
+   * 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 || C;
+  }
+  getScriptId() {
+    return `${this.webComponentTag}-script-${this.getEnvironment()}`;
+  }
+  isScriptLoaded() {
+    return !!document.getElementById(this.getScriptId());
+  }
+  getWebComponent() {
+    return customElements.get(this.webComponentTag);
+  }
+  getEffectiveScriptUrls() {
+    return this.scriptUrls;
+  }
+  async loadScript() {
+    if (!(this.getWebComponent() || this.isScriptLoaded())) {
+      if (this.scriptLoadingPromise)
+        return this.scriptLoadingPromise;
+      this.scriptLoadingPromise = new Promise((t, r) => {
+        V({
+          webComponentTag: this.webComponentTag,
+          appName: this.webComponentTag,
+          scriptUrls: this.getEffectiveScriptUrls(),
+          collectorUrls: W,
+          env: this.getEnvironment(),
+          jwt: this.config.jwt,
+          onLoad: t,
+          onError: (o) => {
+            r(new Error(o.reason === "not-defined" ? this.errorMessages.WEB_COMPONENT_NOT_DEFINED : `${this.errorMessages.SCRIPT_LOAD_FAILED} (${this.getEnvironment()})`));
+          }
+        });
+      });
+      try {
+        await this.scriptLoadingPromise;
+      } catch (t) {
+        throw this.scriptLoadingPromise = void 0, t;
+      }
+      return this.scriptLoadingPromise;
+    }
+  }
+  async waitForWebComponent(t = 5e3) {
+    if (!this.getWebComponent())
+      return new Promise((r, o) => {
+        const n = setTimeout(() => {
+          o(new Error(`Timeout waiting for ${this.webComponentTag} to be defined`));
+        }, t);
+        customElements.whenDefined(this.webComponentTag).then(() => {
+          clearTimeout(n), r();
+        }).catch((a) => {
+          clearTimeout(n), o(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 (t) {
+        throw console.error("Failed to load Connect script:", t), t;
+      }
+  }
+  createWebComponent() {
+    const t = document.createElement(this.webComponentTag);
+    return Object.entries(this.config).forEach(([r, o]) => {
+      o && (t[r] = o);
+    }), t;
+  }
+}
+const p = {
+  local: "http://localhost:5173",
+  dev: "https://sdk-cdn.dev.0hash.com",
+  cert: "https://sdk-cdn.cert.zerohash.com",
+  prod: "https://sdk-cdn.zerohash.com",
+  "eu-cert": "https://sdk-cdn.cert.zerohash.eu",
+  "eu-prod": "https://sdk-cdn.zerohash.eu"
+}, J = (e, t, r = {}) => {
+  const { eu: o = !1, legacyAliases: n = !1, local: a = p.local } = r, i = (c) => `${c}/${e}/${t}`, s = {
+    local: i(a),
+    dev: i(p.dev),
+    cert: i(p.cert),
+    prod: i(p.prod)
+  };
+  return n && (s.sandbox = i(p.cert), s.production = i(p.prod)), o && (s["eu-cert"] = i(p["eu-cert"]), s["eu-prod"] = i(p["eu-prod"])), s;
+};
+var v;
+(function(e) {
+  e.NETWORK_ERROR = "network_error", e.AUTH_ERROR = "auth_error", e.NOT_FOUND_ERROR = "not_found_error", e.VALIDATION_ERROR = "validation_error", e.SERVER_ERROR = "server_error", e.CLIENT_ERROR = "client_error", e.UNKNOWN_ERROR = "unknown_error";
+})(v || (v = {}));
+class x extends j {
+  errorMessages = {
+    ALREADY_RENDERED: "TravelRule widget is already rendered. Call destroy() before rendering again.",
+    NOT_RENDERED: "TravelRule widget is not rendered. Call render() first.",
+    INVALID_CONTAINER: "Invalid container element provided.",
+    SCRIPT_LOAD_FAILED: "Failed to load the Zerohash TravelRule script.",
+    WEB_COMPONENT_NOT_DEFINED: "Web component is not defined. Script may not be loaded."
+  };
+  scriptUrls = J("travel-rule-web", "index.js", { legacyAliases: !0, eu: !0 });
+  webComponentTag = "zerohash-travel-rule";
+  /**
+   * Render the TravelRule 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(t) {
+    return super.render(t);
+  }
+  /**
+   * Update the configuration of the TravelRule widget
+   * @param config - Partial configuration to update
+   */
+  updateConfig(t) {
+    return super.updateConfig(t);
+  }
+  /**
+   * Get the current configuration
+   * @returns The current configuration object
+   */
+  getConfig() {
+    return super.getConfig();
+  }
+  /**
+   * Check if the TravelRule widget is currently rendered
+   * @returns True if the widget is rendered, false otherwise
+   */
+  isRendered() {
+    return super.isRendered();
+  }
+  /**
+   * Destroy the TravelRule widget and clean up resources
+   */
+  destroy() {
+    return super.destroy();
+  }
+}
+export {
+  v as ErrorCode,
+  x as TravelRule,
+  x as default
+};

package/dist/index.umd.cjs ADDED Viewed

@@ -0,0 +1 @@

package/package.json ADDED Viewed

@@ -0,0 +1,26 @@
+{
+  "name": "@zerohash-sdk/travel-rule-js",
+  "version": "0.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",
+      "require": "./dist/index.umd.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "nx": {
+    "name": "travel-rule-js"
+  }
+}