npm - @nevermined-io/ui-widgets - Versions diffs - 0.3.1 - Mend

@nevermined-io/ui-widgets 0.3.1

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 (4) hide show

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,345 @@
+export declare interface CardAction {
+    /** Currently the only emitted action; reserved as a discriminator for future ones. */
+    action: 'delegate';
+    paymentMethodId: string;
+}
+export declare interface CheckoutOptions {
+    did: string;
+    planId?: string;
+    container?: HTMLElement;
+    onBooted?: () => void;
+    onReady?: () => void;
+    onSuccess?: (result: CheckoutResult) => void;
+    onError?: (error: EmbedError) => void;
+    onClose?: () => void;
+}
+export declare interface CheckoutResult {
+    did: string;
+    planId?: string;
+    txHash?: string;
+}
+/**
+ * Checkout widget.
+ *
+ * Lifecycle note for SDK consumers: when the iframe sends `nvm:close` the
+ * widget instance auto-calls `destroy()` and becomes terminal — any
+ * subsequent `start()` call throws. If the host page needs to re-show the
+ * checkout after a close, construct a new `CheckoutWidget` (typically via
+ * `nvm.checkout`) and call `start()` on the fresh instance.
+ */
+export declare class CheckoutWidget {
+    private readonly session;
+    private readonly webappBase;
+    private manager;
+    private destroyed;
+    constructor(session: SessionManager, webappBase: string);
+    /**
+     * Mounts the checkout iframe into `options.container`.
+     * Throws if called after `destroy()` (including the implicit destroy on
+     * `nvm:close` — see class JSDoc).
+     */
+    start(options: CheckoutOptions): void;
+    destroy(): void;
+    private handleMessage;
+}
+export declare interface CreateDelegationOptions {
+    paymentMethodId: string;
+    container?: HTMLElement;
+    onBooted?: () => void;
+    onReady?: () => void;
+    onSuccess?: (result: CreateDelegationResult) => void;
+    onError?: (error: EmbedError) => void;
+    onClose?: () => void;
+}
+export declare interface CreateDelegationResult {
+    delegationId: string;
+    paymentMethodId: string;
+}
+export declare function createMessage<T>(type: WidgetMessageType, payload?: T): WidgetMessage<T>;
+/**
+ * Card and delegation management widget.
+ *
+ * Surfaces three iframe-based flows (enrollment, listing, delegation creation)
+ * and two SDK-direct revocations. The three iframe flows share the single
+ * `manager` slot — calling any of them destroys the previously-mounted iframe
+ * (same semantics as calling `enrollCard()` twice). Once any iframe is closed
+ * by the user (`nvm:close`), the instance is implicitly destroyed and any
+ * subsequent iframe call throws. Construct a fresh widget (via
+ * `nvm.delegations`) to mount another flow after a close.
+ *
+ * The two `revoke*` methods do NOT use an iframe — they hit the
+ * `/api/v1/widgets/...` endpoints directly with the widget session token.
+ * They exist because the SDK consumer on the host page only holds the widget
+ * session token; the apiKeyHash that gates the standard delegation/payment
+ * endpoints never leaves the embedded iframe.
+ */
+export declare class DelegationsWidget {
+    private readonly session;
+    private readonly webappBase;
+    private readonly apiBase;
+    private manager;
+    private destroyed;
+    constructor(session: SessionManager, webappBase: string, apiBase: string);
+    /**
+     * Mounts the enrollment iframe at `/embed/cards/enroll`.
+     * Throws if called after `destroy()` (including the implicit destroy on
+     * `nvm:close` — see class JSDoc).
+     */
+    enrollCard(options: EnrollCardOptions): void;
+    /**
+     * Mounts the cards-list iframe at `/embed/cards/list`. Per-row actions
+     * (currently only "Create Delegation") are forwarded via `onCardAction` so
+     * the host can mount the appropriate follow-up widget.
+     */
+    listCards(options: ListCardsOptions): void;
+    /**
+     * Mounts the delegation creation iframe at `/embed/cards/delegate` for a
+     * specific payment method. The `paymentMethodId` is required and is passed
+     * as a search param so the embed route can scope the form to that card.
+     */
+    createDelegation(options: CreateDelegationOptions): void;
+    /**
+     * Revoke (detach) a payment method via the widget-prefixed API endpoint.
+     * Resolves on 2xx; throws `WidgetApiError` on any other response or
+     * network failure.
+     */
+    revokeCard(paymentMethodId: string): Promise<void>;
+    /**
+     * Revoke a delegation via the widget-prefixed API endpoint.
+     * Resolves on 2xx; throws `WidgetApiError` on any other response or
+     * network failure.
+     */
+    revokeDelegation(delegationId: string): Promise<void>;
+    destroy(): void;
+    private assertAlive;
+    private mountIframe;
+    private postInitOnBooted;
+    private handleEnrollMessage;
+    private handleListMessage;
+    private handleCreateDelegationMessage;
+    private deleteWithSession;
+}
+export declare interface EmbedError {
+    code: 'UNAUTHORIZED' | 'NETWORK' | 'PAYMENT_NOT_CONFIRMED' | 'UNKNOWN';
+    message: string;
+    status?: number;
+    apiCode?: string;
+}
+export declare interface EnrollCardOptions {
+    container?: HTMLElement;
+    onBooted?: () => void;
+    onReady?: () => void;
+    onSuccess?: (result: EnrollCardResult) => void;
+    onError?: (error: EmbedError) => void;
+    onClose?: () => void;
+}
+export declare interface EnrollCardResult {
+    paymentMethodId: string;
+}
+export declare type Environment = (typeof ENVIRONMENTS)[number];
+declare const ENVIRONMENTS: readonly ["local", "sandbox", "live", "staging_sandbox", "staging_live"];
+declare type EventHandler<T> = (payload: T) => void;
+export declare class IframeManager {
+    private expectedOrigin;
+    private iframe;
+    private messageHandlers;
+    private protocolErrorHandlers;
+    private messageListener;
+    private destroyed;
+    constructor(expectedOrigin: string);
+    create(url: string, options?: IframeOptions): HTMLIFrameElement;
+    destroy(): void;
+    postMessage(msg: WidgetMessage): void;
+    onMessage(handler: (msg: WidgetMessage) => void): () => void;
+    onProtocolError(handler: (reason: string) => void): () => void;
+    private ensureListener;
+}
+export declare interface IframeOptions {
+    container?: HTMLElement;
+    style?: Partial<CSSStyleDeclaration>;
+}
+export declare interface ListCardsOptions {
+    container?: HTMLElement;
+    onBooted?: () => void;
+    onReady?: () => void;
+    onCardAction?: (action: CardAction) => void;
+    onError?: (error: EmbedError) => void;
+    onClose?: () => void;
+}
+export declare class NeverminedWidgets {
+    private readonly sessionManager;
+    private readonly _account;
+    private readonly environment;
+    private _checkout;
+    private _delegations;
+    private readonly events;
+    private constructor();
+    static initialize(config: WidgetConfig): Promise<NeverminedWidgets>;
+    private refreshSession;
+    on<K extends keyof NeverminedWidgetsEvents>(event: K, handler: (payload: NeverminedWidgetsEvents[K]) => void): this;
+    off<K extends keyof NeverminedWidgetsEvents>(event: K, handler: (payload: NeverminedWidgetsEvents[K]) => void): this;
+    get account(): WidgetAccount;
+    get hasValidSession(): boolean;
+    getSessionToken(): string;
+    get checkout(): CheckoutWidget;
+    get delegations(): DelegationsWidget;
+    /**
+     * Resets the parent widget container: tears down any live child widget (e.g.
+     * the checkout widget) and clears the internal cache. This is a reset, not a
+     * terminal state — accessing `widget.checkout` after `destroy()` lazily
+     * creates a fresh `CheckoutWidget` instance. If you need a terminal "this
+     * widget can no longer be used" semantics, call `destroy()` on the child
+     * widget directly (e.g. `widget.checkout.destroy()`), which flips its
+     * internal `destroyed` flag and makes subsequent `start()` calls throw.
+     */
+    destroy(): void;
+}
+declare interface NeverminedWidgetsEvents {
+    'session-expired': void;
+}
+export declare function parseMessage(data: unknown): ParseResult;
+export declare type ParseResult<T = unknown> = {
+    ok: true;
+    message: WidgetMessage<T>;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare class SessionManager {
+    private session;
+    private expiresMs;
+    private timer;
+    constructor(session: WidgetSession);
+    isValid(): boolean;
+    getToken(): string;
+    getSession(): WidgetSession;
+    startAutoRefresh(refreshFn: () => Promise<WidgetSession>, onExpired: () => void): void;
+    stopAutoRefresh(): void;
+}
+export declare class TypedEventEmitter<Events extends object> {
+    private listeners;
+    on<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): this;
+    off<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): this;
+    once<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): this;
+    removeAllListeners(event?: keyof Events): this;
+    emit<K extends keyof Events>(event: K, payload: Events[K]): void;
+}
+declare const WIDGET_ERRORS: {
+    readonly MISSING_INIT_TOKEN: {
+        readonly numericCode: "WDG.0001";
+        readonly message: "initToken is required and must be a non-empty string";
+    };
+    readonly INVALID_ENVIRONMENT: {
+        readonly numericCode: "WDG.0002";
+        readonly message: "environment must be one of: sandbox, live, staging_sandbox, staging_live, local";
+    };
+    readonly INVALID_INIT_TOKEN: {
+        readonly numericCode: "WDG.0003";
+        readonly message: "Init token is invalid or expired";
+    };
+    readonly INVALID_RESPONSE: {
+        readonly numericCode: "WDG.0004";
+        readonly message: "Server response is missing required fields";
+    };
+    readonly NETWORK_ERROR: {
+        readonly numericCode: "WDG.0005";
+        readonly message: "Network request failed";
+    };
+    readonly SESSION_EXPIRED: {
+        readonly numericCode: "WDG.0006";
+        readonly message: "Widget session has expired";
+    };
+};
+export declare const WIDGET_MESSAGE_VERSION: "1";
+export declare interface WidgetAccount {
+    userId: string;
+    userWallet: `0x${string}`;
+}
+/**
+ * Thrown by SDK methods that hit the API directly (no iframe), e.g.
+ * `delegations.revokeCard()` / `delegations.revokeDelegation()`. Carries the
+ * HTTP status and the optional BCK error code so consumers can branch on
+ * 401/403/etc. without parsing the message.
+ */
+export declare class WidgetApiError extends Error {
+    readonly status?: number | undefined;
+    readonly apiCode?: string | undefined;
+    constructor(message: string, status?: number | undefined, apiCode?: string | undefined);
+}
+export declare interface WidgetConfig {
+    initToken: string;
+    environment: Environment;
+}
+declare type WidgetErrorCode = keyof typeof WIDGET_ERRORS;
+export declare class WidgetInitError extends Error {
+    readonly code: WidgetErrorCode;
+    constructor(code: WidgetErrorCode, message?: string, cause?: unknown);
+}
+export declare interface WidgetMessage<T = unknown> {
+    type: WidgetMessageType;
+    version: '1';
+    payload?: T;
+}
+export declare enum WidgetMessageType {
+    INIT = "nvm:init",
+    CLOSE = "nvm:close",
+    BOOTED = "nvm:booted",
+    READY = "nvm:ready",
+    RESIZE = "nvm:resize",
+    SUCCESS = "nvm:success",
+    ERROR = "nvm:error",
+    CARD_ACTION = "nvm:card-action"
+}
+export declare interface WidgetSession {
+    sessionToken: string;
+    userId: string;
+    userWallet: `0x${string}`;
+    /**
+     * Hash of the NVM API key bound to this widget session user. Returned by
+     * `POST /api/v1/widgets/session` so host pages that want to call user-scoped
+     * endpoints directly (outside the iframe) have the bearer token to do so.
+     * The embedded iframe flow consumes it via the session JWT claims rather
+     * than this field.
+     */
+    apiKeyHash: string;
+    expiresAt: string;
+}
+export declare class WidgetSessionExpiredError extends Error {
+    readonly code: "SESSION_EXPIRED";
+    constructor();
+}
+export { }

package/dist/index.js ADDED Viewed

@@ -0,0 +1 @@

package/dist/index.mjs ADDED Viewed

@@ -0,0 +1,510 @@
+//#region src/types.ts
+var e = [
+	"local",
+	"sandbox",
+	"live",
+	"staging_sandbox",
+	"staging_live"
+], t = {
+	local: "http://localhost:3001",
+	sandbox: "https://api.sandbox.nevermined.app",
+	live: "https://api.live.nevermined.app",
+	staging_sandbox: "https://api.sandbox.nevermined.dev",
+	staging_live: "https://api.live.nevermined.dev"
+}, n = {
+	local: "http://localhost:4200",
+	sandbox: "https://nevermined.app",
+	live: "https://nevermined.app",
+	staging_sandbox: "https://nevermined.dev",
+	staging_live: "https://nevermined.dev"
+};
+function r(e) {
+	return t[e];
+}
+function i(e) {
+	return n[e];
+}
+//#endregion
+//#region src/utils/errors.ts
+var a = {
+	MISSING_INIT_TOKEN: {
+		numericCode: "WDG.0001",
+		message: "initToken is required and must be a non-empty string"
+	},
+	INVALID_ENVIRONMENT: {
+		numericCode: "WDG.0002",
+		message: "environment must be one of: sandbox, live, staging_sandbox, staging_live, local"
+	},
+	INVALID_INIT_TOKEN: {
+		numericCode: "WDG.0003",
+		message: "Init token is invalid or expired"
+	},
+	INVALID_RESPONSE: {
+		numericCode: "WDG.0004",
+		message: "Server response is missing required fields"
+	},
+	NETWORK_ERROR: {
+		numericCode: "WDG.0005",
+		message: "Network request failed"
+	},
+	SESSION_EXPIRED: {
+		numericCode: "WDG.0006",
+		message: "Widget session has expired"
+	}
+}, o = class extends Error {
+	constructor(e, t, n) {
+		super(t ?? a[e].message, { cause: n }), this.code = e, this.name = "WidgetInitError";
+	}
+}, s = class extends Error {
+	code = "SESSION_EXPIRED";
+	constructor() {
+		super(a.SESSION_EXPIRED.message), this.name = "WidgetSessionExpiredError";
+	}
+}, c = class extends Error {
+	constructor(e, t, n) {
+		super(e), this.status = t, this.apiCode = n, this.name = "WidgetApiError";
+	}
+}, l = .8, u = class {
+	session;
+	expiresMs;
+	timer = null;
+	constructor(e) {
+		this.session = e, this.expiresMs = new Date(e.expiresAt).getTime(), Number.isNaN(this.expiresMs) && console.warn("[SessionManager] malformed expiresAt, session will be treated as expired:", e.expiresAt);
+	}
+	isValid() {
+		return !Number.isNaN(this.expiresMs) && this.expiresMs > Date.now();
+	}
+	getToken() {
+		return this.session.sessionToken;
+	}
+	getSession() {
+		return this.session;
+	}
+	startAutoRefresh(e, t) {
+		if (this.stopAutoRefresh(), !this.isValid()) {
+			t();
+			return;
+		}
+		let n = Math.max(0, Math.floor((this.expiresMs - Date.now()) * l));
+		this.timer = setTimeout(() => {
+			this.timer = null, e().then((n) => {
+				if (this.session = n, this.expiresMs = new Date(n.expiresAt).getTime(), !this.isValid()) {
+					t();
+					return;
+				}
+				this.startAutoRefresh(e, t);
+			}, (e) => {
+				console.error("[SessionManager] session refresh failed:", e), t();
+			});
+		}, n);
+	}
+	stopAutoRefresh() {
+		this.timer !== null && (clearTimeout(this.timer), this.timer = null);
+	}
+}, d = class {
+	listeners = /* @__PURE__ */ new Map();
+	on(e, t) {
+		let n = this.listeners.get(e) ?? /* @__PURE__ */ new Set();
+		return n.add(t), this.listeners.set(e, n), this;
+	}
+	off(e, t) {
+		let n = this.listeners.get(e);
+		return n ? (n.delete(t), n.size === 0 && this.listeners.delete(e), this) : this;
+	}
+	once(e, t) {
+		let n = (r) => {
+			this.off(e, n), t(r);
+		};
+		return this.on(e, n);
+	}
+	removeAllListeners(e) {
+		return e === void 0 ? this.listeners.clear() : this.listeners.delete(e), this;
+	}
+	emit(e, t) {
+		let n = this.listeners.get(e);
+		n && [...n].forEach((e) => {
+			try {
+				e(t);
+			} catch (e) {
+				console.error("[TypedEventEmitter] Handler threw:", e);
+			}
+		});
+	}
+}, f = /* @__PURE__ */ function(e) {
+	return e.INIT = "nvm:init", e.CLOSE = "nvm:close", e.BOOTED = "nvm:booted", e.READY = "nvm:ready", e.RESIZE = "nvm:resize", e.SUCCESS = "nvm:success", e.ERROR = "nvm:error", e.CARD_ACTION = "nvm:card-action", e;
+}({}), p = "1", m = "1";
+function h(e) {
+	return typeof e == "string" && Object.values(f).includes(e);
+}
+function g(e, t) {
+	return {
+		type: e,
+		version: m,
+		payload: t
+	};
+}
+function _(e) {
+	if (typeof e != "object" || !e) return {
+		ok: !1,
+		reason: "not an object"
+	};
+	let t = e;
+	return h(t.type) ? t.version === m ? {
+		ok: !0,
+		message: {
+			type: t.type,
+			version: t.version,
+			payload: t.payload
+		}
+	} : {
+		ok: !1,
+		reason: `version mismatch: received "${t.version}", expected "${m}"`
+	} : {
+		ok: !1,
+		reason: typeof t.type == "string" && t.type.startsWith("nvm:") ? `unknown nvm: type "${t.type}"` : "missing or unknown type"
+	};
+}
+//#endregion
+//#region src/iframe-manager.ts
+var v = class {
+	iframe = null;
+	messageHandlers = /* @__PURE__ */ new Set();
+	protocolErrorHandlers = /* @__PURE__ */ new Set();
+	messageListener = null;
+	destroyed = !1;
+	constructor(e) {
+		if (this.expectedOrigin = e, e === "*") throw Error("[IframeManager] Wildcard origin \"*\" is not allowed — pass an explicit origin");
+	}
+	create(e, t) {
+		this.iframe?.remove();
+		let n = document.createElement("iframe");
+		return n.src = e, n.style.width = "100%", n.style.height = "100%", n.style.border = "none", n.style.display = "block", n.setAttribute("sandbox", "allow-scripts allow-same-origin allow-forms"), t?.container || (n.style.position = "fixed", n.style.top = "0", n.style.left = "0", n.style.right = "0", n.style.bottom = "0", n.style.zIndex = "9999"), t?.style && Object.assign(n.style, t.style), (t?.container ?? document.body).appendChild(n), this.iframe = n, n;
+	}
+	destroy() {
+		this.destroyed = !0, this.messageListener &&= (window.removeEventListener("message", this.messageListener), null), this.messageHandlers.clear(), this.protocolErrorHandlers.clear(), this.iframe?.remove(), this.iframe = null;
+	}
+	postMessage(e) {
+		this.destroyed || this.iframe?.contentWindow?.postMessage(e, this.expectedOrigin);
+	}
+	onMessage(e) {
+		return this.destroyed ? () => void 0 : (this.messageHandlers.add(e), this.ensureListener(), () => this.messageHandlers.delete(e));
+	}
+	onProtocolError(e) {
+		return this.destroyed ? () => void 0 : (this.protocolErrorHandlers.add(e), this.ensureListener(), () => this.protocolErrorHandlers.delete(e));
+	}
+	ensureListener() {
+		this.messageListener || (this.messageListener = (e) => {
+			if (e.origin !== this.expectedOrigin) return;
+			let t = _(e.data);
+			if (!t.ok) {
+				console.warn(`[IframeManager] Discarding message from ${this.expectedOrigin}: ${t.reason}`), this.protocolErrorHandlers.forEach((e) => {
+					try {
+						e(t.reason);
+					} catch (e) {
+						console.error("[IframeManager] Protocol error handler threw:", e);
+					}
+				});
+				return;
+			}
+			this.messageHandlers.forEach((e) => {
+				try {
+					e(t.message);
+				} catch (e) {
+					console.error("[IframeManager] Message handler threw:", e);
+				}
+			});
+		}, window.addEventListener("message", this.messageListener));
+	}
+}, y = {
+	code: "UNKNOWN",
+	message: "Unknown widget error"
+}, b = class {
+	manager = null;
+	destroyed = !1;
+	constructor(e, t) {
+		this.session = e, this.webappBase = t;
+	}
+	start(e) {
+		if (this.destroyed) throw Error("[CheckoutWidget] cannot start: instance has been destroyed");
+		if (!e.did || typeof e.did != "string") throw Error("[CheckoutWidget] did is required");
+		this.manager?.destroy();
+		let t = new URL(this.webappBase).origin, n = window.location.origin, r = new URL(`/embed/checkout/${encodeURIComponent(e.did)}`, this.webappBase);
+		r.searchParams.set("parentOrigin", n), e.planId && r.searchParams.set("planId", e.planId);
+		let i = new v(t);
+		this.manager = i, i.create(r.toString(), { container: e.container }), i.onMessage((t) => this.handleMessage(t, e));
+	}
+	destroy() {
+		this.destroyed = !0, this.manager?.destroy(), this.manager = null;
+	}
+	handleMessage(e, t) {
+		switch (e.type) {
+			case f.BOOTED:
+				this.manager?.postMessage(g(f.INIT, { sessionToken: this.session.getToken() })), t.onBooted?.();
+				return;
+			case f.READY:
+				t.onReady?.();
+				return;
+			case f.SUCCESS: {
+				let n = e.payload ?? {};
+				t.onSuccess?.({
+					did: n.did ?? t.did,
+					planId: n.planId ?? t.planId,
+					txHash: n.txHash
+				});
+				return;
+			}
+			case f.ERROR: {
+				let n = e.payload;
+				t.onError?.(n?.error ?? y);
+				return;
+			}
+			case f.CLOSE:
+				t.onClose?.(), this.destroy();
+				return;
+			default: return;
+		}
+	}
+}, x = {
+	code: "UNKNOWN",
+	message: "Unknown widget error"
+}, S = {
+	code: "UNKNOWN",
+	message: "Malformed nvm:success payload — paymentMethodId missing or invalid"
+}, C = {
+	code: "UNKNOWN",
+	message: "Malformed nvm:success payload — delegationId missing or invalid"
+}, w = class {
+	manager = null;
+	destroyed = !1;
+	constructor(e, t, n) {
+		this.session = e, this.webappBase = t, this.apiBase = n;
+	}
+	enrollCard(e) {
+		this.assertAlive("enrollCard"), this.mountIframe("/embed/cards/enroll", e.container).onMessage((t) => this.handleEnrollMessage(t, e));
+	}
+	listCards(e) {
+		this.assertAlive("listCards"), this.mountIframe("/embed/cards/list", e.container).onMessage((t) => this.handleListMessage(t, e));
+	}
+	createDelegation(e) {
+		if (this.assertAlive("createDelegation"), typeof e.paymentMethodId != "string" || e.paymentMethodId.length === 0) throw Error("[DelegationsWidget] createDelegation: paymentMethodId is required");
+		this.mountIframe("/embed/cards/delegate", e.container, { paymentMethodId: e.paymentMethodId }).onMessage((t) => this.handleCreateDelegationMessage(t, e));
+	}
+	async revokeCard(e) {
+		if (typeof e != "string" || e.length === 0) throw Error("[DelegationsWidget] revokeCard: paymentMethodId is required");
+		await this.deleteWithSession(`${this.apiBase}/api/v1/widgets/payment-methods/${encodeURIComponent(e)}`, "Failed to revoke payment method");
+	}
+	async revokeDelegation(e) {
+		if (typeof e != "string" || e.length === 0) throw Error("[DelegationsWidget] revokeDelegation: delegationId is required");
+		await this.deleteWithSession(`${this.apiBase}/api/v1/widgets/delegation/${encodeURIComponent(e)}`, "Failed to revoke delegation");
+	}
+	destroy() {
+		this.destroyed = !0, this.manager?.destroy(), this.manager = null;
+	}
+	assertAlive(e) {
+		if (this.destroyed) throw Error(`[DelegationsWidget] cannot ${e}: instance has been destroyed`);
+	}
+	mountIframe(e, t, n = {}) {
+		this.manager?.destroy();
+		let r = new URL(this.webappBase).origin, i = window.location.origin, a = new URL(e, this.webappBase);
+		a.searchParams.set("parentOrigin", i);
+		for (let [e, t] of Object.entries(n)) a.searchParams.set(e, t);
+		let o = new v(r);
+		return this.manager = o, o.create(a.toString(), { container: t }), o;
+	}
+	postInitOnBooted() {
+		this.manager?.postMessage(g(f.INIT, { sessionToken: this.session.getToken() }));
+	}
+	handleEnrollMessage(e, t) {
+		switch (e.type) {
+			case f.BOOTED:
+				this.postInitOnBooted(), t.onBooted?.();
+				return;
+			case f.READY:
+				t.onReady?.();
+				return;
+			case f.SUCCESS: {
+				let n = (e.payload ?? {}).paymentMethodId;
+				if (typeof n != "string" || n.length === 0) {
+					t.onError?.(S);
+					return;
+				}
+				t.onSuccess?.({ paymentMethodId: n });
+				return;
+			}
+			case f.ERROR: {
+				let n = e.payload;
+				t.onError?.(n?.error ?? x);
+				return;
+			}
+			case f.CLOSE:
+				t.onClose?.(), this.destroy();
+				return;
+			default: return;
+		}
+	}
+	handleListMessage(e, t) {
+		switch (e.type) {
+			case f.BOOTED:
+				this.postInitOnBooted(), t.onBooted?.();
+				return;
+			case f.READY:
+				t.onReady?.();
+				return;
+			case f.CARD_ACTION: {
+				let n = e.payload ?? {};
+				if (n.action !== "delegate" || typeof n.paymentMethodId != "string" || n.paymentMethodId.length === 0) return;
+				t.onCardAction?.({
+					action: n.action,
+					paymentMethodId: n.paymentMethodId
+				});
+				return;
+			}
+			case f.ERROR: {
+				let n = e.payload;
+				t.onError?.(n?.error ?? x);
+				return;
+			}
+			case f.CLOSE:
+				t.onClose?.(), this.destroy();
+				return;
+			default: return;
+		}
+	}
+	handleCreateDelegationMessage(e, t) {
+		switch (e.type) {
+			case f.BOOTED:
+				this.postInitOnBooted(), t.onBooted?.();
+				return;
+			case f.READY:
+				t.onReady?.();
+				return;
+			case f.SUCCESS: {
+				let n = (e.payload ?? {}).delegationId;
+				if (typeof n != "string" || n.length === 0) {
+					t.onError?.(C);
+					return;
+				}
+				t.onSuccess?.({
+					delegationId: n,
+					paymentMethodId: t.paymentMethodId
+				});
+				return;
+			}
+			case f.ERROR: {
+				let n = e.payload;
+				t.onError?.(n?.error ?? x);
+				return;
+			}
+			case f.CLOSE:
+				t.onClose?.(), this.destroy();
+				return;
+			default: return;
+		}
+	}
+	async deleteWithSession(e, t) {
+		let n;
+		try {
+			n = await fetch(e, {
+				method: "DELETE",
+				headers: {
+					Authorization: `Bearer ${this.session.getToken()}`,
+					Accept: "application/json"
+				}
+			});
+		} catch (e) {
+			throw new c(e instanceof Error && e.message ? e.message : t);
+		}
+		if (n.ok) return;
+		let r, i = t;
+		try {
+			let e = await n.json();
+			typeof e?.message == "string" && e.message.length > 0 && (i = e.message), typeof e?.code == "string" && (r = e.code);
+		} catch {}
+		throw new c(i, n.status, r);
+	}
+};
+//#endregion
+//#region src/nevermined-widgets.ts
+function T(e) {
+	if (typeof e != "object" || !e) return !1;
+	let t = e;
+	return [
+		"sessionToken",
+		"userId",
+		"expiresAt",
+		"apiKeyHash"
+	].every((e) => typeof t[e] == "string") && typeof t.userWallet == "string" && t.userWallet.startsWith("0x");
+}
+var E = class t {
+	_checkout = null;
+	_delegations = null;
+	events = new d();
+	constructor(e, t, n) {
+		this.sessionManager = e, this._account = t, this.environment = n;
+	}
+	static async initialize(n) {
+		let { initToken: i, environment: a } = n;
+		if (!i || typeof i != "string") throw new o("MISSING_INIT_TOKEN");
+		if (!a || !e.includes(a)) throw new o("INVALID_ENVIRONMENT");
+		let s = r(a), c;
+		try {
+			c = await fetch(`${s}/api/v1/widgets/session`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ initToken: i })
+			});
+		} catch (e) {
+			throw console.error("[NeverminedWidgets] fetch failed:", e), new o("NETWORK_ERROR", void 0, e);
+		}
+		if (!c.ok) throw c.status === 401 ? new o("INVALID_INIT_TOKEN") : new o("NETWORK_ERROR", `Request failed with status ${c.status}`);
+		let l;
+		try {
+			l = await c.json();
+		} catch (e) {
+			throw new o("INVALID_RESPONSE", void 0, e);
+		}
+		if (!T(l)) throw new o("INVALID_RESPONSE");
+		let d = new u(l), f = new t(d, {
+			userId: l.userId,
+			userWallet: l.userWallet
+		}, a);
+		return d.startAutoRefresh(() => f.refreshSession(), () => f.events.emit("session-expired", void 0)), f;
+	}
+	async refreshSession() {
+		let e = await fetch(`${r(this.environment)}/api/v1/widgets/session/refresh`, {
+			method: "POST",
+			headers: { Authorization: `Bearer ${this.sessionManager.getToken()}` }
+		});
+		if (!e.ok) throw Error(`Session refresh failed with status ${e.status}`);
+		let t = await e.json();
+		if (!T(t)) throw Error("Session refresh returned an invalid response");
+		return t;
+	}
+	on(e, t) {
+		return this.events.on(e, t), this;
+	}
+	off(e, t) {
+		return this.events.off(e, t), this;
+	}
+	get account() {
+		return this._account;
+	}
+	get hasValidSession() {
+		return this.sessionManager.isValid();
+	}
+	getSessionToken() {
+		if (!this.sessionManager.isValid()) throw new s();
+		return this.sessionManager.getToken();
+	}
+	get checkout() {
+		return this._checkout ||= new b(this.sessionManager, i(this.environment)), this._checkout;
+	}
+	get delegations() {
+		return this._delegations ||= new w(this.sessionManager, i(this.environment), r(this.environment)), this._delegations;
+	}
+	destroy() {
+		this.sessionManager.stopAutoRefresh(), this._checkout?.destroy(), this._checkout = null, this._delegations?.destroy(), this._delegations = null, this.events.removeAllListeners();
+	}
+};
+//#endregion
+export { b as CheckoutWidget, w as DelegationsWidget, v as IframeManager, E as NeverminedWidgets, u as SessionManager, d as TypedEventEmitter, p as WIDGET_MESSAGE_VERSION, c as WidgetApiError, o as WidgetInitError, f as WidgetMessageType, s as WidgetSessionExpiredError, g as createMessage, _ as parseMessage };

package/package.json ADDED Viewed

@@ -0,0 +1,21 @@
+{
+  "name": "@nevermined-io/ui-widgets",
+  "version": "0.3.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "devDependencies": {}
+}