@sdcorejs/angular 20.1.3 → 20.1.4

package/fesm2022/sdcorejs-angular-services-api.mjs

@@ -1,31 +1,39 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, NgModule } from '@angular/core';
-import { HttpClient, HttpResponse, HTTP_INTERCEPTORS, provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
+import { InjectionToken, inject, DestroyRef, Injectable, NgModule } from '@angular/core';
+import { HttpClient, HttpRequest, HttpResponse, HttpErrorResponse, HttpHeaders, HttpParams, HTTP_INTERCEPTORS, provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
 import { SdCacheService } from '@sdcorejs/angular/services/cache';
 import { BrowserUtilities, Utilities } from '@sdcorejs/utils/fns';
-import { lastValueFrom, from, throwError } from 'rxjs';
-import { timeout, map, catchError, shareReplay, switchMap } from 'rxjs/operators';
+import { Subscription, throwError, timer, of, TimeoutError, from, defer } from 'rxjs';
+import { timeout, filter, map, retry, switchMap, materialize, concatMap, catchError, dematerialize } from 'rxjs/operators';
 
 const SD_API_CONFIG = new InjectionToken('sd-api.configuration');
-const SD_API_CONFIGURATION = new InjectionToken('sd-api.configuration');
+/** @deprecated Use `SD_API_CONFIG`. This is the same injection token. */
+const SD_API_CONFIGURATION = SD_API_CONFIG;
 
+/**
+ * Response generics intentionally default to `unknown` for type safety.
+ * Callers should specify `T`; migration guidance is tracked for Task 13.
+ */
 class SdApiService {
-    #defaultTimeout = 60000; // 60s
-    #dedupCacheDuration = 1000; // 1s (Deduplication cache duration)
+    #defaultTimeout = 60000;
+    #defaultDedupeWindowMs = 1000;
+    #maxTimerMs = 2_147_483_647;
+    #maxRetryAttempts = 10;
     #httpClient = inject(HttpClient);
-    #configurations = inject(SD_API_CONFIG, { optional: true }) || [];
+    #configurations = inject(SD_API_CONFIG, { optional: true }) ?? [];
     #cacheService = inject(SdCacheService);
-    // Thay đổi cấu trúc Cache: Lưu Observable thay vì Subject phức tạp
-    // Key: hash string -> Value: { stream$: Observable, expiry: number }
-    #inFlightRequests = new Map();
+    #destroyRef = inject(DestroyRef);
+    #sharedRequests = new Map();
+    #activeRequests = new Set();
+    #objectIds = new WeakMap();
+    #nextObjectId = 1;
+    #destroyed = false;
     constructor() {
-        // Optional: Cơ chế dọn dẹp cache định kỳ (mỗi 1 phút dọn dẹp các key hết hạn)
-        setInterval(() => this.#cleanupCache(), 60000);
+        this.#destroyRef.onDestroy(() => this.#destroy());
     }
     get http() {
         return this.#httpClient;
     }
-    // --- PUBLIC METHODS ---
     get = (url, option) => {
         return this.#executeWithLayeredCache(url, 'GET', undefined, option);
     };
@@ -35,15 +43,18 @@ class SdApiService {
     put = (url, body, option) => {
         return this.#executeWithLayeredCache(url, 'PUT', body, option);
     };
+    patch = (url, body, option) => {
+        return this.#executeWithLayeredCache(url, 'PATCH', body, option);
+    };
     delete = (url, option) => {
         return this.#executeWithLayeredCache(url, 'DELETE', undefined, option);
     };
-    // Upload file logic giữ nguyên nhưng refactor nhẹ
     upload = async (url, option) => {
         const file = await BrowserUtilities.upload(option);
         if (!Array.isArray(file) && file) {
             return this.uploadFile(url, file);
         }
+        return undefined;
     };
     uploadFile = async (url, file) => {
         if (!file)
@@ -52,105 +63,367 @@ class SdApiService {
             throw new Error('Invalid file extension');
         const formData = new FormData();
         formData.append('file', file, file.name);
-        // Upload thường không cần deduplication cache, set autoCache: false
-        return await this.post(url, formData, { autoCache: false });
+        return this.post(url, formData, { dedupe: false });
     };
-    // --- PRIVATE CORE LOGIC ---
-    /**
-     * Hàm trung gian xử lý Layer Cache (SdCacheService) trước khi gọi API thực tế
-     */
-    #executeWithLayeredCache = async (url, method, body, option) => {
-        // Layer 1: Persistent Cache (SdCacheService)
-        if (option?.cacheOption) {
-            const key = this.#generateKey(url, method, body, option);
-            const { get, set, has } = this.#cacheService.create(key, option.cacheOption);
-            if (has()) {
-                return get();
-            }
+    async #executeWithLayeredCache(url, method, body, option) {
+        if (this.#destroyed || option?.signal?.aborted) {
+            throw this.#createAbortError();
+        }
+        if (!option?.cacheOption) {
+            return this.#request(url, method, body, option);
+        }
+        const key = this.#generateKey(url, method, body, option);
+        const cache = this.#cacheService.create(key, option.cacheOption);
+        try {
+            const cached = cache.snapshot();
+            if (cached.present)
+                return cached.value;
             const result = await this.#request(url, method, body, option);
-            set(result);
+            cache.set(result);
             return result;
         }
-        // Không có cache dài hạn thì gọi trực tiếp logic deduplication
-        return this.#request(url, method, body, option);
-    };
-    /**
-     * Core Request: Xử lý Deduplication, Timeout, Mapping Response
-     */
-    #request = (url, method, body, option) => {
-        const key = this.#generateKey(url, method, body, option);
-        // Layer 2: Deduplication Cache (In-Flight Request / Short-term cache)
-        const now = Date.now();
-        const cachedItem = this.#inFlightRequests.get(key);
-        // Nếu đã có request đang chạy hoặc mới chạy xong trong vòng 1s -> Trả về stream đó luôn
-        if (cachedItem && cachedItem.expiry > now) {
-            return lastValueFrom(cachedItem.stream$);
-        }
-        // Setup request mới
+        finally {
+            cache.release();
+        }
+    }
+    #request(url, method, body, option) {
+        if (this.#destroyed || option?.signal?.aborted) {
+            return Promise.reject(this.#createAbortError());
+        }
+        const shouldDedupe = option?.dedupe ?? option?.autoCache ?? method === 'GET';
+        const key = shouldDedupe ? this.#generateRequestKey(url, method, body, option) : undefined;
+        let request = key ? this.#sharedRequests.get(key) : undefined;
+        if (!request) {
+            const prepared = this.#prepareRequest(url, method, body, option, key);
+            request = prepared.request;
+            if (key)
+                this.#sharedRequests.set(key, request);
+            this.#startRequest(request, prepared.source);
+        }
+        return this.#attachCaller(request, option?.signal);
+    }
+    #prepareRequest(url, method, body, option, key) {
+        let resolve;
+        let reject;
+        const promise = new Promise((resolvePromise, rejectPromise) => {
+            resolve = resolvePromise;
+            reject = rejectPromise;
+        });
+        const request = {
+            key,
+            replayWindowMs: this.#normalizeDedupeWindow(option?.dedupeWindowMs),
+            promise,
+            resolve,
+            reject,
+            subscription: Subscription.EMPTY,
+            owners: 0,
+            state: 'pending',
+        };
+        this.#activeRequests.add(request);
         const handler = this.#getHandler(url);
-        const apiTimeout = option?.timeout ?? handler?.timeout ?? this.#defaultTimeout;
-        // Tạo Observable call API
-        const request$ = this.#httpClient
-            .request(method, url, {
-            body,
-            headers: option?.headers,
-            params: option?.params,
-            observe: 'response', // Lấy full response để check status
-            responseType: option?.responseType,
-        })
-            .pipe(timeout(apiTimeout), map(res => {
-            // Normalize Response Logic
-            const bodyRes = res.body;
-            // Logic check response cũ của bạn
-            if (bodyRes && typeof bodyRes === 'object' && 'ok' in bodyRes && !bodyRes.ok) {
-                throw bodyRes; // Giả sử structure trả về { ok: false, ... } là lỗi
-            }
-            if (handler?.mapResponse) {
-                return handler.mapResponse(bodyRes);
+        const httpRequest = new HttpRequest(method, url, body ?? null, {
+            headers: this.#toHttpHeaders(option?.headers),
+            context: option?.context,
+            params: this.#toHttpParams(option?.params),
+            reportProgress: option?.reportProgress,
+            responseType: option?.responseType ?? 'json',
+            withCredentials: option?.withCredentials,
+            transferCache: option?.transferCache,
+        });
+        const source = this.#withRetry(this.#httpClient.request(httpRequest).pipe(timeout(this.#resolveTimeout(url, option?.timeout)), filter((event) => event instanceof HttpResponse), map(response => this.#mapResponse(response.body, handler))), method, option?.retry);
+        return { request, source };
+    }
+    #startRequest(request, source) {
+        request.subscription = source.subscribe({
+            next: value => this.#completeSuccess(request, value),
+            error: error => this.#completeError(request, error),
+            complete: () => {
+                if (request.state === 'pending') {
+                    this.#completeError(request, new Error('HTTP request completed without a response'));
+                }
+            },
+        });
+    }
+    #attachCaller(request, signal) {
+        request.owners++;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const cleanup = () => {
+                if (signal)
+                    signal.removeEventListener('abort', abort);
+            };
+            const release = () => {
+                request.owners = Math.max(0, request.owners - 1);
+                if (request.state === 'pending' && request.owners === 0) {
+                    this.#cancelRequest(request);
+                }
+            };
+            const abort = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                release();
+                reject(this.#createAbortError());
+            };
+            if (signal) {
+                signal.addEventListener('abort', abort, { once: true });
+                if (signal.aborted) {
+                    abort();
+                    return;
+                }
             }
-            return bodyRes;
-        }), catchError(err => {
-            // Xóa cache ngay lập tức nếu lỗi để user có thể retry
-            this.#inFlightRequests.delete(key);
-            throw err;
-        }), 
-        // QUAN TRỌNG: shareReplay(1) giúp share kết quả cho các subscriber đến sau (trong 1s)
-        shareReplay(1));
-        // Lưu vào Map
-        this.#inFlightRequests.set(key, {
-            stream$: request$,
-            expiry: now + this.#dedupCacheDuration,
+            request.promise.then(value => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                release();
+                resolve(value);
+            }, error => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                release();
+                reject(error);
+            });
         });
-        // Chuyển đổi sang Promise cho đúng return type của bạn
-        return lastValueFrom(request$);
-    };
-    // --- HELPERS ---
-    #getHandler = (url) => {
-        const handlers = this.#configurations.flatMap(b => b?.handlers || []);
-        return handlers.find(e => e.hosts.some(host => url.startsWith(host)));
-    };
-    #generateKey = (url, method, body, option) => {
-        // FormData không hash được nội dung file, luôn generate key mới
-        if (body instanceof FormData || option?.autoCache === false) {
-            return Utilities.generateUuid();
+    }
+    #completeSuccess(request, value) {
+        if (request.state !== 'pending')
+            return;
+        request.state = 'succeeded';
+        request.resolve(value);
+        if (!request.key) {
+            this.#activeRequests.delete(request);
+            return;
+        }
+        if (request.replayWindowMs === 0) {
+            this.#evictRequest(request);
+            return;
         }
+        request.replayTimer = setTimeout(() => this.#evictRequest(request), request.replayWindowMs);
+    }
+    #completeError(request, error) {
+        if (request.state !== 'pending')
+            return;
+        request.state = 'failed';
+        this.#removeRequest(request);
+        request.reject(error);
+    }
+    #cancelRequest(request) {
+        if (request.state !== 'pending')
+            return;
+        request.state = 'cancelled';
+        request.subscription.unsubscribe();
+        this.#removeRequest(request);
+        request.reject(this.#createAbortError());
+    }
+    #evictRequest(request) {
+        if (request.replayTimer !== undefined) {
+            clearTimeout(request.replayTimer);
+            request.replayTimer = undefined;
+        }
+        this.#removeRequest(request);
+    }
+    #removeRequest(request) {
+        if (request.key && this.#sharedRequests.get(request.key) === request) {
+            this.#sharedRequests.delete(request.key);
+        }
+        this.#activeRequests.delete(request);
+    }
+    #withRetry(source, method, option) {
+        const attempts = this.#normalizeRetryAttempts(option?.attempts);
+        const mutation = method !== 'GET';
+        if (attempts === 0 || (mutation && option?.mutations !== true)) {
+            return source;
+        }
+        return source.pipe(retry({
+            count: attempts,
+            delay: (error, attempt) => {
+                if (this.#isAbortError(error) || !this.#shouldRetry(error, attempt, option)) {
+                    return throwError(() => error);
+                }
+                const baseDelay = this.#normalizeRetryDelay(option?.delayMs);
+                const backoff = this.#normalizeRetryBackoff(option?.backoff);
+                const computedDelay = baseDelay * Math.pow(backoff, attempt - 1);
+                const delayMs = Number.isFinite(computedDelay) ? Math.min(this.#maxTimerMs, computedDelay) : this.#maxTimerMs;
+                return delayMs > 0 ? timer(delayMs) : of(undefined);
+            },
+        }));
+    }
+    #shouldRetry(error, attempt, option) {
+        if (option?.retryWhen) {
+            return option.retryWhen(error, attempt);
+        }
+        if (error instanceof TimeoutError)
+            return true;
+        if (!(error instanceof HttpErrorResponse))
+            return false;
+        return error.status === 0 || [408, 425, 429, 500, 502, 503, 504].includes(error.status);
+    }
+    #mapResponse(body, handler) {
+        if (body !== null && typeof body === 'object' && 'ok' in body && body.ok === false) {
+            throw body;
+        }
+        return handler?.mapResponse ? handler.mapResponse(body) : body;
+    }
+    #getHandler(url) {
+        const handlers = this.#configurations.flatMap(configuration => configuration.handlers ?? []);
+        return handlers.find(handler => handler.hosts.some(host => url.startsWith(host)));
+    }
+    #generateKey(url, method, body, option) {
         return Utilities.hash({
-            url,
             method,
-            params: option?.params,
-            headers: option?.headers,
-            body,
+            url,
+            body: this.#normalizeBody(body),
+            headers: this.#normalizeHeaders(option?.headers),
+            params: this.#normalizeParams(option?.params),
+            context: option?.context ? this.#getObjectId(option.context) : undefined,
+            reportProgress: option?.reportProgress ?? false,
+            responseType: option?.responseType ?? 'json',
+            withCredentials: option?.withCredentials ?? false,
+            transferCache: option?.transferCache,
+            timeout: this.#resolveTimeout(url, option?.timeout),
+            retry: option?.retry
+                ? {
+                    attempts: this.#normalizeRetryAttempts(option.retry.attempts),
+                    delayMs: this.#normalizeRetryDelay(option.retry.delayMs),
+                    backoff: this.#normalizeRetryBackoff(option.retry.backoff),
+                    mutations: option.retry.mutations,
+                    retryWhen: option.retry.retryWhen ? this.#getObjectId(option.retry.retryWhen) : undefined,
+                }
+                : undefined,
         });
-    };
-    // Dọn dẹp memory leak
-    #cleanupCache() {
-        const now = Date.now();
-        this.#inFlightRequests.forEach((value, key) => {
-            if (value.expiry < now) {
-                this.#inFlightRequests.delete(key);
-            }
+    }
+    #generateRequestKey(url, method, body, option) {
+        return Utilities.hash({
+            responseKey: this.#generateKey(url, method, body, option),
+            dedupeWindowMs: this.#normalizeDedupeWindow(option?.dedupeWindowMs),
         });
     }
+    #normalizeDedupeWindow(dedupeWindowMs) {
+        return this.#normalizeFiniteNumber(dedupeWindowMs, this.#defaultDedupeWindowMs, 0, this.#maxTimerMs);
+    }
+    #resolveTimeout(url, timeoutMs) {
+        const configuredTimeout = timeoutMs === undefined ? this.#getHandler(url)?.timeout : timeoutMs;
+        return this.#normalizeFiniteNumber(configuredTimeout, this.#defaultTimeout, 0, this.#maxTimerMs);
+    }
+    #normalizeRetryAttempts(attempts) {
+        return Math.floor(this.#normalizeFiniteNumber(attempts, 0, 0, this.#maxRetryAttempts));
+    }
+    #normalizeRetryDelay(delayMs) {
+        return this.#normalizeFiniteNumber(delayMs, 0, 0, this.#maxTimerMs);
+    }
+    #normalizeRetryBackoff(backoff) {
+        const normalized = this.#normalizeFiniteNumber(backoff, 1, 0, this.#maxTimerMs);
+        return normalized > 0 ? normalized : 1;
+    }
+    #normalizeFiniteNumber(value, defaultValue, minimum, maximum) {
+        if (value === undefined || !Number.isFinite(value))
+            return defaultValue;
+        return Math.min(maximum, Math.max(minimum, value));
+    }
+    #normalizeBody(body, ancestors = new WeakSet()) {
+        if (body === null || typeof body !== 'object')
+            return body;
+        if (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams) {
+            return { urlSearchParams: body.toString() };
+        }
+        if (typeof FormData !== 'undefined' && body instanceof FormData) {
+            return { objectType: 'FormData', objectId: this.#getObjectId(body) };
+        }
+        if (typeof Blob !== 'undefined' && body instanceof Blob) {
+            return { objectType: 'Blob', objectId: this.#getObjectId(body) };
+        }
+        if (typeof ArrayBuffer !== 'undefined' && (body instanceof ArrayBuffer || ArrayBuffer.isView(body))) {
+            return { objectType: 'ArrayBuffer', objectId: this.#getObjectId(body) };
+        }
+        if (body instanceof Date) {
+            return { date: body.getTime() };
+        }
+        if (ancestors.has(body)) {
+            return { circularObjectId: this.#getObjectId(body) };
+        }
+        if (Array.isArray(body)) {
+            ancestors.add(body);
+            const normalized = body.map(value => this.#normalizeBody(value, ancestors));
+            ancestors.delete(body);
+            return normalized;
+        }
+        const prototype = Object.getPrototypeOf(body);
+        if (prototype === Object.prototype || prototype === null) {
+            ancestors.add(body);
+            const normalized = Object.fromEntries(Object.entries(body).map(([key, value]) => [key, this.#normalizeBody(value, ancestors)]));
+            ancestors.delete(body);
+            return normalized;
+        }
+        return { objectType: prototype?.constructor?.name ?? 'Object', objectId: this.#getObjectId(body) };
+    }
+    #normalizeHeaders(headers) {
+        if (headers instanceof HttpHeaders) {
+            return headers
+                .keys()
+                .sort()
+                .map(key => [key.toLowerCase(), headers.getAll(key)]);
+        }
+        return headers;
+    }
+    #normalizeParams(params) {
+        if (params instanceof HttpParams) {
+            return params
+                .keys()
+                .sort()
+                .map(key => [key, params.getAll(key)]);
+        }
+        return params;
+    }
+    #toHttpHeaders(headers) {
+        if (!headers || headers instanceof HttpHeaders)
+            return headers;
+        return new HttpHeaders(headers);
+    }
+    #toHttpParams(params) {
+        if (!params || params instanceof HttpParams)
+            return params;
+        return new HttpParams({ fromObject: params });
+    }
+    #getObjectId(value) {
+        const existing = this.#objectIds.get(value);
+        if (existing !== undefined)
+            return existing;
+        const id = this.#nextObjectId++;
+        this.#objectIds.set(value, id);
+        return id;
+    }
+    #createAbortError() {
+        const error = new Error('The operation was aborted');
+        error.name = 'AbortError';
+        return error;
+    }
+    #isAbortError(error) {
+        return error instanceof Error && error.name === 'AbortError';
+    }
+    #destroy() {
+        if (this.#destroyed)
+            return;
+        this.#destroyed = true;
+        for (const request of [...this.#activeRequests]) {
+            if (request.replayTimer !== undefined) {
+                clearTimeout(request.replayTimer);
+                request.replayTimer = undefined;
+            }
+            if (request.state === 'pending') {
+                request.state = 'cancelled';
+                request.subscription.unsubscribe();
+                request.reject(this.#createAbortError());
+            }
+            this.#removeRequest(request);
+        }
+        this.#sharedRequests.clear();
+        this.#activeRequests.clear();
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: SdApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: SdApiService, providedIn: 'root' });
 }
@@ -162,46 +435,43 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImpo
         }], ctorParameters: () => [] });
 
 class SdHttpInterceptor {
-    #configurations = inject(SD_API_CONFIG, { optional: true }) || [];
+    #configurations = inject(SD_API_CONFIG, { optional: true }) ?? [];
     intercept(request, next) {
-        const url = request.url;
-        if (!url) {
-            throw new Error(`Invalid URL`);
-        }
-        const handlers = this.#configurations.flatMap(configuration => configuration?.handlers || []);
-        const handler = handlers?.find(e => e.hosts.some(host => url.startsWith(host)));
-        const intercept = handler?.intercept;
-        if (intercept) {
-            request = request.clone(intercept(request));
-        }
-        if (request.body instanceof FormData) {
-            request = request.clone({
-                headers: request.headers.delete('Content-Type'),
-            });
+        if (!request.url)
+            throw new Error('Invalid URL');
+        const handler = this.#findHandler(request.url);
+        if (handler?.intercept) {
+            const interceptedRequest = handler.intercept(request);
+            request = interceptedRequest instanceof HttpRequest ? interceptedRequest : request.clone(interceptedRequest);
+        }
+        if (typeof FormData !== 'undefined' && request.body instanceof FormData) {
+            request = request.clone({ headers: request.headers.delete('Content-Type') });
         }
-        const beforeRemoteHandler = handler?.beforeRemote;
-        const afterRemoteHandler = handler?.afterRemote;
-        const beforeRemote = beforeRemoteHandler?.(request);
+        const beforeRemote = handler?.beforeRemote?.(request);
         if (beforeRemote instanceof Promise) {
-            return from(beforeRemote).pipe(switchMap(() => next.handle(request)), map((event) => {
-                if (event instanceof HttpResponse) {
-                    afterRemoteHandler?.(event);
-                }
-                return event;
-            }), catchError((error) => {
-                afterRemoteHandler?.(error);
-                return throwError(() => error);
-            }));
-        }
-        return next.handle(request).pipe(map((event) => {
-            if (event instanceof HttpResponse) {
-                afterRemoteHandler?.(event);
+            return from(beforeRemote).pipe(switchMap(() => this.#handleRemote(request, next, handler)));
+        }
+        return this.#handleRemote(request, next, handler);
+    }
+    #handleRemote(request, next, handler) {
+        return next.handle(request).pipe(materialize(), concatMap(notification => {
+            const afterValue = notification.kind === 'N' && notification.value instanceof HttpResponse
+                ? notification.value
+                : notification.kind === 'E' && (notification.error instanceof Error || notification.error instanceof HttpErrorResponse)
+                    ? notification.error
+                    : undefined;
+            if (!afterValue || !handler?.afterRemote) {
+                return of(notification);
             }
-            return event;
-        }), catchError((error) => {
-            afterRemoteHandler?.(error);
-            return throwError(() => error);
-        }));
+            return defer(() => {
+                const result = handler.afterRemote?.(afterValue);
+                return result instanceof Promise ? result : Promise.resolve();
+            }).pipe(map(() => notification), catchError(hookError => (notification.kind === 'E' ? of(notification) : throwError(() => hookError))));
+        }), dematerialize());
+    }
+    #findHandler(url) {
+        const handlers = this.#configurations.flatMap(configuration => configuration.handlers ?? []);
+        return handlers.find(handler => handler.hosts.some(host => url.startsWith(host)));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: SdHttpInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: SdHttpInterceptor });