http-request-manager 18.15.34 → 18.16.1

package/src/lib/services/utils/path-query.service.ts

@@ -1,69 +0,0 @@
-import { Injectable } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class PathQueryService {
-
-  buildAPIPath(server: string|string[], params?: any[]|any) {
-
-    server = (Array.isArray(server)) ? server.join('/') : server
-
-    const pathObjects = (params) ? params.filter((path:any) => (!this.isObject(path))) : []
-    const queryObjects = (params) ? params.filter((path:any) => (this.isObject(path))) : []
-
-    const query = this.removeEmptyParams(queryObjects.reduce((r: any, c: any) => {
-      Object.entries(c).forEach(([key, value]) => {
-        r[key] = Array.isArray(value) ? value.join(',') : value
-      })
-      return r
-    }, {}))
-
-    let path = this.buildRestPath(server, pathObjects)
-
-    return(Object.keys(query).length > 0) ? path + '?' + this.buildQueryPath(query) : path
-
-  }
-
-  private buildRestPath(server: string, params: any[]): string {
-    server = (server) ? server : ''
-    server = (server.charAt(0) === '/') ? server.substring(1) : server
-    return this.cleanUrlPath(server +'/'+ params.join('/'))
-  }
-
-  private buildQueryPath(params: any): string {
-
-    const searchParams = new URLSearchParams()
-
-    for (const key in params) {
-
-      if (Array.isArray(params[key])) {
-        params[key].forEach((value: any) => searchParams.append(key, value));
-      } else {
-        searchParams.append(key, params[key]);
-      }
-
-    }
-
-    return searchParams.toString()
-
-  }
-
-  private cleanUrlPath(str: string) {
-    return str.replace(/([^:]\/)\/+/g, "$1").replace(/\/$/,'')
-  }
-
-  private isObject(val: any): boolean {
-    return (val === null) ? false : ( (typeof val === 'function') || (typeof val === 'object') )
-  }
-
-  private removeEmptyParams = (obj: any): Record<string, any> =>
-    Object.fromEntries(
-      Object.entries(obj)
-        .map(([key, value]) =>
-          [key, value && typeof value === 'object' ? this.removeEmptyParams(value) : value]
-        )
-        .filter(([_, value]) => value !== undefined && value !== "")
-    )
-
-}

package/src/lib/services/utils/query-params-tracker.service.ts

@@ -1,442 +0,0 @@
-// import { inject, Injectable } from '@angular/core';
-// import { BehaviorSubject } from 'rxjs';
-// import { take } from 'rxjs/operators';
-
-// import { LocalStorageManagerService } from '../local-storage-manager-service/local-storage-manager.service';
-// import { SettingOptions } from '../local-storage-manager-service/models/setting-options.model';
-// import { StorageType } from '../local-storage-manager-service/models/storage-type.enum';
-// import {
-//   NormalizedQueryParams,
-//   NormalizedRequestOptionsInterface,
-//   QueryValue
-// } from './models/normalized-request-options.model';
-// import { PathTrackerStateInterface } from './models/path-tracker-state.model';
-// import { QueryParamsTrackerOptionsInterface } from './models/query-params-tracker-options.model';
-// import { QueryTrackerStateInterface, QueryTrackerStateModel } from './models/query-tracker-state.model';
-
-// export type QueryParamsTrackerOptions = QueryParamsTrackerOptionsInterface;
-
-// const TRACKER_STORE_NAME = 'query_params_tracker';
-// const TRACKER_SESSION_INIT_KEY = 'query_params_tracker_initialized';
-// const DEFAULT_TRACKER_OPTIONS = SettingOptions.adapt({
-//   storage: StorageType.GLOBAL,
-//   encrypted: false,
-// });
-
-// @Injectable({
-//   providedIn: 'root'
-// })
-// export class QueryParamsTrackerService {
-
-//   private state: QueryTrackerStateInterface = { paths: {} };
-//   private stateRestored = false;
-//   private readonly localStorageManager = inject(LocalStorageManagerService);
-//   readonly ready$ = new BehaviorSubject<boolean>(false);
-
-//   getPathsSnapshot(): QueryTrackerStateInterface['paths'] {
-//     this.ensureStateRestored();
-//     return QueryTrackerStateModel.adapt(this.state).paths;
-//   }
-
-//   clearTracking(resetSessionInit = false): void {
-//     this.state = { paths: {} };
-//     this.localStorageManager.deleteStore({ name: TRACKER_STORE_NAME });
-
-//     if (resetSessionInit && this.hasSessionStorage()) {
-//       sessionStorage.removeItem(TRACKER_SESSION_INIT_KEY);
-//     }
-//   }
-
-//   clearTrackingForPath(pathKey: string): void {
-//     this.ensureStateRestored();
-//     if (this.state.paths[pathKey]) {
-//       delete this.state.paths[pathKey];
-//       this.persistState();
-//     }
-//   }
-
-//   checkRequestOptions(requestOptions: any[] = [], options: QueryParamsTrackerOptions = {}): boolean {
-//     this.ensureStateRestored();
-
-//     if (!this.ready$.value) {
-//       return true;
-//     }
-
-//     const normalized = this.normalizeRequestOptions(requestOptions);
-
-//     if (!normalized.pathKey) return false;
-
-//     this.cleanupExpiredEntries();
-
-//     if (!normalized.hasQuery) {
-//       const pathState = this.ensurePathState(normalized.pathKey);
-//       const pathSeenBefore = Object.keys(pathState.consumedValuesByKey).length > 0;
-//       if (!pathSeenBefore) {
-//         this.persistState();
-//       }
-//       return !pathSeenBefore;
-//     }
-
-//     if (options.mode === 'exact') {
-//       return this.checkExact(normalized, options);
-//     }
-
-//     return this.checkVariation(normalized, options);
-//   }
-
-//   matchesPath(requestOptions: any[] = [], expectedPathOptions: any[] = []): boolean {
-//     this.ensureStateRestored();
-//     const requestPath = this.normalizeRequestOptions(requestOptions).pathKey;
-//     const expectedPath = this.normalizeRequestOptions(expectedPathOptions).pathKey;
-//     return Boolean(requestPath) && requestPath === expectedPath;
-//   }
-
-//   private checkExact(normalized: NormalizedRequestOptionsInterface, options: QueryParamsTrackerOptions): boolean {
-//     const pathState = this.ensurePathState(normalized.pathKey);
-//     const filteredQuery = this.filterQueryByWatchParams(normalized.query, options.watchParams);
-
-//     if (Object.keys(filteredQuery).length === 0) {
-//       return false;
-//     }
-
-//     const hash = this.stringifyQuery(filteredQuery);
-//     const consumed = pathState.consumedValuesByKey['__exact__'] || [];
-
-//     if (!consumed.includes(hash)) {
-//       pathState.consumedValuesByKey['__exact__'] = [...consumed, hash];
-//       this.persistState();
-//       return true;
-//     }
-
-//     return false;
-//   }
-
-//   private checkVariation(normalized: NormalizedRequestOptionsInterface, options: QueryParamsTrackerOptions): boolean {
-//     const pathState = this.ensurePathState(normalized.pathKey);
-
-//     if (Array.isArray(options.watchParams) && options.watchParams.length === 0) {
-//       const pathSeenBefore = Object.keys(pathState.consumedValuesByKey).length > 0;
-//       if (!pathSeenBefore) {
-//         pathState.watchExpiresAt = this.buildExpiryEpoch(
-//           typeof options.watchExpiresAt !== 'undefined' ? options.watchExpiresAt : options.watchParamsExpire
-//         );
-//         this.persistState();
-//       }
-//       return !pathSeenBefore;
-//     }
-
-//     const filteredQuery = this.filterQueryByWatchParams(normalized.query, options.watchParams);
-//     const keys = Object.keys(filteredQuery);
-
-//     if (keys.length === 0) {
-//       return false;
-//     }
-
-//     this.resetPathStateIfExpired(pathState);
-
-//     let accepted = false;
-
-//     keys.forEach((key) => {
-//       const currentValue = filteredQuery[key];
-//       const consumed = pathState.consumedValuesByKey[key] || [];
-
-//       if (!consumed.includes(currentValue)) {
-//         pathState.consumedValuesByKey[key] = [...consumed, currentValue];
-//         accepted = true;
-//       }
-//     });
-
-//     if (accepted) {
-//       pathState.watchExpiresAt = this.buildExpiryEpoch(
-//         typeof options.watchExpiresAt !== 'undefined' ? options.watchExpiresAt : options.watchParamsExpire
-//       );
-//       this.persistState();
-//     }
-
-//     return accepted;
-//   }
-
-//   private filterQueryByWatchParams(
-//     query: NormalizedQueryParams,
-//     watchParams?: string[]
-//   ): NormalizedQueryParams {
-//     if (!Array.isArray(watchParams)) {
-//       return query;
-//     }
-
-//     if (watchParams.length === 0) {
-//       return {};
-//     }
-
-//     const normalizedWatchParams = watchParams.map((p) => this.normalizeParamKey(p));
-//     return Object.keys(query).reduce((acc, key) => {
-//       if (normalizedWatchParams.includes(key)) {
-//         acc[key] = query[key];
-//       }
-//       return acc;
-//     }, {} as NormalizedQueryParams);
-//   }
-
-//   private normalizeRequestOptions(requestOptions: any[]): NormalizedRequestOptionsInterface {
-//     const params = Array.isArray(requestOptions) ? requestOptions : [];
-//     const pathSegments: string[] = [];
-//     const queryObjects: Record<string, any>[] = [];
-
-//     params.forEach((item) => {
-//       if (this.isPlainObject(item)) {
-//         queryObjects.push(item);
-//       } else if (typeof item !== 'undefined' && item !== null) {
-//         const parsed = this.parsePathSegment(String(item));
-//         if (parsed.pathSegment) {
-//           pathSegments.push(parsed.pathSegment);
-//         }
-//         if (Object.keys(parsed.queryObject).length > 0) {
-//           queryObjects.push(parsed.queryObject);
-//         }
-//       }
-//     });
-
-//     const query = queryObjects.reduce((acc, current) => {
-//       Object.keys(current).forEach((key) => {
-//         const normalizedKey = this.normalizeParamKey(key);
-//         const value = current[key];
-
-//         if (!normalizedKey || typeof value === 'undefined' || value === null || value === '') {
-//           return;
-//         }
-
-//         acc[normalizedKey] = this.normalizeParamValue(value);
-//       });
-
-//       return acc;
-//     }, {} as NormalizedQueryParams);
-
-//     return {
-//       pathKey: this.normalizePath(pathSegments),
-//       query,
-//       hasQuery: Object.keys(query).length > 0,
-//     };
-//   }
-
-//   private parsePathSegment(rawSegment: string): { pathSegment: string; queryObject: Record<string, any> } {
-//     const [pathPart, ...queryParts] = String(rawSegment).split('?');
-//     const queryString = queryParts.join('?');
-//     const queryObject: Record<string, any> = {};
-
-//     if (queryString) {
-//       queryString.split('&').forEach((pair) => {
-//         if (!pair) return;
-
-//         const [rawKey, ...rawValueParts] = pair.split('=');
-//         const key = this.safeDecode(rawKey).trim();
-//         const value = this.safeDecode(rawValueParts.join('=')).trim();
-
-//         if (!key) return;
-
-//         queryObject[key] = value;
-//       });
-//     }
-
-//     return {
-//       pathSegment: pathPart,
-//       queryObject,
-//     };
-//   }
-
-//   private safeDecode(value: string | undefined): string {
-//     if (typeof value === 'undefined') {
-//       return '';
-//     }
-
-//     try {
-//       return decodeURIComponent(value);
-//     } catch {
-//       return String(value);
-//     }
-//   }
-
-//   private normalizePath(pathSegments: string[]): string {
-//     return pathSegments
-//       .map((segment) => String(segment).trim())
-//       .filter((segment) => segment.length > 0)
-//       .join('/')
-//       .replace(/([^:]\/+)\/+/g, '$1')
-//       .replace(/^\//, '')
-//       .replace(/\/$/, '');
-//   }
-
-//   private normalizeParamKey(key: string): string {
-//     return String(key).trim().toLowerCase();
-//   }
-
-//   private normalizeParamValue(value: any): QueryValue {
-//     if (Array.isArray(value)) {
-//       return value.map((item) => this.normalizeParamValue(item)).join(',');
-//     }
-
-//     if (this.isPlainObject(value)) {
-//       return this.stringifyQuery(
-//         Object.keys(value).reduce((acc, key) => {
-//           acc[this.normalizeParamKey(key)] = this.normalizeParamValue(value[key]);
-//           return acc;
-//         }, {} as NormalizedQueryParams)
-//       );
-//     }
-
-//     return String(value).trim().toLowerCase();
-//   }
-
-//   private buildExpiryEpoch(expireIn?: string | number): number | undefined {
-//     if (typeof expireIn === 'undefined' || expireIn === null || expireIn === '') {
-//       return undefined;
-//     }
-
-//     if (typeof expireIn === 'number' && Number.isFinite(expireIn) && expireIn > 0) {
-//       return Math.floor(Date.now() / 1000) + Math.floor(expireIn);
-//     }
-
-//     const raw = String(expireIn).trim().toLowerCase().replace(/\s+/g, '');
-//     const parsed = raw.match(/^(\d+)(y|w|d|hr|h|mn|min|m|s)$/);
-
-//     if (!parsed) {
-//       return undefined;
-//     }
-
-//     const value = Number(parsed[1]);
-//     const unit = parsed[2];
-
-//     const toSeconds: Record<string, number> = {
-//       y: 31556926,
-//       w: 604800,
-//       d: 86400,
-//       hr: 3600,
-//       h: 3600,
-//       mn: 60,
-//       min: 60,
-//       m: 60,
-//       s: 1,
-//     };
-
-//     const seconds = toSeconds[unit];
-
-//     if (!seconds) {
-//       return undefined;
-//     }
-
-//     return Math.floor(Date.now() / 1000) + value * seconds;
-//   }
-
-//   private resetPathStateIfExpired(pathState: PathTrackerStateInterface): void {
-//     const now = Math.floor(Date.now() / 1000);
-
-//     if (pathState.watchExpiresAt && pathState.watchExpiresAt <= now) {
-//       pathState.consumedValuesByKey = {};
-//       pathState.watchExpiresAt = undefined;
-//     }
-//   }
-
-//   private cleanupExpiredEntries(): void {
-//     const now = Math.floor(Date.now() / 1000);
-
-//     Object.keys(this.state.paths).forEach((pathKey) => {
-//       const pathState = this.state.paths[pathKey];
-
-//       if (pathState.watchExpiresAt && pathState.watchExpiresAt <= now) {
-//         pathState.consumedValuesByKey = {};
-//         pathState.watchExpiresAt = undefined;
-//       }
-
-//       const hasTrackedValues = Object.keys(pathState.consumedValuesByKey).some(
-//         (key) => (pathState.consumedValuesByKey[key] || []).length > 0
-//       );
-//       if (!hasTrackedValues) {
-//         delete this.state.paths[pathKey];
-//       }
-//     });
-//   }
-
-//   private ensurePathState(pathKey: string): PathTrackerStateInterface {
-//     if (!this.state.paths[pathKey]) {
-//       this.state.paths[pathKey] = {
-//         consumedValuesByKey: {},
-//       };
-//     }
-
-//     return this.state.paths[pathKey];
-//   }
-
-//   private ensureStateRestored(): void {
-//     if (this.stateRestored) {
-//       return;
-//     }
-
-//     this.stateRestored = true;
-//     this.restoreState();
-//   }
-
-//   private restoreState(): void {
-//     this.localStorageManager.store$(TRACKER_STORE_NAME)
-//       .pipe(take(1))
-//       .subscribe({
-//         next: (storedState: any) => {
-//           if (this.isTrackerState(storedState)) {
-//             this.state = QueryTrackerStateModel.adapt(storedState);
-//             this.cleanupExpiredEntries();
-//           } else {
-//             this.state = { paths: {} };
-//           }
-
-//           this.ready$.next(true);
-//         },
-//         error: () => {
-//           this.state = { paths: {} };
-//           this.ready$.next(true);
-//         }
-//       });
-//   }
-
-//   private persistState(): void {
-//     this.localStorageManager.storeExists$(TRACKER_STORE_NAME)
-//       .pipe(take(1))
-//       .subscribe((exists: boolean) => {
-//         if (exists) {
-//           this.localStorageManager.updateStore({ name: TRACKER_STORE_NAME, data: this.state });
-//           return;
-//         }
-
-//         this.localStorageManager.createStore({
-//           name: TRACKER_STORE_NAME,
-//           data: this.state,
-//           options: DEFAULT_TRACKER_OPTIONS,
-//         });
-//       });
-//   }
-
-//   private stringifyQuery(query: NormalizedQueryParams): string {
-//     return JSON.stringify(
-//       Object.keys(query)
-//         .sort()
-//         .reduce((acc, key) => {
-//           acc[key] = query[key];
-//           return acc;
-//         }, {} as NormalizedQueryParams)
-//     );
-//   }
-
-//   private isTrackerState(value: any): value is QueryTrackerStateInterface {
-//     return this.isPlainObject(value) && this.isPlainObject(value.paths);
-//   }
-
-//   private isPlainObject(value: any): boolean {
-//     return Object.prototype.toString.call(value) === '[object Object]';
-//   }
-
-//   private hasSessionStorage(): boolean {
-//     try {
-//       return typeof sessionStorage !== 'undefined';
-//     } catch {
-//       return false;
-//     }
-//   }
-
-// }

package/src/lib/services/utils/random-color.utils.ts

@@ -1,83 +0,0 @@
-/**
- * Generate a random hex color code
- * @returns A random hex color string (e.g., "#FF5733")
- */
-export const RandomHexColor = (): string => {
-  // Generate a random number between 0 and 16777215 (0xFFFFFF)
-  const randomColor = Math.floor(Math.random() * 16777215);
-  // Convert to hexadecimal and pad with zeros to ensure 6 digits
-  const hexColor = randomColor.toString(16).padStart(6, '0');
-  // Return with # prefix
-  return `#${hexColor}`;
-};
-
-/**
- * Generate a random hex color with constraints to ensure good visibility
- * @param options Optional constraints for color generation
- * @returns A random hex color string with good contrast
- */
-export const RandomVisibleColor = (options?: {
-  minBrightness?: number; // Minimum brightness (0-255), default: 50
-  maxBrightness?: number; // Maximum brightness (0-255), default: 200
-}): string => {
-  const minBrightness = options?.minBrightness ?? 50;
-  const maxBrightness = options?.maxBrightness ?? 200;
-
-  // Generate RGB values within the specified brightness range
-  const r = Math.floor(Math.random() * (maxBrightness - minBrightness) + minBrightness);
-  const g = Math.floor(Math.random() * (maxBrightness - minBrightness) + minBrightness);
-  const b = Math.floor(Math.random() * (maxBrightness - minBrightness) + minBrightness);
-
-  // Convert to hex and pad with zeros
-  const toHex = (n: number) => n.toString(16).padStart(2, '0');
-  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
-};
-
-/**
- * Generate a random color from a predefined palette
- * @returns A hex color from a set of visually distinct colors
- */
-export const RandomPaletteColor = (): string => {
-  const colorPalette = [
-    '#FF6B6B', // Coral
-    '#4ECDC4', // Turquoise
-    '#45B7D1', // Sky Blue
-    '#FFBE0B', // Amber
-    '#FB5607', // Orange
-    '#8338EC', // Violet
-    '#3A86FF', // Azure
-    '#38B000', // Green
-    '#9D4EDD', // Purple
-    '#FF006E', // Pink
-    '#0077B6', // Blue
-    '#2A9D8F'  // Teal
-  ];
-
-  const randomIndex = Math.floor(Math.random() * colorPalette.length);
-  return colorPalette[randomIndex];
-};
-
-/**
- * Generate a random HSL color
- * @param options Optional constraints for HSL generation
- * @returns A random HSL color string (e.g., "hsl(120, 100%, 50%)")
- */
-export const RandomHSLColor = (options?: {
-  saturation?: [number, number]; // Saturation range (0-100), default: [50, 100]
-  lightness?: [number, number];   // Lightness range (0-100), default: [40, 80]
-}): string => {
-  // Full range for hue (0-360)
-  const hue = Math.floor(Math.random() * 361);
-
-  // Default or custom saturation range
-  const satMin = options?.saturation?.[0] ?? 50;
-  const satMax = options?.saturation?.[1] ?? 100;
-  const saturation = Math.floor(Math.random() * (satMax - satMin + 1) + satMin);
-
-  // Default or custom lightness range
-  const lightMin = options?.lightness?.[0] ?? 40;
-  const lightMax = options?.lightness?.[1] ?? 80;
-  const lightness = Math.floor(Math.random() * (lightMax - lightMin + 1) + lightMin);
-
-  return `hsl(${hue}, ${saturation}%, ${lightness}%)`;
-};