joopjs 2.0.0

package/dist/idempotency.service-_6LqhivP.d.mts

@@ -0,0 +1,372 @@
+import { b as JoopSubject, J as JoopObservable } from './index-Dz0gOur2.mjs';
+import { a as JoopHttpMethod } from './index-CqDKWTUP.mjs';
+import { J as JoopClientProfile } from './client-profile.service-BuPeXVp5.mjs';
+import { b as JoopAesService, c as JoopRequestOptions } from './aes.service-CkoupAww.mjs';
+import { J as JoopConfigService } from './config.service-Cz4QQLlf.mjs';
+import { d as JoopStorageAdapter } from './adapters-B6slG6hQ.mjs';
+
+interface JoopFetchOptions {
+    headers?: Record<string, string>;
+    body?: any;
+    signal?: AbortSignal;
+    timeout?: number;
+}
+/**
+ * Thin fetch wrapper — no Angular, no RxJS.
+ * Use directly or extend for request/response interceptors.
+ */
+declare class JoopHttpClient {
+    request<T = any>(method: JoopHttpMethod, url: string, options?: JoopFetchOptions): Promise<T>;
+    get<T = any>(url: string, options?: JoopFetchOptions): Promise<T>;
+    post<T = any>(url: string, body?: any, options?: JoopFetchOptions): Promise<T>;
+    put<T = any>(url: string, body?: any, options?: JoopFetchOptions): Promise<T>;
+    patch<T = any>(url: string, body?: any, options?: JoopFetchOptions): Promise<T>;
+    delete<T = any>(url: string, options?: JoopFetchOptions): Promise<T>;
+    /** Upload files with progress via XMLHttpRequest (fetch does not expose upload progress). */
+    uploadWithProgress<T = any>(url: string, formData: FormData, onProgress: (percent: number) => void, headers?: Record<string, string>): Promise<T>;
+}
+
+interface JoopRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: unknown;
+    [key: string]: unknown;
+}
+interface JoopResponse<T = unknown> {
+    status: number;
+    headers: Record<string, string>;
+    data: T;
+    url: string;
+}
+type JoopRequestInterceptor = (req: JoopRequest) => JoopRequest | Promise<JoopRequest>;
+type JoopResponseInterceptor = (res: JoopResponse) => JoopResponse | Promise<JoopResponse>;
+type JoopErrorInterceptor = (err: unknown) => unknown | Promise<unknown>;
+declare class JoopInterceptorPipeline {
+    private _req;
+    private _res;
+    private _err;
+    addRequestInterceptor(fn: JoopRequestInterceptor): () => void;
+    addResponseInterceptor(fn: JoopResponseInterceptor): () => void;
+    addErrorInterceptor(fn: JoopErrorInterceptor): () => void;
+    processRequest(req: JoopRequest): Promise<JoopRequest>;
+    processResponse(res: JoopResponse): Promise<JoopResponse>;
+    processError(err: unknown): Promise<unknown>;
+    clear(): void;
+}
+
+type JoopCircuitState = 'closed' | 'open' | 'half-open';
+type JoopCircuitBreakerState = JoopCircuitState;
+interface JoopCircuitBreakerConfig {
+    name?: string;
+    failureThreshold?: number;
+    successThreshold?: number;
+    timeoutMs?: number;
+    volumeThreshold?: number;
+    onStateChange?: (from: JoopCircuitState, to: JoopCircuitState, name: string) => void;
+}
+interface JoopCircuitBreakerStats {
+    state: JoopCircuitState;
+    failures: number;
+    successes: number;
+    totalCalls: number;
+    lastFailureAt?: number;
+    openedAt?: number;
+    nextAttemptAt?: number;
+}
+declare class JoopCircuitBreakerOpenError extends Error {
+    readonly nextAttemptAt: number;
+    constructor(name: string, nextAttemptAt: number);
+}
+declare class JoopCircuitBreaker {
+    private readonly _name;
+    private readonly failureThreshold;
+    private readonly successThreshold;
+    private readonly timeoutMs;
+    private readonly volumeThreshold;
+    private readonly onStateChangeFn?;
+    private _state;
+    private _failures;
+    private _successes;
+    private _totalCalls;
+    private _lastFailureAt?;
+    private _openedAt?;
+    constructor(nameOrConfig: string | (JoopCircuitBreakerConfig & {
+        name: string;
+    }), config?: JoopCircuitBreakerConfig);
+    get state(): JoopCircuitState;
+    get name(): string;
+    private setState;
+    private recordSuccess;
+    private recordFailure;
+    private canAttempt;
+    /** Primary execution method — throws JoopCircuitBreakerOpenError when open. */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /** Alias kept for back-compat with original `call()` interface. */
+    call<T>(fn: () => Promise<T>): Promise<T>;
+    executeWithFallback<T>(fn: () => Promise<T>, fallback: () => Promise<T> | T): Promise<T>;
+    getState(): JoopCircuitState;
+    getStats(): JoopCircuitBreakerStats;
+    reset(): void;
+    forceOpen(): void;
+    forceClose(): void;
+}
+declare class JoopCircuitBreakerRegistry {
+    private static readonly store;
+    static get(name: string, config?: JoopCircuitBreakerConfig): JoopCircuitBreaker;
+    static getAll(): Map<string, JoopCircuitBreaker>;
+    static reset(name?: string): void;
+}
+
+declare class JoopOfflineQueue {
+    private _queue;
+    private _online;
+    private _draining;
+    constructor();
+    isOnline(): boolean;
+    queueLength(): number;
+    enqueue<T>(fn: () => Promise<T>): Promise<T>;
+    drainNow(): Promise<void>;
+    clear(): void;
+    private _onOnline;
+}
+
+interface JoopPollConfig<T> {
+    fn: () => Promise<T>;
+    intervalMs: number;
+    immediate?: boolean;
+    stopWhen?: (result: T) => boolean;
+    onError?: (err: unknown) => void;
+}
+declare class JoopPollingService {
+    private _timers;
+    private _subjects;
+    start<T>(id: string, config: JoopPollConfig<T>): JoopSubject<T>;
+    stop(id: string): void;
+    stopAll(): void;
+    isPolling(id: string): boolean;
+}
+
+type JoopErrorType = 'screen' | 'popup' | 'quiet' | 'inline';
+interface JoopError {
+    status?: number;
+    title?: string;
+    message?: string;
+    description?: string;
+    icon?: string;
+    style?: string;
+    isTimeout?: boolean;
+    type?: JoopErrorType;
+    customData?: any;
+    buttons?: JoopErrorButton[];
+}
+interface JoopErrorButton {
+    label: string;
+    action?: string;
+    style?: string;
+    actionData?: any;
+}
+declare class JoopHttpError extends Error {
+    readonly statusCode: number;
+    readonly statusText: string;
+    readonly body?: any | undefined;
+    constructor(statusCode: number, statusText: string, body?: any | undefined);
+}
+declare class JoopEncryptionError extends Error {
+    constructor(message: string);
+}
+
+type JoopLoadingState = {
+    active: boolean;
+    count: number;
+};
+/**
+ * High-level service request dispatcher.
+ *
+ * - Serialises request data
+ * - Optionally encrypts (AES E2E)
+ * - Tracks concurrent requests for loader visibility
+ * - Decrypts encrypted responses
+ */
+declare class JoopRequestService {
+    private readonly _http;
+    private readonly _config;
+    private readonly _profile;
+    private readonly _aes;
+    private readonly _loading$;
+    private _requestCount;
+    constructor(_http: JoopHttpClient, _config: JoopConfigService, _profile: JoopClientProfile, _aes: JoopAesService);
+    /** Observable loading state — subscribe in any framework to drive a spinner. */
+    loading$(): JoopObservable<JoopLoadingState>;
+    isLoading(): boolean;
+    /**
+     * Send a service request to the configured base URL.
+     * @param serviceId  Service/endpoint identifier appended to the base URL
+     * @param data       Request payload
+     * @param options    Loader, error, method overrides
+     */
+    send<T = any>(serviceId: string, data?: Record<string, any>, options?: JoopRequestOptions): Promise<T>;
+    /** Upload a file with progress. */
+    upload<T = any>(serviceId: string, formData: FormData, onProgress: (pct: number) => void): Promise<T>;
+    private _buildUrl;
+    private _prepareBody;
+    private _handleResponse;
+    private _incrementLoader;
+    private _decrementLoader;
+}
+/** Convenience: catch JoopHttpError by status code. */
+declare function isHttpError(err: unknown, status?: number): err is JoopHttpError;
+
+interface JoopDownloadOptions {
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    body?: string | FormData;
+    iosHandlerName?: string;
+}
+declare class JoopFileSaverService {
+    isIosWebView(handlerName?: string): boolean;
+    download(url: string, options?: JoopDownloadOptions): Promise<void>;
+    saveBlob(blob: Blob, fileName: string): void;
+    blobToBase64(blob: Blob): Promise<string>;
+    getMimeType(fileName: string): string;
+    typedBlob(blob: Blob, fileName: string): Blob;
+    private _sendToIos;
+    private _fileNameFromHeaders;
+}
+
+interface JoopRawComponent6 {
+    compKey: string;
+    compValue: string;
+}
+interface JoopRawResponse6 {
+    scrId?: string;
+    scrid?: string;
+    compDet?: JoopRawComponent6[];
+    segments?: string;
+    mxenc?: string;
+    mxencres?: string;
+    errorCode?: string;
+    errorDesc?: string;
+}
+interface JoopRawResponse {
+    scrid?: string;
+    segments?: string;
+    mxenc?: string;
+    mxencres?: string;
+    components?: Record<string, string>;
+    errorCode?: string;
+    errorDesc?: string;
+}
+interface JoopMappedComponent {
+    key: string;
+    value: string;
+    scope: string;
+    dataKey: string;
+}
+interface JoopMappedResponse {
+    scrid: string;
+    segments: string;
+    mxenc: string;
+    mxencres: string;
+    components: Record<string, string>;
+    componentList: JoopMappedComponent[];
+    errorCode?: string;
+    errorDesc?: string;
+    hasError: boolean;
+}
+declare class JoopResponseMapper {
+    /** Normalize a v6 or v7+ raw API response into a typed mapped response */
+    map(raw: JoopRawResponse | JoopRawResponse6): JoopMappedResponse;
+    /** Extract scope prefix from a component key (first char: M/O/N/S) */
+    extractScope(key: string): string;
+    /** Extract data key portion (everything after the first character) */
+    extractDataKey(key: string): string;
+    /**
+     * Build a property map from component list — groups by scope prefix.
+     * e.g. "MUserName" → { scope: 'M', dataKey: 'UserName', value: '...' }
+     */
+    buildScopedMap(response: JoopMappedResponse): Record<string, Record<string, string>>;
+    /** Get a single component value from a mapped response */
+    getComponent(response: JoopMappedResponse, key: string): string | null;
+    /** Check if the raw payload looks like a v7+ response (has 'components' key) */
+    private _isV7;
+    private _convertV6ToV7;
+}
+
+interface JoopCsvOptions {
+    delimiter?: string;
+    headers?: string[];
+    includeHeaders?: boolean;
+    bom?: boolean;
+    nullValue?: string;
+}
+declare class JoopExportService {
+    /** Convert an array of objects to a CSV string */
+    toCsv(data: Record<string, unknown>[], options?: JoopCsvOptions): string;
+    /** Trigger browser download of a CSV string */
+    downloadCsv(data: Record<string, unknown>[], filename: string, options?: JoopCsvOptions): void;
+    /** Download Excel-compatible CSV (with BOM so Excel reads UTF-8 correctly) */
+    downloadExcel(data: Record<string, unknown>[], filename: string, options?: JoopCsvOptions): void;
+    /** Convert data to a JSON string and download */
+    downloadJson(data: unknown, filename: string, indent?: number): void;
+    /** Download a plain-text file */
+    downloadText(content: string, filename: string): void;
+    /** Convert a 2D array (table) to CSV */
+    tableToCsv(rows: unknown[][], headers?: string[], delimiter?: string): string;
+    private _download;
+}
+
+type JoopWebhookProvider = 'stripe' | 'github' | 'generic';
+interface JoopWebhookOptions {
+    toleranceSeconds?: number;
+    algorithm?: 'SHA-256' | 'SHA-1' | 'SHA-512';
+}
+declare class JoopWebhookVerifier {
+    private _provider;
+    for(provider: JoopWebhookProvider): JoopWebhookVerifier;
+    verify(payload: string, signature: string, secret: string, opts?: JoopWebhookOptions): Promise<boolean>;
+    /** Stripe: `Stripe-Signature: t=...,v1=...` */
+    verifyStripe(payload: string, header: string, secret: string, opts?: JoopWebhookOptions): Promise<boolean>;
+    /** GitHub: `X-Hub-Signature-256: sha256=...` */
+    verifyGitHub(payload: string, header: string, secret: string, opts?: JoopWebhookOptions): Promise<boolean>;
+    /** Generic HMAC verification. signature is a hex string. */
+    verifyGeneric(payload: string, signature: string, secret: string, opts?: JoopWebhookOptions): Promise<boolean>;
+    /** Returns true if the timestamp is within tolerance of now */
+    verifyTimestamp(timestamp: number, toleranceSeconds?: number): boolean;
+    /** Compute the expected HMAC for a payload (for testing) */
+    sign(payload: string, secret: string, algo?: AlgorithmIdentifier): Promise<string>;
+}
+
+interface JoopIdempotencyConfig {
+    storage?: JoopStorageAdapter;
+    ttlMs?: number;
+    prefix?: string;
+}
+declare class JoopIdempotencyService {
+    private _storage;
+    private _ttlMs;
+    private _prefix;
+    /** Internal key registry used for clearAll() and gc() (avoids requiring Storage.length/key()) */
+    private _keys;
+    constructor(config?: JoopIdempotencyConfig);
+    /**
+     * Generate and store an idempotency key for the given operation.
+     * Returns an existing (non-expired) key if one already exists.
+     */
+    generate(operationKey: string): string;
+    /** Get the stored key for an operation, or null if expired/not found */
+    get(operationKey: string): string | null;
+    /** Remove the key for an operation (e.g. after successful completion) */
+    clear(operationKey: string): void;
+    /** Clear all idempotency keys managed by this instance */
+    clearAll(): void;
+    /**
+     * Wrap a fetch-based function with automatic idempotency key injection.
+     * Clears the key on success; keeps it on failure so retries reuse the same key.
+     */
+    wrap<T>(operationKey: string, fn: (idempotencyKey: string) => Promise<T>): Promise<T>;
+    /** Remove all expired entries */
+    gc(): void;
+}
+
+export { type JoopLoadingState as A, type JoopMappedComponent as B, type JoopMappedResponse as C, type JoopPollConfig as D, type JoopRawResponse as E, type JoopRawResponse6 as F, type JoopRequest as G, type JoopRequestInterceptor as H, type JoopResponse as I, JoopHttpClient as J, type JoopResponseInterceptor as K, type JoopWebhookOptions as L, type JoopWebhookProvider as M, isHttpError as N, type JoopRawComponent6 as O, JoopInterceptorPipeline as a, JoopCircuitBreaker as b, JoopOfflineQueue as c, JoopPollingService as d, JoopRequestService as e, JoopFileSaverService as f, JoopResponseMapper as g, JoopExportService as h, JoopWebhookVerifier as i, JoopIdempotencyService as j, type JoopCircuitBreakerConfig as k, JoopCircuitBreakerOpenError as l, JoopCircuitBreakerRegistry as m, type JoopCircuitBreakerState as n, type JoopCircuitBreakerStats as o, type JoopCircuitState as p, type JoopCsvOptions as q, type JoopDownloadOptions as r, JoopEncryptionError as s, type JoopError as t, type JoopErrorButton as u, type JoopErrorInterceptor as v, type JoopErrorType as w, type JoopFetchOptions as x, JoopHttpError as y, type JoopIdempotencyConfig as z };