@securitydept/client 0.2.0 → 0.3.0-beta.10

package/dist/fetch-transport-Bd5RyWj2.d.mts

@@ -1,339 +0,0 @@
-import { n as ReadableSignalTrait } from "./types-DQc088ZP.mjs";
-import { a as RecordStore } from "./types-C59fcM5W.mjs";
-
-//#region src/cancellation/types.d.ts
-/** Disposable resource handle. */
-interface DisposableTrait {
-  dispose(): void;
-}
-/** Cancelable operation handle. */
-interface CancelableHandle$1 {
-  cancel(): void;
-}
-/** Cooperative cancellation token — consumers check / subscribe to cancellation. */
-interface CancellationTokenTrait {
-  readonly isCancellationRequested: boolean;
-  readonly reason?: unknown;
-  onCancellationRequested(listener: (reason: unknown) => void): DisposableTrait;
-  throwIfCancellationRequested(): void;
-}
-/** Cancellation source — producer-side control. */
-interface CancellationTokenSourceTrait extends DisposableTrait {
-  readonly token: CancellationTokenTrait;
-  cancel(reason?: unknown): void;
-}
-//#endregion
-//#region src/logging/types.d.ts
-declare const LogLevel: {
-  readonly Debug: "debug";
-  readonly Info: "info";
-  readonly Warn: "warn";
-  readonly Error: "error";
-};
-type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
-interface LogEntry {
-  level: LogLevel;
-  message: string;
-  scope?: string;
-  code?: string;
-  attributes?: Record<string, unknown>;
-  error?: unknown;
-  at?: number;
-}
-interface LoggerTrait {
-  log(entry: LogEntry): void;
-}
-declare const OperationTraceEventType: {
-  readonly Started: "operation.started";
-  readonly Event: "operation.event";
-  readonly Error: "operation.error";
-  readonly Ended: "operation.ended";
-};
-type OperationTraceEventType = (typeof OperationTraceEventType)[keyof typeof OperationTraceEventType];
-interface TraceEvent {
-  type: string;
-  at: number;
-  scope?: string;
-  operationId?: string;
-  source?: string;
-  attributes?: Record<string, unknown>;
-}
-interface TraceEventSinkTrait {
-  record(event: TraceEvent): void;
-}
-interface OperationScope {
-  id: string;
-  addEvent(type: string, attributes?: Record<string, unknown>): void;
-  setAttribute(key: string, value: unknown): void;
-  recordError(error: unknown, attributes?: Record<string, unknown>): void;
-  end(attributes?: Record<string, unknown>): void;
-}
-interface OperationTracerTrait {
-  startOperation(name: string, attributes?: Record<string, unknown>): OperationScope;
-}
-//#endregion
-//#region src/scheduling/types.d.ts
-/** Wall clock abstraction — injectable for testing. */
-interface Clock {
-  /** Return current epoch milliseconds. */
-  now(): number;
-}
-/** Cancelable scheduled task handle. */
-interface CancelableHandle {
-  cancel(): void;
-}
-/** Scheduler abstraction — decoupled from platform timers. */
-interface Scheduler {
-  setTimeout(delayMs: number, fn: () => void): CancelableHandle;
-}
-//#endregion
-//#region src/transport/types.d.ts
-/** Neutral HTTP request representation. */
-interface HttpRequest {
-  url: string;
-  method: string;
-  headers: Record<string, string>;
-  body?: unknown;
-  cancellationToken?: CancellationTokenTrait;
-}
-/** Neutral HTTP response representation. */
-interface HttpResponse {
-  status: number;
-  headers: Record<string, string>;
-  body?: unknown;
-}
-/** Transport protocol — decoupled from any specific HTTP client. */
-interface HttpTransport {
-  execute(request: HttpRequest): Promise<HttpResponse>;
-}
-//#endregion
-//#region src/runtime/types.d.ts
-/**
- * Runtime capability bundle — injected into auth context clients
- * via explicit wiring at composition root.
- *
- * All capabilities are optional except `transport`.
- * Missing capabilities use no-op defaults where applicable.
- * `createRuntime()` is a convenience helper for common setups;
- * callers can also wire this interface directly.
- */
-interface ClientRuntime {
-  transport: HttpTransport;
-  scheduler: Scheduler;
-  clock: Clock;
-  logger?: LoggerTrait;
-  traceSink?: TraceEventSinkTrait;
-  operationTracer?: OperationTracerTrait;
-  /** Optional persistent storage backing. */
-  persistentStore?: RecordStore;
-  /** Optional session-scoped storage backing. */
-  sessionStore?: RecordStore;
-}
-//#endregion
-//#region src/scheduling/helpers.d.ts
-/** Subscription handle returned by input-source adapters. */
-interface Subscription {
-  /** Unsubscribe and release resources. */
-  unsubscribe(): void;
-}
-interface FromSignalOptions<T> {
-  /** Signal to observe. */
-  signal: ReadableSignalTrait<T>;
-  /** Callback invoked when the signal value changes. */
-  callback: (value: T) => void;
-  /**
-   * Emit the current snapshot immediately after subscription.
-   * Defaults to `false`.
-   */
-  emitInitialValue?: boolean;
-}
-declare const PromiseSettlementKind: {
-  readonly Fulfilled: "fulfilled";
-  readonly Rejected: "rejected";
-};
-type PromiseSettlementKind = (typeof PromiseSettlementKind)[keyof typeof PromiseSettlementKind];
-type PromiseSettlement<T> = {
-  kind: typeof PromiseSettlementKind.Fulfilled;
-  value: T;
-} | {
-  kind: typeof PromiseSettlementKind.Rejected;
-  reason: unknown;
-};
-interface FromPromiseOptions<T> {
-  /** Promise-like source to observe. */
-  promise: PromiseLike<T>;
-  /** Callback invoked when the promise settles. */
-  callback: (settlement: PromiseSettlement<T>) => void;
-}
-/** Options for {@link timer}. */
-interface TimerOptions {
-  /** Scheduler to use (platform default if omitted). */
-  scheduler: Scheduler;
-  /** Delay in milliseconds. */
-  delayMs: number;
-  /** Callback to invoke after the delay. */
-  callback: () => void;
-}
-/**
- * Schedule a one-shot callback after a delay.
- *
- * Returns a {@link CancelableHandle} that can cancel the pending timer.
- *
- * @example
- * ```ts
- * const handle = timer({
- *   scheduler: runtime.scheduler,
- *   delayMs: 5000,
- *   callback: () => console.log("fired"),
- * });
- * // Cancel before it fires:
- * handle.cancel();
- * ```
- */
-declare function timer(options: TimerOptions): CancelableHandle;
-/** Options for {@link interval}. */
-interface IntervalOptions {
-  /** Scheduler to use. */
-  scheduler: Scheduler;
-  /** Interval period in milliseconds. */
-  periodMs: number;
-  /** Callback to invoke on each tick. */
-  callback: () => void;
-}
-/**
- * Schedule a repeating callback at a fixed interval.
- *
- * Built on top of `Scheduler.setTimeout` so it works with deterministic
- * test schedulers. Returns a {@link CancelableHandle} to stop the interval.
- *
- * @example
- * ```ts
- * const handle = interval({
- *   scheduler: runtime.scheduler,
- *   periodMs: 30_000,
- *   callback: () => refreshTokens(),
- * });
- * // Stop:
- * handle.cancel();
- * ```
- */
-declare function interval(options: IntervalOptions): CancelableHandle;
-/** Options for {@link scheduleAt}. */
-interface ScheduleAtOptions {
-  /** Scheduler to use. */
-  scheduler: Scheduler;
-  /** Clock to use for computing the delay. */
-  clock: Clock;
-  /** Target epoch milliseconds at which the callback should fire. */
-  atMs: number;
-  /** Callback to invoke at (or after) the target time. */
-  callback: () => void;
-}
-/**
- * Schedule a callback at a specific wall-clock time.
- *
- * Computes the delay from `clock.now()` to `atMs` and delegates to
- * `Scheduler.setTimeout`. If the target time is already in the past,
- * the callback fires on the next scheduler tick (delay 0).
- *
- * @example
- * ```ts
- * const handle = scheduleAt({
- *   scheduler: runtime.scheduler,
- *   clock: runtime.clock,
- *   atMs: tokenExpiresAtMs - 30_000,
- *   callback: () => refreshToken(),
- * });
- * ```
- */
-declare function scheduleAt(options: ScheduleAtOptions): CancelableHandle;
-/**
- * Adapt an SDK signal into the shared {@link Subscription} callback model.
- *
- * @example
- * ```ts
- * const sub = fromSignal({
- *   signal: authState,
- *   callback: (snapshot) => console.log(snapshot),
- * });
- * sub.unsubscribe();
- * ```
- */
-declare function fromSignal<T>(options: FromSignalOptions<T>): Subscription;
-/**
- * Adapt a promise settlement into the shared {@link Subscription} callback model.
- *
- * This helper is intentionally thin: it reports one settlement and lets the
- * consumer decide how to model pending/fulfilled/error state.
- *
- * @example
- * ```ts
- * const sub = fromPromise({
- *   promise: fetchConfig(),
- *   callback: (settlement) => {
- *     if (settlement.kind === PromiseSettlementKind.Fulfilled) {
- *       console.log(settlement.value);
- *     }
- *   },
- * });
- * sub.unsubscribe();
- * ```
- */
-declare function fromPromise<T>(options: FromPromiseOptions<T>): Subscription;
-/** Options for {@link fromEventPattern}. */
-interface FromEventPatternOptions<T> {
-  /**
-   * Called to install the event listener. Should return whatever handle
-   * is needed by `removeHandler` to unsubscribe.
-   */
-  addHandler: (handler: (value: T) => void) => void;
-  /**
-   * Called to uninstall the event listener.
-   */
-  removeHandler: (handler: (value: T) => void) => void;
-  /** Callback invoked each time the event fires. */
-  callback: (value: T) => void;
-}
-/**
- * Adapt an arbitrary add/remove event pattern into a {@link Subscription}.
- *
- * This is a thin bridge between imperative event APIs (e.g. `addEventListener`
- * / `removeEventListener`) and the SDK's subscription model.
- *
- * @example
- * ```ts
- * const sub = fromEventPattern<Event>({
- *   addHandler: (h) => document.addEventListener("visibilitychange", h),
- *   removeHandler: (h) => document.removeEventListener("visibilitychange", h),
- *   callback: () => onVisibilityChange(),
- * });
- * // Cleanup:
- * sub.unsubscribe();
- * ```
- */
-declare function fromEventPattern<T>(options: FromEventPatternOptions<T>): Subscription;
-//#endregion
-//#region src/transport/fetch-transport.d.ts
-declare const FetchTransportRedirectKind: {
-  readonly Follow: "follow";
-  readonly Manual: "manual";
-};
-type FetchTransportRedirectKind = (typeof FetchTransportRedirectKind)[keyof typeof FetchTransportRedirectKind];
-interface FetchTransportOptions {
-  /**
-   * How to handle HTTP redirects.
-   * - `"follow"`: automatically follow redirects (default fetch behavior)
-   * - `"manual"`: capture redirect responses as-is (needed for fragment-based protocols)
-   */
-  redirect?: FetchTransportRedirectKind;
-}
-/**
- * Default `HttpTransport` backed by the global `fetch` API.
- *
- * The caller is responsible for ensuring `fetch` is available in the runtime.
- * No polyfill is injected — see the polyfill strategy in the design guide.
- */
-declare function createFetchTransport(options?: FetchTransportOptions): HttpTransport;
-//#endregion
-export { OperationTraceEventType as A, CancelableHandle as C, LogLevel as D, LogEntry as E, CancellationTokenSourceTrait as F, CancellationTokenTrait as I, DisposableTrait as L, TraceEvent as M, TraceEventSinkTrait as N, LoggerTrait as O, CancelableHandle$1 as P, HttpTransport as S, Scheduler as T, scheduleAt as _, FromPromiseOptions as a, HttpRequest as b, PromiseSettlement as c, Subscription as d, TimerOptions as f, interval as g, fromSignal as h, FromEventPatternOptions as i, OperationTracerTrait as j, OperationScope as k, PromiseSettlementKind as l, fromPromise as m, FetchTransportRedirectKind as n, FromSignalOptions as o, fromEventPattern as p, createFetchTransport as r, IntervalOptions as s, FetchTransportOptions as t, ScheduleAtOptions as u, timer as v, Clock as w, HttpResponse as x, ClientRuntime as y };
-//# sourceMappingURL=fetch-transport-Bd5RyWj2.d.mts.map