@securitydept/client 0.3.0-beta.3 → 0.3.0-beta.6

package/dist/handle-TnxwtQ4T.mjs

@@ -0,0 +1,634 @@
+import { A as RxEventSubject, D as RxStateSignal, F as SYMBOL_DISPOSE, G as UserRecovery, H as ClientErrorKind, V as ClientError, W as ErrorPresentationTone, h as createAsyncSchedulerWithTimestampProvider } from "./rx-B3OU17wu.mjs";
+import { B as validateWithSchemaSync } from "./create-99Ksgl_O.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/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 userRecoveryValues = new Set(Object.values(UserRecovery));
+const clientErrorKindValues = new Set(Object.values(ClientErrorKind));
+function readErrorPresentationDescriptor(error, options = {}) {
+	const clientError = error instanceof ClientError ? error : coerceClientErrorLike(error);
+	if (!clientError) return {
+		code: null,
+		kind: null,
+		title: options.fallbackTitle ?? "Operation failed",
+		description: options.fallbackDescription ?? "An unexpected error prevented the operation from completing.",
+		recovery: UserRecovery.None,
+		retryable: false,
+		tone: ErrorPresentationTone.Danger,
+		primaryAction: null
+	};
+	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);
+	return {
+		code,
+		kind: clientError.kind,
+		source: clientError.source,
+		title: codePresentation?.title ?? generic.title,
+		description: clientError.presentation?.message ?? codePresentation?.description ?? generic.description,
+		recovery,
+		retryable: clientError.retryable,
+		tone: codePresentation?.tone ?? readClientErrorTone(clientError.kind, recovery),
+		primaryAction: readPrimaryAction(recovery, options)
+	};
+}
+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 coerceClientErrorLike(error) {
+	if (typeof error !== "object" || error === null) return null;
+	const candidate = error;
+	if (typeof candidate.kind !== "string" || !clientErrorKindValues.has(candidate.kind)) return null;
+	return {
+		code: typeof candidate.code === "string" ? candidate.code : null,
+		kind: candidate.kind,
+		recovery: typeof candidate.recovery === "string" && userRecoveryValues.has(candidate.recovery) ? candidate.recovery : UserRecovery.None,
+		retryable: candidate.retryable === true,
+		source: typeof candidate.source === "string" ? candidate.source : void 0,
+		presentation: isErrorPresentation(candidate.presentation) ? candidate.presentation : void 0
+	};
+}
+function isErrorPresentation(value) {
+	return typeof value === "object" && value !== null && typeof value.code === "string" && typeof value.message === "string" && typeof value.recovery === "string" && userRecoveryValues.has(value.recovery);
+}
+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, createJsonRpcServer as i, readonlySignal as l, PopupServerWindowHandle as n, PopupErrorCode as o, createJsonRpcClient as r, readPopupErrorPresentationDescriptor as s, PopupClientWindowHandle as t, readErrorPresentationDescriptor as u };
+
+//# sourceMappingURL=handle-TnxwtQ4T.mjs.map