http-request-manager 18.15.32 → 18.15.34

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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,442 @@
+// 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

@@ -0,0 +1,83 @@
+/**
+ * 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}%)`;
+};