http-request-manager 18.15.34 → 18.16.1

package/src/lib/services/utils/utils.service.spec.ts

@@ -1,165 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
-import { UtilsService } from './utils.service';
-import { provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
-
-describe('UtilsService', () => {
-  let service: UtilsService;
-  let httpMock: HttpTestingController;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-    imports: [],
-    providers: [UtilsService, provideHttpClient(withInterceptorsFromDi()), provideHttpClientTesting()]
-});
-    service = TestBed.inject(UtilsService);
-    httpMock = TestBed.inject(HttpTestingController);
-  });
-
-  afterEach(() => {
-    httpMock.verify();
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  describe('Type Checks and JSON Conversions', () => {
-    it('should check string and object types', () => {
-      expect(service.isString('test')).toBeTrue();
-      expect(service.isString(123)).toBeFalse();
-      expect(service.isObject({})).toBeTrue();
-      expect(service.isObject('test')).toBeFalse();
-    });
-
-    it('should convert between JSON and string', () => {
-      const obj = { key: 'value' };
-      const jsonString = '{"key":"value"}';
-      expect(service.JSONToString(obj)).toBe(JSON.stringify(obj));
-      expect(service.JSONToString('test')).toBe('test');
-      expect(service.stringToJSON(jsonString)).toEqual(JSON.parse(jsonString));
-      expect(service.stringToJSON('test')).toBe('test');
-    });
-
-    it('should check if a string is valid JSON', () => {
-      expect(service.isJSON('{"key":"value"}')).toBeTrue();
-      expect(service.isJSON('not json')).toBeFalse();
-    });
-  });
-
-  describe('Object Access and Comparison', () => {
-    it('should return property value and compare objects', () => {
-      const obj = { key: 'value' };
-      expect(service.getValueByProp(obj, 'key')).toBe('value');
-      expect(service.getValueByProp(undefined, 'key')).toBeFalse();
-
-      const obj1 = { key: 'value', nested: { a: 1 } };
-      const obj2 = { key: 'value', nested: { a: 1 } };
-      const obj3 = { key: 'value', nested: { a: 2 } };
-      expect(service.objectsEqual(obj1, obj2)).toBeTrue();
-      expect(service.objectsEqual(obj1, obj3)).toBeFalse();
-    });
-  });
-
-  describe('HTTP and Getter', () => {
-    it('should obtain JSON from file', () => {
-      const dummyData = { key: 'value' };
-      service.getJSON('test.json').subscribe(data => {
-        expect(data).toEqual(dummyData);
-      });
-      const req = httpMock.expectOne('assets/data/test.json');
-      expect(req.request.method).toBe('GET');
-      req.flush(dummyData);
-    });
-
-    it('should return current time from today getter', () => {
-      const nowInSec = new Date().getMilliseconds() / 1000;
-      expect(service.today).toBeCloseTo(nowInSec, 0);
-    });
-  });
-
-  describe('Conversion Methods', () => {
-    it('should convert base32 to hex (simple case)', () => {
-      // For "A", expecting "0".
-      expect(service.base32ToHex('A')).toBe('0');
-    });
-
-    it('should convert binary to hex with 32-character padding', () => {
-      /* For the binary representation of "Hello":
-         H -> 01001000
-         e -> 01100101
-         l -> 01101100
-         l -> 01101100
-         o -> 01101111
-         -> Hex: "48656c6c6f"
-         Padded (22 zeros in front): "00000000000000000000000048656c6c6f"
-      */
-      const binary = '0100100001100101011011000110110001101111';
-      const expected = '000000000000000000000048656c6c6f';
-      expect(service.binaryToHex(binary)).toBe(expected);
-    });
-  });
-
-  describe('Expiry Calculations', () => {
-    // Helper to test expiry() returns a value close to now + (multiplier)
-    function expectExpiryClose(input: string, multiplier: number) {
-      const now = Math.floor(new Date().getTime() / 1000);
-      const expiry = service.expires(input);
-      expect(expiry).toBeGreaterThanOrEqual(now + multiplier - 1);
-      expect(expiry).toBeLessThanOrEqual(now + multiplier + 1);
-    }
-
-    it('should calculate expiry for various time units', () => {
-      expectExpiryClose("1y", 31556926);
-      expectExpiryClose("1m", 2629743);
-      expectExpiryClose("1w", 604800);
-      expectExpiryClose("1d", 86400);
-      expectExpiryClose("1hr", 3600);
-      expectExpiryClose("1mn", 60);
-      expectExpiryClose("1s", 1);
-    });
-
-    it('should return undefined for missing expiry string', () => {
-      expect(service.expires()).toBeUndefined();
-    });
-
-    it('should indicate if expired', () => {
-      const now = Math.floor(new Date().getTime() / 1000);
-      expect(service.hasExpired(now - 10)).toBeTrue();
-      expect(service.hasExpired(now + 10)).toBeFalse();
-      expect(service.hasExpired(0)).toBeFalse();
-    });
-
-    it('should check setting for expiry', () => {
-      const settingWithExpiry = { expires: 1234567890 };
-      const settingWithoutExpiry = { key: 'value' };
-      expect(service.hasExpiry(settingWithExpiry)).toBeTrue();
-      expect(service.hasExpiry(settingWithoutExpiry)).toBeFalse();
-    });
-
-    it('should return a formatted string for future expiry dates', () => {
-      const now = Math.floor(new Date().getTime() / 1000);
-      const future = now + 10000;
-      const result = service.expiresIn(future);
-      expect(typeof result).toBe('string');
-      expect(result).toBeDefined();
-      expect(result!.length).toBeGreaterThan(0);
-      // Expect one of the time unit labels in the formatted result.
-      expect(result).toMatch(/(y|m|w|d|h|min|s)/);
-    });
-
-    it('should return "Expired" for past or current expiry dates', () => {
-      const now = Math.floor(new Date().getTime() / 1000);
-      expect(service.expiresIn(now - 1)).toBe("Expired");
-      expect(service.expiresIn(now)).toBe("Expired");
-    });
-  });
-
-  describe('String Conversion', () => {
-    it('should convert string to lowercase with underscores', () => {
-      const input = 'Hello, World!';
-      // Expected conversion: remove punctuation, convert to lowercase, replace spaces with underscores.
-      expect(service.lc(input)).toBe('hello_world');
-    });
-  });
-});

package/src/lib/services/utils/utils.service.ts

@@ -1,192 +0,0 @@
-
-import { HttpClient } from '@angular/common/http';
-import { Injectable, inject } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class UtilsService {
-
-  http = inject(HttpClient)
-
-  constructor() { }
-
-  isString(x: string | number) {
-    return Object.prototype.toString.call(x) === '[object String]'
-  }
-
-  isObject(obj: any) {
-    return Object.prototype.toString.call(obj) === '[object Object]'
-  }
-
-  JSONToString(value: any) {
-    return (this.isObject(value)) ? JSON.stringify(value) : value
-  }
-
-  stringToJSON(value: string) {
-    return (this.isJSON(value)) ? JSON.parse(value) : value
-  }
-
-  isJSON(str: any) {
-    try {
-      JSON.parse(str)
-    } catch (e) {
-      return false
-    }
-    return true
-  }
-
-  getValueByProp(obj: any, prop: string) {
-    if(typeof obj === 'undefined') return false
-    return obj[prop]
-  }
-
-  objectsEqual(x: any, y: any): boolean {
-
-    const ok = Object.keys, tx = typeof x, ty = typeof y
-
-    return x && y && tx === 'object' && tx === ty ? (
-      ok(x).length === ok(y).length &&
-        ok(x).every((key: any) => this.objectsEqual(x[key], y[key]))
-    ) : (x === y)
-
-  }
-
-  getJSON(file: string) {
-    return this.http.get(`assets/data/${file}`)
-  }
-
-  get today() {
-    return new Date().getMilliseconds() / 1000
-  }
-
-  base32ToHex(base32: string): string {
-
-    const base32chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
-
-    const charToValue = (char: string) => base32chars.indexOf(char.toUpperCase())
-
-    let bits = ''
-    let hex = ''
-
-    for (let i = 0; i < base32.length; i++) {
-      const val = charToValue(base32.charAt(i))
-      bits += val.toString(2).padStart(5, '0')
-    }
-
-    for (let i = 0; i + 4 <= bits.length; i += 4) {
-      const chunk = bits.substr(i, 4)
-      hex += parseInt(chunk, 2).toString(16)
-    }
-
-    return hex.toUpperCase()
-  }
-
-  binaryToHex(binary: string): string {
-    let hex = '';
-    for (let i = 0; i < binary.length; i += 8) {
-      const byte = binary.substr(i, 8);
-      const decimal = parseInt(byte, 2);
-      hex += decimal.toString(16).padStart(2, '0');
-    }
-    return hex.padStart(32, '0').substr(0, 32);
-  }
-
-  // y = years, m = months, w = weeks, d = days, hr = hours, mn = minutes else seconds
-  // returns epoch time corresponding to the expiry type
-  expires(str?: string) {
-
-    if(!str) return undefined
-
-    const match = str.match(/[^0-9]+$/)
-
-    const type = (match) ? str.slice(-match[0].length) : 0
-
-    const now = Math.floor(new Date().getTime() / 1000)
-
-    let value = 0;
-
-    switch (type) {
-      case
-      'y':
-        const years = parseInt(str.slice(0, -1))
-        value = now + (years * 31556926)
-        break;
-      case
-      'm':
-        const months = parseInt(str.slice(0, -1))
-        value = now + (months * 2629743)
-        break;
-      case
-      'w':
-        const weeks = parseInt(str.slice(0, -1))
-        value = now + (weeks * 604800)
-        break;
-      case
-      'd':
-        const days = parseInt(str.slice(0, -1))
-        value = now + (days * 86400)
-        break;
-      case
-      'hr':
-        const hrs = parseInt(str.slice(0, -2))
-        value = now + (hrs * 3600)
-        break;
-      case
-      'mn':
-        const min = parseInt(str.slice(0, -2))
-        value = now + (min * 60)
-        break;
-      default: //seconds
-        const sec = parseInt(str.slice(0, -1))
-        value = now + sec
-        break;
-    }
-    return value;
-  }
-
-  hasExpired(expiryDate: number): boolean {
-    if (!expiryDate || expiryDate === 0) return false
-    const currentTime = Math.floor(new Date().getTime() / 1000)
-    return expiryDate < currentTime
-  }
-
-  hasExpiry(setting: any) {
-    return (setting?.expires) ? true : false
-  }
-
-  expiresIn(expiryDate: number) {
-
-    if (!expiryDate) return;
-
-    const now = Math.floor(new Date().getTime() / 1000);
-    let diff = expiryDate - now;
-
-    if (diff <= 0) return "Expired";
-
-    const units = [
-        { label: 'y', s: 31536000 },
-        { label: 'm', s: 2592000 },
-        { label: 'w', s: 604800 },
-        { label: 'd', s: 86400 },
-        { label: 'h', s: 3600 },
-        { label: 'min', s: 60 },
-        { label: 's', s: 1 },
-    ];
-
-    let result = [];
-
-    for (const unit of units) {
-        if (diff >= unit.s) {
-            const value = Math.floor(diff / unit.s);
-            diff %= unit.s;
-            result.push(`${value}${unit.label}`);
-        }
-    }
-
-    return result.join(', ');
-  }
-
-  lc = (str: string) => str.toLowerCase().replace(/[^\w\s]/g, '').replace(/\s+/g, '_')
-
-}

package/src/lib/services/ws-manager-service/index.ts

@@ -1,13 +0,0 @@
-
-export * from "./models/index";
-export * from "./services/websocket.service";
-export * from "./websocket-service/index";
-
-export { WebSocketMessageService } from "./services/websocket-message.service";
-export { WebSocketSignalsManagerService } from "./websocket-signals-manager.service";
-export { MessageTrackerSignalsService } from "./message-tracker-signals.service";
-export { StateMessage, StateMessageInterface } from "./models/state-message.model";
-export { PublicMessage, PublicMessageInterface } from "./models/public-message.model";
-export { NotificationMessage, NotificationMessageInterface } from "./models/notification-message.model";
-// ChannelType is already exported from request-manager-state-service to avoid conflicts
-

package/src/lib/services/ws-manager-service/message-tracker-signals.service.ts

@@ -1,147 +0,0 @@
-import { Injectable, inject, signal, computed, effect } from '@angular/core';
-import { toObservable } from '@angular/core/rxjs-interop';
-import { WebSocketSignalsManagerService } from './websocket-signals-manager.service';
-
-/**
- * MessageTrackerSignalsService - Signal-based message tracking
- *
- * Tracks WebSocket messages, channel metadata, and user presence using signals.
- * Provides real-time reactivity for message-driven applications.
- */
-@Injectable({
-  providedIn: 'root',
-})
-export class MessageTrackerSignalsService {
-
-  private wsManager = inject(WebSocketSignalsManagerService);
-
-  // Signal-based state
-  private messagesSignal = signal<any>(null);
-  public readonly messages = this.messagesSignal.asReadonly();
-  public readonly messages$ = toObservable(this.messagesSignal);
-
-  private channelMetadataSignal = signal<Map<string, any>>(new Map());
-  public readonly channelMetadata = this.channelMetadataSignal.asReadonly();
-  public readonly channelMetadata$ = toObservable(this.channelMetadataSignal);
-
-  private usersInChannelsSignal = signal<Map<string, Set<string>>>(new Map());
-  public readonly usersInChannels = this.usersInChannelsSignal.asReadonly();
-  public readonly usersInChannels$ = toObservable(this.usersInChannelsSignal);
-
-  // Computed signals for derived state
-  readonly messageCount = computed(() => {
-    const metadata = this.channelMetadataSignal();
-    let count = 0;
-    metadata.forEach(data => count += data.count);
-    return count;
-  });
-
-  readonly activeChannels = computed(() => {
-    return Array.from(this.channelMetadataSignal().keys());
-  });
-
-  constructor() {
-    // Track messages from WebSocket
-    effect(() => {
-      const message = this.wsManager.messages();
-      if (message) {
-        this.trackMessage(message);
-      }
-    });
-
-    // Track connection status
-    effect(() => {
-      const connected = this.wsManager.connectionStatus();
-      if (!connected) {
-        this.onDisconnect();
-      }
-    });
-  }
-
-  trackMessage(message: any): void {
-    // Store message
-    this.messagesSignal.set(message);
-
-    // Update channel metadata
-    if (message.channel) {
-      this.updateChannelMetadata(message.channel, message);
-    }
-
-    // Update user presence if applicable
-    if (message.user && message.channel) {
-      this.updateUserPresence(message.channel, message.user);
-    }
-  }
-
-  private updateChannelMetadata(channel: string, message: any): void {
-    this.channelMetadataSignal.update(metadata => {
-      const updated = new Map(metadata);
-      const current = updated.get(channel) || { count: 0, lastMessage: null, lastUpdated: 0 };
-      updated.set(channel, {
-        ...current,
-        count: current.count + 1,
-        lastMessage: message,
-        lastUpdated: Date.now()
-      });
-      return updated;
-    });
-  }
-
-  private updateUserPresence(channel: string, user: string): void {
-    this.usersInChannelsSignal.update(users => {
-      const updated = new Map(users);
-      const channelUsers = new Set(updated.get(channel) || []);
-      channelUsers.add(user);
-      updated.set(channel, channelUsers);
-      return updated;
-    });
-  }
-
-  removeUserFromChannel(channel: string, user: string): void {
-    this.usersInChannelsSignal.update(users => {
-      const updated = new Map(users);
-      const channelUsers = updated.get(channel);
-      if (channelUsers) {
-        channelUsers.delete(user);
-        updated.set(channel, channelUsers);
-      }
-      return updated;
-    });
-  }
-
-  subscribeToChannel(channel: string): void {
-    this.wsManager.subscribeToChannel(channel);
-  }
-
-  unsubscribeFromChannel(channel: string): void {
-    this.wsManager.unsubscribeFromChannel(channel);
-    this.removeUserFromChannel(channel, 'current-user');
-  }
-
-  // Selectors
-  getMessageCount(channel: string): number {
-    const metadata = this.channelMetadataSignal();
-    return metadata.get(channel)?.count || 0;
-  }
-
-  getLastMessage(channel: string): any {
-    const metadata = this.channelMetadataSignal();
-    return metadata.get(channel)?.lastMessage || null;
-  }
-
-  getActiveChannels(): string[] {
-    return Array.from(this.channelMetadataSignal().keys());
-  }
-
-  getUsersInChannel(channel: string): string[] {
-    const users = this.usersInChannelsSignal().get(channel);
-    return users ? Array.from(users) : [];
-  }
-
-  private onDisconnect(): void {
-    // Clear state on disconnect
-    this.messagesSignal.set(null);
-    this.channelMetadataSignal.set(new Map());
-    this.usersInChannelsSignal.set(new Map());
-  }
-}