http-request-manager 18.15.34 → 18.16.1

package/src/lib/message-display/models/display-rule.interface.ts

@@ -1,28 +0,0 @@
-import { DisplayConfig } from './display-config.model';
-import { CommunicationMessage } from './communication-message.model';
-
-export interface DisplayRuleInterface {
-  id: string;
-  name?: string;
-  match: (message: CommunicationMessage) => boolean;
-  display: DisplayConfig;
-}
-
-export class DisplayRule implements DisplayRuleInterface {
-  constructor(
-    public id: string = '',
-    public name?: string,
-    public match: (message: CommunicationMessage) => boolean = () => false,
-    public display: DisplayConfig = DisplayConfig.adapt(),
-  ) {}
-
-  static adapt(item?: any): DisplayRule {
-    return new DisplayRule(
-      item?.id,
-      item?.name,
-      item?.match,
-      item?.display ? DisplayConfig.adapt(item.display) : DisplayConfig.adapt(),
-    );
-  }
-}
-

package/src/lib/message-display/models/display-strategy.interface.ts

@@ -1,8 +0,0 @@
-import { CommunicationMessage } from '../models/communication-message.model';
-import { DisplayConfig } from '../models/display-config.model';
-
-export interface IDisplayStrategy {
-  name: string;
-  canHandle(message: CommunicationMessage): boolean;
-  display(message: CommunicationMessage, config: DisplayConfig): void;
-}

package/src/lib/message-display/models/index.ts

@@ -1,6 +0,0 @@
-export * from './display-config.model';
-export * from './display-rule.interface';
-export * from './display-strategy.interface';
-export * from './communication-message.model';
-export * from './slide.model';
-export * from './action.model';

package/src/lib/message-display/models/slide.model.ts

@@ -1,24 +0,0 @@
-export interface SlideInterface {
-  title: string;
-  message: string;
-  image?: string;
-  icon?: string;
-}
-
-export class Slide implements SlideInterface {
-  constructor(
-    public title: string = '',
-    public message: string = '',
-    public image?: string,
-    public icon?: string
-  ) {}
-
-  static adapt(item?: any): Slide {
-    return new Slide(
-      item?.title,
-      item?.message,
-      item?.image,
-      item?.icon
-    );
-  }
-}

package/src/lib/message-display/rules/default-display-rules.ts

@@ -1,35 +0,0 @@
-import { DisplayRule } from '../models/display-rule.interface';
-
-export const defaultDisplayRules: DisplayRule[] = [
-  {
-    id: 'carousel',
-    name: 'Carousel',
-    match: (message) => message.content?.displayConfig?.type === 'carousel',
-    display: {
-      type: 'carousel',
-      supportsMarkdown: true,
-      stackable: false
-    }
-  },
-  {
-    id: 'dialog',
-    name: 'Dialog',
-    match: (message) => message.content?.displayConfig?.type === 'dialog',
-    display: {
-      type: 'dialog',
-      supportsMarkdown: true,
-      stackable: true
-    }
-  },
-  {
-    id: 'default',
-    name: 'Snackbar',
-    match: () => true,
-    display: {
-      type: 'snackbar',
-      supportsMarkdown: false,
-      stackable: true,
-      autoDismiss: 3000
-    }
-  }
-];

package/src/lib/message-display/services/message-display-router.service.ts

@@ -1,63 +0,0 @@
-import { Injectable, inject } from '@angular/core';
-import { IDisplayStrategy } from '../models/display-strategy.interface';
-import { DisplayRule } from '../models/display-rule.interface';
-import { CommunicationMessage } from '../models/communication-message.model';
-import { defaultDisplayRules } from '../rules/default-display-rules';
-import { SnackbarStrategy } from '../strategies/snackbar.strategy';
-
-@Injectable({ providedIn: 'root' })
-export class MessageDisplayRouterService {
-
-  private snackbarStrategy = inject(SnackbarStrategy);
-
-  // All available strategies
-  private strategies: IDisplayStrategy[] = [
-    this.snackbarStrategy
-    // DialogStrategy will be added in Phase 2
-    // CarouselStrategy will be added in Phase 3
-  ];
-
-  // Rules are evaluated in order - first match wins
-  private rules: DisplayRule[] = defaultDisplayRules;
-
-  display(message: CommunicationMessage): void {
-    console.log('📨 MessageDisplayRouterService: Processing message:', message);
-
-    // Find FIRST matching rule (order matters!)
-    const matchingRule = this.rules.find(rule => rule.match(message));
-
-    // Get the rule (will be 'default' if nothing else matches)
-    const rule = matchingRule || this.rules[this.rules.length - 1];
-
-    console.log(`🎯 MessageDisplayRouterService: Matched rule '${rule.id}' (${rule.name})`);
-    console.log(`   → Display type: ${rule.display.type}`);
-
-    // Get strategy for the display type
-    const strategy = this.strategies.find(s => s.name === rule.display.type);
-
-    if (!strategy) {
-      console.warn(`⚠️ MessageDisplayRouterService: No strategy found for type '${rule.display.type}', falling back to snackbar`);
-      // Fallback to snackbar if strategy not found
-      this.snackbarStrategy.display(message, rule.display);
-      return;
-    }
-
-    // Execute display
-    console.log(`🚀 MessageDisplayRouterService: Executing ${strategy.name} strategy`);
-    strategy.display(message, rule.display);
-  }
-
-  registerStrategies(strategies: IDisplayStrategy[]): void {
-    strategies.forEach(strategy => {
-      if (!this.strategies.find(s => s.name === strategy.name)) {
-        this.strategies.push(strategy);
-        console.log(`✅ Registered strategy: ${strategy.name}`);
-      }
-    });
-  }
-
-  setRules(rules: DisplayRule[]): void {
-    this.rules = rules;
-    console.log(`📋 MessageDisplayRouterService: Rules updated (${rules.length} rules)`);
-  }
-}

package/src/lib/message-display/strategies/snackbar.strategy.ts

@@ -1,46 +0,0 @@
-import { Injectable, inject } from '@angular/core';
-import { ToastMessageDisplayService, ToastColors } from 'toast-message-display';
-import { IDisplayStrategy } from '../models/display-strategy.interface';
-import { CommunicationMessage } from '../models/communication-message.model';
-import { DisplayConfig } from '../models/display-config.model';
-
-@Injectable()
-export class SnackbarStrategy implements IDisplayStrategy {
-  name = 'snackbar';
-
-  private toastService = inject(ToastMessageDisplayService);
-
-  canHandle(message: CommunicationMessage): boolean {
-    return true;  // Always can handle (fallback strategy)
-  }
-
-  display(message: CommunicationMessage, config: DisplayConfig): void {
-    const messageText = this.extractMessage(message.content);
-
-    this.toastService.toastMessage(
-      {
-        message: messageText,
-        color: ToastColors.INFO,
-        icon: 'info',
-        action: 'DONE'
-      },
-      config.autoDismiss ?? 3000
-    );
-  }
-
-  private extractMessage(content: any): string {
-    if (!content) return '';
-
-    // Try nested content structure (backward compatibility)
-    if (content.content?.message) {
-      return content.content.message;
-    }
-
-    // Try direct message
-    if (content.message) {
-      return content.message;
-    }
-
-    return '';
-  }
-}

package/src/lib/models/batch-options.model.ts

@@ -1,33 +0,0 @@
-export interface BatchOptionsInterface {
-  mode?: 'sequential' | 'parallel';
-  stopOnError?: boolean;
-  concurrency?: number;
-  ignoreErrors?: boolean;
-  logErrors?: boolean;
-  displaySuccess?: boolean;
-  displayError?: boolean;
-}
-
-export class BatchOptions implements BatchOptionsInterface {
-  constructor(
-    public mode: 'sequential' | 'parallel' = 'sequential',
-    public stopOnError: boolean = false,
-    public concurrency: number = 3,
-    public ignoreErrors: boolean = false,
-    public logErrors: boolean = true,
-    public displaySuccess?: boolean,
-    public displayError?: boolean,
-  ) {}
-
-  static adapt(item?: any): BatchOptions {
-    return new BatchOptions(
-      item?.mode ?? 'sequential',
-      item?.stopOnError ?? false,
-      item?.concurrency ?? 3,
-      item?.ignoreErrors ?? false,
-      item?.logErrors !== false,
-      item?.displaySuccess ?? false,
-      item?.displayError ?? false,
-    );
-  }
-}

package/src/lib/models/batch-progress.model.ts

@@ -1,19 +0,0 @@
-import { BatchRequestState } from './batch-request-state.model';
-
-export interface BatchProgress {
-  total: number;
-  pending: number;
-  completed: number;
-  failed: number;
-  percent: number;
-}
-
-export function calculateBatchProgress<T>(states: BatchRequestState<T>[]): BatchProgress {
-  const total = states.length;
-  const pending = states.filter(s => s.isPending).length;
-  const completed = states.filter(s => !s.isPending && s.data !== undefined).length;
-  const failed = states.filter(s => !s.isPending && s.error !== undefined).length;
-  const percent = total > 0 ? Math.round(((completed + failed) / total) * 100) : 0;
-
-  return { total, pending, completed, failed, percent };
-}

package/src/lib/models/batch-request-state.model.ts

@@ -1,40 +0,0 @@
-export type BatchRequestState<T> = 
-  | BatchPendingState
-  | BatchSuccessState<T>
-  | BatchErrorState;
-
-export interface BatchPendingState {
-  index: number;
-  request: any;
-  isPending: true;
-  data?: undefined;
-  error?: undefined;
-}
-
-export interface BatchSuccessState<T> {
-  index: number;
-  request: any;
-  isPending: false;
-  data: T;
-  error?: undefined;
-}
-
-export interface BatchErrorState {
-  index: number;
-  request: any;
-  isPending: false;
-  data?: undefined;
-  error: any;
-}
-
-export function isPendingState<T>(state: BatchRequestState<T>): state is BatchPendingState {
-  return state.isPending === true;
-}
-
-export function isSuccessState<T>(state: BatchRequestState<T>): state is BatchSuccessState<T> {
-  return state.isPending === false && state.data !== undefined;
-}
-
-export function isErrorState<T>(state: BatchRequestState<T>): state is BatchErrorState {
-  return state.isPending === false && state.error !== undefined;
-}

package/src/lib/models/batch-result.model.ts

@@ -1,30 +0,0 @@
-export interface BatchResultInterface<T = any> {
-  request: any;
-  success: boolean;
-  data?: T;
-  error?: any;
-  index: number;
-  timestamp: number;
-}
-
-export class BatchResult<T = any> implements BatchResultInterface<T> {
-  constructor(
-    public request: any,
-    public success: boolean,
-    public data?: T,
-    public error?: any,
-    public index: number = 0,
-    public timestamp: number = Date.now(),
-  ) {}
-
-  static adapt<T>(item?: any): BatchResult<T> {
-    return new BatchResult<T>(
-      item?.request,
-      item?.success ?? false,
-      item?.data,
-      item?.error,
-      item?.index ?? 0,
-      item?.timestamp ?? Date.now(),
-    );
-  }
-}

package/src/lib/models/config-http-options.model.ts

@@ -1,45 +0,0 @@
-import { RetryOptions } from "./retry-options.model"
-
-export interface ConfigHTTPOptionsInterface {
-  server: string
-  path?: any[]
-  headers?: any
-  polling?: number // seconds (undefined | 0 = none)
-  retry?: RetryOptions
-  stream?: boolean
-  displayError?: boolean
-  displaySuccess?: boolean
-}
-
-export class ConfigHTTPOptions implements ConfigHTTPOptionsInterface {
-
-  constructor(
-    public server = '',
-    public path?: any[],
-    public headers?: any,
-    public polling?: number,
-    public retry?: RetryOptions,
-    public stream?: boolean,
-    public displayError?: boolean,
-    public displaySuccess?: boolean,
-  ) {}
-
-  static adapt(item?: any): ConfigHTTPOptions {
-
-    const server = Array.isArray(item?.server) ? item.server.join('/') : item?.server || '';
-    const retryOptions = item?.retry ? RetryOptions.adapt(item.retry) : RetryOptions.adapt();
-
-    return new ConfigHTTPOptions(
-      server,
-      (item?.path) ? item.path : [],
-      (item?.headers) ? item.headers : {},
-      item?.polling ? Math.floor(item.polling) : 0,
-      retryOptions,
-      (item?.stream) ? item.stream : false,
-      (item?.displayError) ? item.displayError : false,
-      (item?.displaySuccess) ? item.displaySuccess : false,
-    )
-
-  }
-
-}

package/src/lib/models/config-local-storage-options.model.ts

@@ -1,27 +0,0 @@
-import { SettingOptions } from "../services"
-
-export interface LocalStorageOptionsInterface {
-  storageName?: string
-  storageSettingsName?: string
-  options?: SettingOptions,
-}
-
-export class LocalStorageOptions implements LocalStorageOptionsInterface {
-
-  constructor(
-    public storageName?: string,
-    public storageSettingsName?: string,
-    public options?: SettingOptions,
-  ) {}
-
-  static adapt(item?: any): LocalStorageOptions {
-
-    return new LocalStorageOptions(
-      (item?.storageName) ? item.storageName : 'storage',
-      (item?.storageSettingsName) ? item.storageSettingsName : 'global-storage',
-      (item?.options) ? SettingOptions.adapt(item.options) : SettingOptions.adapt(),
-    )
-
-  }
-
-}

package/src/lib/models/config-options.model.ts

@@ -1,27 +0,0 @@
-import { ConfigHTTPOptions } from "./config-http-options.model";
-import { LocalStorageOptions } from "./config-local-storage-options.model";
-
-export interface ConfigOptionsInterface {
-  httpRequestOptions?: ConfigHTTPOptions
-  LocalStorageOptions?: LocalStorageOptions
-  // DatabaseOptions: any
-}
-
-export class ConfigOptions implements ConfigOptionsInterface {
-
-  constructor(
-    public httpRequestOptions?: ConfigHTTPOptions,
-    public LocalStorageOptions?: LocalStorageOptions,
-    // public DatabaseOptions?: any,
-  ) {}
-
-  static adapt(item?: any): ConfigOptions {
-    return new ConfigOptions(
-      (item?.httpRequestOptions) ? ConfigHTTPOptions.adapt(item.httpRequestOptions) : undefined,
-      (item?.LocalStorageOptions) ? LocalStorageOptions.adapt(item.LocalStorageOptions) : undefined,
-      // item?.DatabaseOptions,
-    )
-
-  }
-
-}

package/src/lib/models/config-token.model.ts

@@ -1,9 +0,0 @@
-import { InjectionToken } from "@angular/core";
-import { ConfigOptions } from "./config-options.model";
-
-/**
- * An injection token that provides the configuration settings for the application.
- * This token can be used to inject the `ConfigSettings` instance into components or services
- * that require access to the application configuration.
- */
-export const CONFIG_SETTINGS_TOKEN = new InjectionToken<ConfigOptions>('http.config');

package/src/lib/models/data-type.enum.ts

@@ -1,5 +0,0 @@
-export enum DataType {
-  ANY = 0,
-  ARRAY,
-  OBJECT
-}

package/src/lib/models/database-storage.model.ts

@@ -1,24 +0,0 @@
-export interface DatabaseStorageInterface {
-  table: string
-  expiresIn: string
-}
-
-export class DatabaseStorage implements DatabaseStorageInterface {
-
-  constructor(
-    public table = '',
-    public expiresIn: '',
-  ) {}
-
-  static adapt(item?: any): any {
-
-    if(!item?.table) return
-
-    return new DatabaseStorage(
-      item?.table,
-      item?.expiresIn,
-    )
-
-  }
-
-}

package/src/lib/models/index.ts

@@ -1,16 +0,0 @@
-export * from './database-storage.model'
-export * from './retry-options.model'
-export * from './batch-options.model'
-export * from './batch-result.model'
-export * from './batch-request-state.model'
-export * from './batch-progress.model'
-
-export * from './data-type.enum'
-
-export * from './config-token.model'
-export * from './config-http-options.model'
-export * from './config-local-storage-options.model'
-export * from './config-options.model'
-
-export * from './upload-validation-error.model'
-

package/src/lib/models/retry-options.model.ts

@@ -1,22 +0,0 @@
-export interface RetryOptionsInterface {
-  times?: number // total request to be made including initial request
-  delay?: number // seconds (<= 3 default 3 seconds)
-}
-
-export class RetryOptions implements RetryOptionsInterface {
-
-  constructor(
-    public times = 0,
-    public delay = 3,
-  ) {}
-
-  static adapt(item?: any): RetryOptions {
-
-    return new RetryOptions(
-      item?.times,
-      item?.delay
-    )
-
-  }
-
-}

package/src/lib/models/upload-validation-error.model.ts

@@ -1,46 +0,0 @@
-export interface InvalidFileInfoInterface {
-  fileName: string;
-  fileSize: number;
-  fileType: string;
-  errors: string[];
-}
-
-export class InvalidFileInfoModel implements InvalidFileInfoInterface {
-  constructor(
-    public fileName: string = '',
-    public fileSize: number = 0,
-    public fileType: string = '',
-    public errors: string[] = []
-  ) {}
-
-  static adapt(item?: any): InvalidFileInfoModel {
-    return new InvalidFileInfoModel(
-      item?.fileName,
-      item?.fileSize,
-      item?.fileType,
-      Array.isArray(item?.errors) ? item.errors : []
-    );
-  }
-}
-
-export interface UploadValidationErrorInterface {
-  invalidFiles: InvalidFileInfoModel[];
-  validFilesCount: number;
-  totalFilesCount: number;
-}
-
-export class UploadValidationErrorModel implements UploadValidationErrorInterface {
-  constructor(
-    public invalidFiles: InvalidFileInfoModel[] = [],
-    public validFilesCount: number = 0,
-    public totalFilesCount: number = 0
-  ) {}
-
-  static adapt(item?: any): UploadValidationErrorModel {
-    return new UploadValidationErrorModel(
-      Array.isArray(item?.invalidFiles) ? item.invalidFiles.map((f: any) => InvalidFileInfoModel.adapt(f)) : [],
-      item?.validFilesCount,
-      item?.totalFilesCount
-    );
-  }
-}