@securitydept/client 0.3.0-beta.1 → 0.3.0-beta.11

package/dist/handle-DwMgqe7R.mjs

@@ -0,0 +1,638 @@
+import { A as RxEventSubject, D as RxStateSignal, F as SYMBOL_DISPOSE, G as ErrorPresentationTone, H as ClientError, K as UserRecovery, U as ClientErrorKind, h as createAsyncSchedulerWithTimestampProvider } from "./rx-DM6Ouv-m.mjs";
+import { V as validateWithSchemaSync } from "./create-i5VyYgN6.mjs";
+import { BehaviorSubject, ReplaySubject, Subject, catchError, delayWhen, distinctUntilChanged, exhaustMap, filter, from, map, merge, of, shareReplay, take, takeUntil, timeout, timer } from "rxjs";
+import { type } from "arktype";
+//#region src/span/attributes.ts
+const SpanSharedAttributeName = {
+	ClientName: "client.name",
+	ClientId: "client.id",
+	OperationName: "operation.name"
+};
+//#endregion
+//#region src/errors/presentation-descriptor.ts
+const DEFAULT_RECOVERY_LABELS = {
+	[UserRecovery.None]: "",
+	[UserRecovery.Retry]: "Try again",
+	[UserRecovery.RestartFlow]: "Restart flow",
+	[UserRecovery.Reauthenticate]: "Sign in again",
+	[UserRecovery.ContactSupport]: "Contact support"
+};
+const formatClientErrorContext = (context) => {
+	let clientName;
+	let clientId;
+	let operationName;
+	for (const frame of context) {
+		const frameClientName = frame.attributes[SpanSharedAttributeName.ClientName];
+		const frameClientId = frame.attributes[SpanSharedAttributeName.ClientId];
+		const frameOperationName = frame.attributes[SpanSharedAttributeName.OperationName];
+		if (typeof frameClientName === "string") clientName = frameClientName;
+		if (typeof frameClientId === "string") clientId = frameClientId;
+		if (typeof frameOperationName === "string") operationName = frameOperationName;
+	}
+	return [clientName ?? clientId, operationName].filter((value) => Boolean(value)).join(" · ") || void 0;
+};
+function readErrorPresentationDescriptor(error, options = {}) {
+	if (!(error instanceof ClientError)) return {
+		code: null,
+		title: options.fallbackTitle ?? "Operation failed",
+		description: options.fallbackDescription ?? "An unexpected error prevented the operation from completing.",
+		recovery: UserRecovery.None,
+		tone: ErrorPresentationTone.Danger,
+		primaryAction: null
+	};
+	const clientError = error;
+	const code = clientError.presentation?.code ?? clientError.code;
+	const codePresentation = code ? options.codePresentations?.[code] : void 0;
+	const recovery = clientError.presentation?.recovery ?? codePresentation?.recovery ?? clientError.recovery;
+	const generic = readGenericPresentation(clientError.kind);
+	const descriptor = {
+		code,
+		title: codePresentation?.title ?? generic.title,
+		description: clientError.presentation?.message ?? codePresentation?.description ?? generic.description,
+		recovery,
+		tone: codePresentation?.tone ?? readClientErrorTone(clientError.kind, recovery),
+		primaryAction: readPrimaryAction(recovery, options)
+	};
+	if (!clientError.spanContext || options.contextFormatter === null) return descriptor;
+	const contextLabel = (options.contextFormatter ?? formatClientErrorContext)(clientError.spanContext);
+	return contextLabel ? {
+		...descriptor,
+		title: `${contextLabel}: ${descriptor.title}`
+	} : descriptor;
+}
+function readGenericPresentation(kind) {
+	switch (kind) {
+		case ClientErrorKind.Unauthenticated: return {
+			title: "Authentication required",
+			description: "Sign in again to continue."
+		};
+		case ClientErrorKind.Unauthorized: return {
+			title: "Access denied",
+			description: "You do not have permission to complete this operation."
+		};
+		case ClientErrorKind.Cancelled: return {
+			title: "Operation cancelled",
+			description: "The operation was cancelled before it completed."
+		};
+		case ClientErrorKind.Timeout: return {
+			title: "Request timed out",
+			description: "The operation did not complete in time."
+		};
+		case ClientErrorKind.Configuration: return {
+			title: "Configuration error",
+			description: "The client is not configured to complete this operation."
+		};
+		case ClientErrorKind.Storage: return {
+			title: "Storage failed",
+			description: "The client could not access required stored data."
+		};
+		case ClientErrorKind.Transport: return {
+			title: "Network request failed",
+			description: "The client could not reach the service."
+		};
+		case ClientErrorKind.Server: return {
+			title: "Server request failed",
+			description: "The service could not complete the request."
+		};
+		case ClientErrorKind.Protocol: return {
+			title: "Invalid response",
+			description: "The service response did not satisfy the expected protocol."
+		};
+		case ClientErrorKind.Authorization: return {
+			title: "Authorization failed",
+			description: "The authorization flow could not be completed."
+		};
+		default: return {
+			title: "Operation failed",
+			description: "The operation could not be completed."
+		};
+	}
+}
+function readClientErrorTone(kind, recovery) {
+	if (kind === ClientErrorKind.Cancelled) return ErrorPresentationTone.Neutral;
+	if (kind === ClientErrorKind.Unauthenticated || kind === ClientErrorKind.Timeout || kind === ClientErrorKind.Transport || kind === ClientErrorKind.Server || recovery === UserRecovery.Retry || recovery === UserRecovery.RestartFlow || recovery === UserRecovery.Reauthenticate) return ErrorPresentationTone.Warning;
+	return ErrorPresentationTone.Danger;
+}
+function readPrimaryAction(recovery, options) {
+	if (recovery === UserRecovery.None) return null;
+	const label = options.recoveryLabels?.[recovery] ?? DEFAULT_RECOVERY_LABELS[recovery];
+	if (!label) return null;
+	return {
+		recovery,
+		label,
+		href: options.recoveryLinks?.[recovery] ?? null
+	};
+}
+//#endregion
+//#region src/signals/signal.ts
+/**
+* Minimal writable signal implementation.
+* `set()` always publishes a write. Equality-based value-version suppression is
+* handled by the underlying Rx signal for computed dependency validation.
+*/
+function createSignal(initial, options) {
+	return RxStateSignal.fromInitialValue(initial, options);
+}
+/**
+* Create a read-only view of a writable signal.
+*/
+function readonlySignal(signal) {
+	return signal;
+}
+//#endregion
+//#region src/popup/errors.ts
+const PopupErrorCode = {
+	Blocked: "popup.blocked",
+	Closed: "popup.closed_by_user"
+};
+function readPopupErrorPresentationDescriptor(error, options = {}) {
+	return readErrorPresentationDescriptor(error, {
+		...options,
+		codePresentations: {
+			[PopupErrorCode.Blocked]: {
+				title: "Popup was blocked",
+				description: "The browser blocked the popup window. Allow popups for this site, then try again.",
+				recovery: UserRecovery.Retry,
+				tone: ErrorPresentationTone.Warning
+			},
+			[PopupErrorCode.Closed]: {
+				title: "Popup was closed",
+				description: "The popup window was closed before the operation completed. Start the flow again.",
+				recovery: UserRecovery.RestartFlow,
+				tone: ErrorPresentationTone.Warning
+			},
+			...options.codePresentations
+		}
+	});
+}
+//#endregion
+//#region src/protocol/json-rpc/types.ts
+const JsonRpcIdSchema = type("string | number");
+const JsonRpcErrorPayloadSchema = type({
+	code: "number",
+	message: "string",
+	data: "unknown?"
+});
+const JsonRpcRequestMessageSchema = type({
+	jsonrpc: "\"2.0\"",
+	id: JsonRpcIdSchema,
+	method: "string",
+	params: "unknown?"
+});
+const JsonRpcNotificationMessageSchema = type({
+	jsonrpc: "\"2.0\"",
+	method: "string",
+	params: "unknown?"
+});
+const JsonRpcSuccessResponseMessageSchema = type({
+	jsonrpc: "\"2.0\"",
+	id: JsonRpcIdSchema,
+	result: "unknown"
+});
+const JsonRpcErrorResponseMessageSchema = type({
+	jsonrpc: "\"2.0\"",
+	id: JsonRpcIdSchema,
+	error: JsonRpcErrorPayloadSchema
+});
+const JsonRpcMessageSchema = JsonRpcRequestMessageSchema.or(JsonRpcNotificationMessageSchema).or(JsonRpcSuccessResponseMessageSchema).or(JsonRpcErrorResponseMessageSchema);
+//#endregion
+//#region src/protocol/json-rpc/create.ts
+function createJsonRpcClient(options) {
+	return new JsonRpcClient(options);
+}
+function createJsonRpcServer(options) {
+	return new JsonRpcServer(options);
+}
+function createJsonRpcServerAndClient(options) {
+	return new JsonRpcServerAndClient(options);
+}
+var JsonRpcClient = class {
+	options;
+	onNotification;
+	notificationSubject = new RxEventSubject();
+	pendingRequests = /* @__PURE__ */ new Map();
+	disposed = false;
+	nextRequestId = 1;
+	constructor(options) {
+		this.options = options;
+		this.onNotification = this.notificationSubject;
+	}
+	request(method, params, requestOptions = {}) {
+		if (this.disposed) return Promise.reject(createJsonRpcDisposedError("client"));
+		const id = this.nextRequestId++;
+		const timeoutMs = requestOptions.timeoutMs ?? this.options.defaultRequestTimeoutMs;
+		return new Promise((resolve, reject) => {
+			const pendingRequest = {
+				method,
+				reject,
+				resolve
+			};
+			if (timeoutMs !== void 0) pendingRequest.timeoutHandle = this.options.time.setTimeout(() => {
+				this.pendingRequests.delete(id);
+				reject(/* @__PURE__ */ new Error(`JSON-RPC request timed out for ${method}.`));
+			}, timeoutMs);
+			this.pendingRequests.set(id, pendingRequest);
+			try {
+				this.options.send({
+					jsonrpc: "2.0",
+					id,
+					method,
+					params
+				});
+			} catch (error) {
+				this.clearPendingRequest(id);
+				reject(error);
+			}
+		});
+	}
+	notify(method, params) {
+		if (this.disposed) return;
+		this.options.send({
+			jsonrpc: "2.0",
+			method,
+			params
+		});
+	}
+	receive(message) {
+		if (this.disposed) return;
+		for (const parsedMessage of parseIncomingMessages(message)) {
+			if (isJsonRpcResponseMessage(parsedMessage)) {
+				this.resolvePendingRequest(parsedMessage);
+				continue;
+			}
+			if (isJsonRpcNotificationMessage(parsedMessage)) this.notificationSubject.next({
+				method: parsedMessage.method,
+				params: parsedMessage.params
+			});
+		}
+	}
+	rejectAllPendingRequests(reason) {
+		for (const [id, pendingRequest] of this.pendingRequests) {
+			this.clearPendingRequest(id);
+			pendingRequest.reject(reason);
+		}
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.rejectAllPendingRequests(/* @__PURE__ */ new Error("JSON-RPC client disposed."));
+		this.notificationSubject.complete();
+	}
+	[SYMBOL_DISPOSE]() {
+		this.dispose();
+	}
+	resolvePendingRequest(message) {
+		const pendingRequest = this.pendingRequests.get(message.id);
+		if (!pendingRequest) return;
+		this.clearPendingRequest(message.id);
+		if ("error" in message) {
+			pendingRequest.reject(/* @__PURE__ */ new Error(`JSON-RPC request failed for ${pendingRequest.method}: ${message.error.message}`));
+			return;
+		}
+		pendingRequest.resolve(message.result);
+	}
+	clearPendingRequest(id) {
+		const pendingRequest = this.pendingRequests.get(id);
+		if (!pendingRequest) return;
+		if (pendingRequest.timeoutHandle !== void 0) this.options.time.clearTimeout(pendingRequest.timeoutHandle);
+		this.pendingRequests.delete(id);
+	}
+};
+var JsonRpcServer = class {
+	options;
+	onRequest;
+	onNotification;
+	requestSubject = new RxEventSubject();
+	notificationSubject = new RxEventSubject();
+	disposed = false;
+	constructor(options) {
+		this.options = options;
+		this.onRequest = this.requestSubject;
+		this.onNotification = this.notificationSubject;
+	}
+	notify(method, params) {
+		if (this.disposed) return;
+		this.options.send({
+			jsonrpc: "2.0",
+			method,
+			params
+		});
+	}
+	receive(message) {
+		if (this.disposed) return;
+		for (const parsedMessage of parseIncomingMessages(message)) {
+			if (isJsonRpcRequestMessage(parsedMessage)) {
+				this.requestSubject.next({
+					id: parsedMessage.id,
+					method: parsedMessage.method,
+					params: parsedMessage.params
+				});
+				continue;
+			}
+			if (isJsonRpcNotificationMessage(parsedMessage)) this.notificationSubject.next({
+				method: parsedMessage.method,
+				params: parsedMessage.params
+			});
+		}
+	}
+	respondSuccess(id, result) {
+		if (this.disposed) return;
+		this.options.send({
+			jsonrpc: "2.0",
+			id,
+			result
+		});
+	}
+	respondError(id, error) {
+		if (this.disposed) return;
+		this.options.send({
+			jsonrpc: "2.0",
+			id,
+			error
+		});
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.requestSubject.complete();
+		this.notificationSubject.complete();
+	}
+	[SYMBOL_DISPOSE]() {
+		this.dispose();
+	}
+};
+var JsonRpcServerAndClient = class {
+	onNotification;
+	onRequest;
+	client;
+	server;
+	disposed = false;
+	constructor(options) {
+		this.client = new JsonRpcClient(options);
+		this.server = new JsonRpcServer(options);
+		this.onNotification = this.server.onNotification;
+		this.onRequest = this.server.onRequest;
+	}
+	request(method, params, options) {
+		return this.client.request(method, params, options);
+	}
+	notify(method, params) {
+		this.client.notify(method, params);
+	}
+	receive(message) {
+		for (const parsedMessage of parseIncomingMessages(message)) {
+			if (isJsonRpcResponseMessage(parsedMessage)) {
+				this.client.receive(parsedMessage);
+				continue;
+			}
+			this.server.receive(parsedMessage);
+		}
+	}
+	rejectAllPendingRequests(reason) {
+		this.client.rejectAllPendingRequests(reason);
+	}
+	respondSuccess(id, result) {
+		this.server.respondSuccess(id, result);
+	}
+	respondError(id, error) {
+		this.server.respondError(id, error);
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.client.dispose();
+		this.server.dispose();
+	}
+	[SYMBOL_DISPOSE]() {
+		this.dispose();
+	}
+};
+function parseIncomingMessages(message) {
+	if (!Array.isArray(message)) return parseJsonRpcMessage(message);
+	const parsedMessages = [];
+	for (const entry of message) parsedMessages.push(...parseJsonRpcMessage(entry));
+	return parsedMessages;
+}
+function parseJsonRpcMessage(message) {
+	const result = validateWithSchemaSync(JsonRpcMessageSchema, message);
+	return result.success ? [result.value] : [];
+}
+function isJsonRpcRequestMessage(message) {
+	return "method" in message && "id" in message;
+}
+function isJsonRpcResponseMessage(message) {
+	return "id" in message && !("method" in message);
+}
+function isJsonRpcNotificationMessage(message) {
+	return "method" in message && !("id" in message);
+}
+function createJsonRpcDisposedError(role) {
+	return /* @__PURE__ */ new Error(`JSON-RPC ${role} disposed.`);
+}
+//#endregion
+//#region src/popup/session.ts
+const PopupSessionControlMethod = {
+	Ready: "securitydept.popup.session.ready",
+	Ping: "securitydept.popup.session.ping",
+	Pong: "securitydept.popup.session.pong"
+};
+const DEFAULT_READY_TIMEOUT_MS = 1e4;
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 5e3;
+const DEFAULT_HEARTBEAT_TIMEOUT_MS = 15e3;
+var PopupClientSession = class {
+	failure = createSignal(null);
+	isActive = createSignal(false);
+	init$ = new ReplaySubject();
+	destroyed = createSignal(false);
+	destroyed$ = from(this.destroyed).pipe(distinctUntilChanged(), filter(Boolean), shareReplay(1));
+	constructor(options) {
+		const timestampScheduler = createAsyncSchedulerWithTimestampProvider(options.time);
+		const ready$ = new Subject();
+		const pong$ = new Subject();
+		const closed$ = from(options.closedStream).pipe(filter(Boolean));
+		const ping$ = merge(ready$.pipe(filter(Boolean)), pong$.pipe(filter(Boolean))).pipe(delayWhen(() => timer(options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS, timestampScheduler)));
+		from(this.init$).pipe(exhaustMap(() => from(options.jsonRpc.onNotification).pipe(filter(function isReadyNotification(event) {
+			return event.method === PopupSessionControlMethod.Ready;
+		}), take(1), timeout({
+			each: options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS,
+			scheduler: timestampScheduler
+		}), map(() => true), catchError(() => of(false)))), takeUntil(this.destroyed$)).subscribe(ready$);
+		ping$.pipe(exhaustMap(() => from(options.jsonRpc.onNotification).pipe(filter(function isPongNotification(event) {
+			return event.method === PopupSessionControlMethod.Pong;
+		}), take(1), timeout({
+			first: options.heartbeatTimeoutMs ?? DEFAULT_HEARTBEAT_TIMEOUT_MS,
+			scheduler: timestampScheduler
+		}), map(() => true), catchError(() => of(false)))), takeUntil(this.destroyed$)).subscribe(pong$);
+		merge(closed$.pipe(map(() => new ClientError({
+			kind: ClientErrorKind.Authorization,
+			code: PopupErrorCode.Closed,
+			message: "Popup window was closed before completing the login flow.",
+			recovery: UserRecovery.RestartFlow,
+			source: "popup"
+		}))), ready$.pipe(map((success) => !success ? new ClientError({
+			kind: ClientErrorKind.Protocol,
+			message: "Did not receive ready notification from popup within the expected time.",
+			recovery: UserRecovery.RestartFlow,
+			source: "popup"
+		}) : null)), pong$.pipe(map((success) => !success ? new ClientError({
+			kind: ClientErrorKind.Protocol,
+			message: "Did not receive pong notification from popup within the expected time.",
+			recovery: UserRecovery.RestartFlow,
+			source: "popup"
+		}) : null))).pipe(takeUntil(this.destroyed$), shareReplay({
+			bufferSize: 1,
+			refCount: false
+		})).subscribe((error) => this.failure.set(error));
+		merge(closed$.pipe(map(() => false)), ready$.pipe(map(Boolean)), pong$.pipe(map(Boolean))).pipe(takeUntil(this.destroyed$)).subscribe((nextIsActive) => {
+			this.isActive.set(nextIsActive);
+		});
+	}
+	init() {
+		this.init$.next(true);
+	}
+	dispose() {
+		this.destroyed.set(true);
+	}
+	[SYMBOL_DISPOSE]() {
+		this.dispose();
+	}
+};
+var PopupServerSession = class {
+	init$ = new ReplaySubject();
+	destroyed$$ = new BehaviorSubject(false);
+	destroyed$ = this.destroyed$$.pipe(distinctUntilChanged(), filter(Boolean), shareReplay(1));
+	constructor(options) {
+		const ready$ = from(this.init$);
+		const pong$ = from(options.jsonRpc.onNotification).pipe(filter(function isPing(event) {
+			return event.method === PopupSessionControlMethod.Ping;
+		}));
+		merge(ready$.pipe(map(function createReadyNotify() {
+			return { method: PopupSessionControlMethod.Ready };
+		})), pong$.pipe(map(function createPongNotify() {
+			return { method: PopupSessionControlMethod.Pong };
+		}))).pipe(takeUntil(this.destroyed$)).subscribe((event) => {
+			options.jsonRpc.notify(event.method, event.params);
+		});
+	}
+	init() {
+		this.init$.next(true);
+	}
+	dispose() {
+		this.destroyed$$.next(true);
+	}
+	[SYMBOL_DISPOSE]() {
+		this.dispose();
+	}
+};
+//#endregion
+//#region src/popup/handle.ts
+/**
+* popup opener
+*/
+var PopupClientWindowHandle = class {
+	messaging;
+	disposed = false;
+	jsonRpc;
+	session;
+	incomingSubscription;
+	closePopup;
+	constructor(options) {
+		this.messaging = options.messaging;
+		this.closePopup = options.close;
+		this.jsonRpc = createJsonRpcClient({
+			send: (message) => {
+				options.messaging.outgoing.next(message);
+			},
+			time: options.time
+		});
+		this.session = new PopupClientSession({
+			jsonRpc: this.jsonRpc,
+			time: options.time,
+			closedStream: options.closedStream
+		});
+		this.incomingSubscription = options.messaging.incoming.subscribe({ next: (message) => {
+			this.jsonRpc.receive(message);
+		} });
+		this.session.init();
+	}
+	get onNotification() {
+		return this.jsonRpc.onNotification;
+	}
+	get failure() {
+		return this.session.failure;
+	}
+	get isActive() {
+		return this.session.isActive;
+	}
+	async notify(method, params) {
+		this.jsonRpc.notify(method, params);
+	}
+	request(method, params, options) {
+		return this.jsonRpc.request(method, params, options);
+	}
+	close() {
+		this.closePopup();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.session.dispose();
+		this.jsonRpc.dispose();
+		this.incomingSubscription.unsubscribe();
+		this.messaging.outgoing.complete();
+	}
+	[SYMBOL_DISPOSE]() {
+		this.dispose();
+	}
+};
+/**
+* popup target
+*/
+var PopupServerWindowHandle = class {
+	messaging;
+	disposed = false;
+	jsonRpc;
+	session;
+	incomingSubscription;
+	closePopup;
+	constructor(options) {
+		this.messaging = options.messaging;
+		this.closePopup = options.close;
+		this.jsonRpc = createJsonRpcServer({ send: (message) => {
+			options.messaging.outgoing.next(message);
+		} });
+		this.session = new PopupServerSession({ jsonRpc: this.jsonRpc });
+		this.incomingSubscription = options.messaging.incoming.subscribe({ next: (message) => {
+			this.jsonRpc.receive(message);
+		} });
+		this.session.init();
+	}
+	get onNotification() {
+		return this.jsonRpc.onNotification;
+	}
+	get onRequest() {
+		return this.jsonRpc.onRequest;
+	}
+	notify(method, params) {
+		this.jsonRpc.notify(method, params);
+		return Promise.resolve();
+	}
+	close() {
+		this.closePopup();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.session.dispose();
+		this.jsonRpc.dispose();
+		this.incomingSubscription.unsubscribe();
+		this.messaging.outgoing.complete();
+	}
+	[SYMBOL_DISPOSE]() {
+		this.dispose();
+	}
+};
+//#endregion
+export { createJsonRpcServerAndClient as a, createSignal as c, readErrorPresentationDescriptor as d, SpanSharedAttributeName as f, createJsonRpcServer as i, readonlySignal as l, PopupServerWindowHandle as n, PopupErrorCode as o, createJsonRpcClient as r, readPopupErrorPresentationDescriptor as s, PopupClientWindowHandle as t, formatClientErrorContext as u };
+
+//# sourceMappingURL=handle-DwMgqe7R.mjs.map