@futdevpro/fsm-dynamo 1.20.8 → 1.20.10

package/src/_modules/ngx-models/_models/control-models/data-handler.control-model.ts

@@ -1,529 +0,0 @@
-import { DyFM_Log, DyFM_Metadata, DyFM_SearchQuery, DyFM_SearchResult, second } from '../../../..';
-import { BehaviorSubject } from 'rxjs';
-
-import { DyFM_WritableSignalPlaceholder } from '../../_collections/angular-placeholders';
-import { DyFM_SignalDataHandler_Settings } from './data-handler-settings.control-model';
-
-/* export type DNM_DataHandler<
-  T extends DyFM_Metadata | DyFM_Metadata[],
-  Dependency_T extends DyFM_Metadata = any
-> = DyFM_SignalDataHandler<T, Dependency_T>; */
-
-/* export type DNM_DataHandler_Settings<
-  T extends DyFM_Metadata | DyFM_Metadata[],
-  Dependency_T extends DyFM_Metadata = any
-> = DyFM_SignalDataHandler_Settings<T, Dependency_T>; */
-
-/**
- * DyFM_SignalDataHandlerDataLoadInProgress
- * @deprecated
- * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
- * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
- */
-export interface DyFM_SignalDataHandlerDataLoadInProgress<T_LoadBy> {
-  loadBy: T_LoadBy;
-  progress: Promise<any>;
-}
-
-/**
- * DyFM_DataHandlerDataPostProcess
- * @deprecated
- * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
- * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
- */
-export type DyFM_SignalDataHandlerDataLoadPostProcess<T_LoadBy> = (data: any, loadedBy: T_LoadBy) => Promise<any> | any;
-
-/**
- * DynamoDataHandler is used to create application wide data handling
- * used to create subscribeAble data handler
- *
- * this implements data reload function that uses predefined apiService,
- * using previous or given id,
- * prevents multiple load calls and triggers data change subscriptions when done
- *
- * load post processes can be implemented to ensure special conditions
- *
- * @example
- * personalInformationDH = new DynamoDataHandler<PersonalInformation>({
- *   apiService: this.accountApiService,
- *   getDataFunctionName: 'getPersonalInformation',
- * });
- * @deprecated
- * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
- * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
- */
-export abstract class DyFM_SignalDataHandler<
-  T extends DyFM_Metadata | DyFM_Metadata[],
-  T_Dependency extends DyFM_Metadata = any,
-  T_LoadBy = string
-> {
-  name: string;
-
-  abstract readonly data_$: DyFM_WritableSignalPlaceholder<T>;
-  /**
-   * this is only declared if createObservable is set to true in settings
-   * (handled by DyNX_DataHandler)
-   */
-  protected abstract readonly data_BS: BehaviorSubject<T>;
-  get data(): T {
-    return this.data_$();
-  }
-
-  /**
-   * last loaded by will work properly only if you use the Dynamo form of "_id" for loading
-   */
-  lastLoadedBy: T_LoadBy; // for lists
-
-  /** this will handle the data loading from the api */
-  protected readonly get: (loadBy?: T_LoadBy) => Promise<any>;
-  /** this will handle the data setting to the data handler */
-  protected readonly set: (data: T) => Promise<T>;
-  /** this will handle the data patching to the data handler */
-  /* patch: (data: T) => Promise<T>; */
-
-  // TODO
-  /* directApiSetup: any; */
-
-  /**
-   * post processes will be called as pipes after data is loaded by get function,
-   * but before data is set to data handler by data_$.set (after get, before Signal triggers)
-   */
-  protected readonly getPostProcesses: DyFM_SignalDataHandlerDataLoadPostProcess<T_LoadBy>[] = [];
-
-  noId?: boolean;
-
-  abstract readonly loaded_$: DyFM_WritableSignalPlaceholder<boolean>;
-  abstract readonly loadInProgress_$: DyFM_WritableSignalPlaceholder<DyFM_SignalDataHandlerDataLoadInProgress<T_LoadBy> | false>;
-  waitsOnLoad: {
-    promise: Promise<void>;
-    resolve: () => void;
-  }[] = [];
-
-  protected readonly dependentDataHandlers?: DyFM_SignalDataHandler<any>[] = [];
-
-  loopSafetyCollection: {
-    at: Date;
-    stack: string;
-  }[] = [];
-  loopSafetyTimeout: number = second;
-  /** if set to 0, loop safety will be disabled */
-  loopSafety: number = 10;
-  debugLog?: boolean;
-
-  /**
-   * DynamoDataHandler
-   * @param apiService any service can be used as apiService
-   * as long as the function, you pass in getDataFunctionName exists,
-   * uses (or not uses an ID as input) and returns the data as Promise<Type>
-   * @param getDataFunctionName the function name on the apiService,
-   * that will be used as get api call
-   *
-   * @param successfulReloadCallBack you can create direct callback for successful reloads
-   * by passing it here
-   *
-   * @param getPostPreprocessLoad post processes can be implemented to ensure special conditions on data
-   *
-   * @param defaultValue you can set default value that will be used before any load
-   * @param noId this flag needs to be true, when using api function without id
-   *
-   * @example
-   * personalInformationDH = new DynamoDataHandler<PersonalInformation>({
-   *   apiService: this.accountApiService,
-   *   getDataFunctionName: 'getPersonalInformation',
-   * });
-   */
-  constructor(
-    set: DyFM_SignalDataHandler_Settings<T, T_Dependency, T_LoadBy>,
-    /** is in construct? 
-     * so the dependent data handlers are not added here, but in the extended class */
-    skipDependencyConnections?: boolean
-  ) {
-    try {
-      // TODO: + TRYTOGETTYPE(this.data);
-      if (!set.name) {
-        set.name = 'Unnamed DataHandler ' + (+new Date());
-
-        DyFM_Log.warn(
-          `DYNAMO DH.constructor (${this.name}) WARN: ` +
-          `\n  Name is not set!`,
-          '\n\n', new Error()
-        );
-      }
-
-      this.name = set.name; 
-      this.debugLog = set?.debugLog;
-
-      if (set.loopSafety === undefined) {
-        set.loopSafety = 10;
-      } else {
-        this.loopSafety = set.loopSafety;
-      }
-
-      if (set.get) {
-        this.get = set.get;
-      }
-
-      if (set.set) {
-        this.set = set.set;
-      }
-
-      this.noId = !!set.noId;
-
-      if (!skipDependencyConnections) {
-        if (set.dependencyDataHandler) {
-          this.addDependencyDataHandler(set.dependencyDataHandler, true);
-        }
-    
-        if (set.dependentDataHandlers) {
-          this.addDependentDataHandlers(set.dependentDataHandlers, true);
-        }
-      }
-
-      if (set.getPostProcess) {
-        this.getPostProcesses.push(set.getPostProcess);
-      }
-    } catch (error) {
-      DyFM_Log.error(`Error creating DyFM_SignalDataHandler (${set.name}):`, error);
-    }
-  }
-
-  addDependencyDataHandler(dependencyDataHandler: DyFM_SignalDataHandler<any>, isInConstruct?: boolean): void {
-    try {
-      if (!dependencyDataHandler) {
-        throw new Error(
-          `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
-          `\n  Dependent DataHandler is null or undefined! (${this.name})`
-        );
-      }
-  
-      if (!(dependencyDataHandler instanceof DyFM_SignalDataHandler)) {
-        throw new Error(
-          `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
-          `\n  Dependent DataHandler is not instance of DyFM_SignalDataHandler! (${this.name})`
-        );
-      }
-  
-      dependencyDataHandler.addDependentDataHandlers([ this ], isInConstruct);
-    } catch (error) {
-      console.error(
-        `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
-        `\n  Failed to add dependency data handler! ("${this.name}": "${this.constructor.name}")`,
-        '\n\n', error,
-        '\n\n', new Error()
-      );
-    }
-  }
-
-  addDependentDataHandlers(
-    dependentDataHandlers: DyFM_SignalDataHandler<any, any, any>[],
-    isInConstruct?: boolean
-  ): void {
-    try {
-      dependentDataHandlers.forEach((dependent_DH: DyFM_SignalDataHandler<any>): void => {
-        if (!dependent_DH) {
-          throw new Error(
-            `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
-            `\n  Dependent DataHandler is null or undefined! (${this.name})`
-          );
-        }
-
-        if (!(dependent_DH instanceof DyFM_SignalDataHandler)) {
-          throw new Error(
-            `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
-            `\n  Dependent DataHandler is not instance of DyFM_SignalDataHandler! (${this.name})`
-          );
-        }
-
-        if (dependent_DH.name === this.name) {
-          throw new Error(
-            `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
-            `\n  Dependent DataHandler has the same name as the current DataHandler! (${this.name})`
-          );
-        }
-
-        if (!dependent_DH.data_$) {
-          throw new Error(
-            `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
-            `\n  Dependent DataHandler has not been set up yet! ` +
-            `(this: "${this.name}", dependent: "${dependent_DH.name}")` +
-            `\n    Try the opposite direction of dependency!\n\n`
-          );
-        }
-
-        if (!dependentDataHandlers.includes(dependent_DH)) {
-          dependentDataHandlers.push(dependent_DH);
-        }
-
-        if (this.debugLog) {
-          this.getPostProcesses.push(async (newData: T): Promise<T> => {
-            console.log(
-              `DYNAMO DH.addDependentDataHandlers (${this.name}) DEBUG:` +
-              `\nDataHandler triggering dependent dataHandler (${dependent_DH.name}) to reload... ` +
-              `\n(using id: ${newData && newData['_id'] ? newData['_id'] : ''})`
-            );
-
-            return newData;
-          });
-        }
-
-        // Dependency _id változásának követése - csak akkor reload-oljuk a dependenseket, ha a dependency _id ténylegesen változott
-        // Inicializáljuk az aktuális dependency _id-vel, ha már van adat
-        /* let previousDependencyId: any = this.data && this.data['_id'] ? this.data['_id'] : undefined; */
-        
-        this.getPostProcesses.push(
-          async (newData: T): Promise<T> => {
-            if (newData && newData['_id'] && newData['_id'] !== dependent_DH.lastLoadedBy) {
-              dependent_DH.reloadData(newData['_id']);
-            } else if (!newData) {
-              dependent_DH.clear();
-            }
-            
-            /* const currentDependencyId = newData && newData['_id'] ? newData['_id'] : undefined;
-            
-            // Csak akkor reload-olunk, ha a dependency _id ténylegesen változott
-            if (currentDependencyId && currentDependencyId !== previousDependencyId) {
-              previousDependencyId = currentDependencyId;
-              if (currentDependencyId !== dependent_DH.lastLoadedBy) {
-                dependent_DH.reloadData(currentDependencyId);
-              }
-            } else if (!newData && previousDependencyId !== undefined) {
-              previousDependencyId = undefined;
-              dependent_DH.clear();
-            } */
-
-            return newData;
-          }
-        );
-
-        if (!isInConstruct && this.data) {
-          dependent_DH.reloadData(this.data['_id']);
-        }
-      });
-    } catch (error) {
-      DyFM_Log.error(`Error adding dependent data handlers in DyFM_SignalDataHandler (${this.name}):`, error);
-    }
-  }
-
-  /**
-   * reloads data on DynamoDataHandler using predefined apiservice,
-   * using previous or given id,
-   * prevents multiple load calls and triggers data change subscriptions when done
-   * @param loadBy previous or given id (or can be disabled trough setup by: { noId: true })
-   * @param opts BFR-MASTERPROMPTER-024: `silentMissingId` — a hiányzó-ID ág NE console.error-ozzon
-   *   (a throw MARAD). A `getData()` not-loaded-yet útja használja: friss boot-on a dependency-cascade
-   *   (header token-balance/user-data read) a session-restore ELŐTT ér ide → az ID-hiány ott
-   *   „még-nincs-betöltve", NEM caller-hiba — a korábbi feltétel-nélküli console.error minden
-   *   hard-nav-on 2 hamis error-t tett a konzolra (release-gate-zaj). Direct `reloadData()`-hívásnál
-   *   a hiba-log változatlan (valódi caller-hiba látható marad).
-   * @returns the data as Promise<T>, finishes when the call ends (throws error on fail)
-   */
-  async reloadData(loadBy?: T_LoadBy, opts?: { silentMissingId?: boolean }): Promise<T> {
-    try {
-      const loadInProgress = this.loadInProgress_$();
-      const useLoadBy: T_LoadBy = loadBy ??
-        (this.data && this.data['_id'] ? this.data['_id'] : this.lastLoadedBy);
-
-      if (!useLoadBy && !this.noId) {
-        if (!opts?.silentMissingId) {
-          console.error(
-            `DynamoERROR (DH.reloadData): Missing ID! (${this.name})`,
-            this.data,
-            '\n\n', new Error()
-          );
-        }
-
-        throw new Error(`DynamoERROR (DH.reloadData): Missing ID! (${this.name})`);
-      }
-
-      if (loadInProgress && loadInProgress.loadBy === useLoadBy) {
-        if (this.debugLog) {
-          console.log(
-            `DYNAMO DH.reloadData (${this.name}) DEBUG:` +
-            `\n  DataHandler reloadData... (using id: ${useLoadBy})` +
-            `\n  DataHandler is already loading data...`
-          );
-        }
-
-        return this.data;
-      }
-
-      if (this.debugLog) {
-        console.log(
-          `DYNAMO DH.reloadData (${this.name}) DEBUG:` +
-          `\n  DataHandler reloadData... (using id: ${useLoadBy})`
-        );
-      }
-
-      const loadProgress = this.doReloadDataBy(useLoadBy);
-      this.loadInProgress_$.set({ 
-        loadBy: useLoadBy,
-        progress: loadProgress
-      });
-      loadProgress.finally(() => {
-        this.loadInProgress_$.set(false);
-      });
-
-      return await loadProgress;      
-    } catch (error) {
-      this.loadInProgress_$.set(false);
-      this.loaded_$.set(false);
-
-      if (!error?.error?.handled) {
-        console.error(
-          `DYNAMO DH.reloadData (${this.name}) ERROR: ` +
-          `\n  reloadData was UNSUCCESSFUL`,
-          '\n\n', error,
-          '\n\n', new Error()
-        );
-
-        if (error?.error?.flag?.includes('DYNAMO')) {
-          error.error.handled = true;
-        }
-      }
-
-      throw error;
-    }
-  }
-
-  async getData(): Promise<T> {
-    if (!this.data) {
-      const loadProgress = this.loadInProgress_$();
-      if (loadProgress) {
-        return await loadProgress.progress;
-      } else {
-        // BFR-MASTERPROMPTER-024: a getData not-loaded-yet útján a hiányzó ID „még-nincs-betöltve"
-        // (boot-race a session-restore-ral), NEM caller-hiba → silent (a throw marad, a hívó catch-eli).
-        return await this.reloadData(undefined, { silentMissingId: true });
-      }
-    } else {
-      return this.data;
-    }
-  }
-
-  protected async doReloadDataBy(loadedBy: T_LoadBy): Promise<T> {
-    try {
-      this.lastLoadedBy = loadedBy;
-
-      return await this.processLoadResult(await this.get(loadedBy), loadedBy);
-    } catch (error) {
-      this.resolveWaitsOnLoad();
-      throw error;
-    }
-  }
-
-  /**
-   * Az adat közvetlen frissítése (round-trip nélkül; pl. SPA-login → user_DH.updateData). Alapból CSAK
-   * a saját `data_$`-t frissíti.
-   *
-   * @param reloadDependents opt-in (BFR-MASTERPROMPTER-013): ha true, a dependent DataHandler-eket
-   *   (pl. token-balance) is újratölti az új adat `_id`-jével — a `reloadData` post-process
-   *   dependent-lánca az `updateData` (round-trip-mentes) úton eddig NEM futott → a friss SPA-login után
-   *   a dependent-DH-adatok üresek maradtak hard-reload-ig. DEFAULT false (backward-safe: a vak
-   *   dependent-reload HTTP-flood-ot okozhatna, az updateData szándéka épp a szerver-hívás elkerülése).
-   */
-  async updateData(data: T, dontSendUpdate?: boolean, reloadDependents?: boolean): Promise<void> {
-    if (this.set && !dontSendUpdate) {
-      this.data_$.set(await this.set(data));
-    } else {
-      this.data_$.set(data);
-    }
-
-    if (reloadDependents) {
-      // ugyanaz a reload-vagy-clear logika, mint a reloadData dependent-lánc-postprocess-e
-      this.dependentDataHandlers?.forEach((dependent_DH: DyFM_SignalDataHandler<any>): void => {
-        if (data && data['_id'] && data['_id'] !== dependent_DH.lastLoadedBy) {
-          dependent_DH.reloadData(data['_id']);
-        } else if (!data) {
-          dependent_DH.clear();
-        }
-      });
-    }
-  }
-
-  clear(dontClearDependents?: boolean): void {
-    this.data_$.set(undefined);
-    this.lastLoadedBy = undefined;
-    if (!dontClearDependents) {
-      this.dependentDataHandlers.forEach((ddh: DyFM_SignalDataHandler<any>): void => {
-        ddh.clear();
-      });
-    }
-  }
-
-  protected async processLoadResult(result: any, loadedBy: T_LoadBy): Promise<T> {
-    try {
-      if (this.debugLog) {
-        console.log(
-          `DYNAMO DH.processLoadResult (${this.name}) DEBUG:` +
-          `\n  DataHandler processLoadResult... (using id: ${loadedBy})` +
-          `\n  Result:`, result
-        );
-      }
-
-      for (const postProcess of this.getPostProcesses) {
-        if (this.debugLog) {
-          console.log(
-            `DYNAMO DH.processLoadResult (${this.name}) DEBUG:` +
-            `\n  Post process:`, postProcess
-          );
-        }
-        
-        result = await postProcess(result, loadedBy);
-
-        if (!result) {
-          DyFM_Log.warn(
-            `DYNAMO DH.processLoadResult (${this.name}) WARN: ` +
-            `\nPost process returned null or undefined!`,
-            '\n\n', new Error()
-          );
-        }
-      }
-      this.data_$.set(result);
-      this.loaded_$.set(true);
-      this.resolveWaitsOnLoad();
-      return result;
-    } catch (error) {
-      DyFM_Log.error(`Error in DH.processLoadResult (${this.name}):`, error);
-      throw error;
-    }
-  }
-
-  private resolveWaitsOnLoad(): void {
-    this.waitsOnLoad.forEach(({ promise, resolve }) => {
-      resolve();
-    });
-    this.waitsOnLoad = [];
-  }
-
-  /**
-   * waits for the first load to finish
-   * @returns a promise that resolves when the first load finishes after this "subscription"
-   */
-  waitForLoad(): Promise<void> {
-    let resolve: (value: void) => void;
-    const promise = new Promise<void>((r) => { resolve = r; });
-    this.waitsOnLoad.push({ promise, resolve });
-    return promise;
-  }
-
-  protected loopSafetyCheck(): void {
-    this.loopSafetyCollection = this.loopSafetyCollection.filter(
-      (item) => item.at.getTime() > new Date().getTime() - this.loopSafetyTimeout
-    );
-
-    this.loopSafetyCollection.push({
-      at: new Date(),
-      stack: new Error().stack,
-    });
-
-    if (this.loopSafetyCollection.length > this.loopSafety) {
-      throw new Error(
-        `DYNAMO DH.loopSafetyCheck (${this.name}) ERROR: ` +
-        `\n  Loop safety triggered! Count: ${this.loopSafetyCollection.length}` +
-        `\n  Timeout: ${this.loopSafetyTimeout} MaxCount: ${this.loopSafety} Stack: ${new Error().stack}`
-      );
-    }
-  }
-}
-
-

package/src/_modules/ngx-models/_models/control-models/errors/error-notification.control-model.ts

@@ -1,52 +0,0 @@
-import { DyFM_ErrorNotification_Color } from '../../../_enums/errors/error-notification-color.enum';
-import { DyFM_Error_Level } from '../../../_enums/errors/error-level.enum';
-
-/**
- * CCAP-mirror Wave-1a — Runtime notification record.
- *
- * A `DyNX_Errors_ControlService.errors_$: WritableSignal<DyFM_ErrorNotification[]>`
- * lista eleme. CCAP `errors_$[]` minta. Server-side NEM persisted — futás-időben él.
- *
- * @see _specifications/ccap-mirror/02-architecture-spec.md (J szakasz)
- */
-export class DyFM_ErrorNotification {
-  /** Egyedi id (UUID vagy timestamp + random). */
-  id!: string;
-
-  /** Megjelenítendő rövid üzenet. */
-  message!: string;
-
-  /** Error-source label (pl. `'http'`, `'socket'`, `'angular-unhandled'`). */
-  source?: string;
-
-  /** Severity szint — a Tailwind szín-token-t ez vezérli. */
-  level?: DyFM_Error_Level;
-
-  /** Vizuális szín-token (UI-fix override). Ha hiányzik, `level`-ből származtatva. */
-  color?: DyFM_ErrorNotification_Color;
-
-  /** Eredeti error referencia (modal-detail nézethez). */
-  originalError?: unknown;
-
-  /** Timestamp ISO 8601. */
-  createdAt!: string;
-
-  /** Ennyi occurrence már volt (server-side dedup után frissül; client-side csak 1). */
-  occurrenceCount?: number;
-
-  /** Auto-dismiss ezen időpont után (ISO 8601). Ha hiányzik, manual-dismiss. */
-  autoDismissAt?: string;
-
-  constructor(set: Partial<DyFM_ErrorNotification> = {}) {
-    if (!set.id) {
-      throw new Error('DyFM_ErrorNotification: `id` is required');
-    }
-    if (!set.message) {
-      throw new Error('DyFM_ErrorNotification: `message` is required');
-    }
-    if (!set.createdAt) {
-      set.createdAt = new Date().toISOString();
-    }
-    Object.assign(this, set);
-  }
-}

package/src/_modules/ngx-models/_models/control-models/errors/error-settings.control-model.ts

@@ -1,34 +0,0 @@
-/**
- * CCAP-mirror Wave-1a — Single error display Settings.
- *
- * A `DyNX_Error_Component` (single error renderer) POJO konfigurációja.
- * Server-importálható; minden mező optional, primitív vagy enum.
- *
- * Function-handler-ek (onCopy, onSendToInput, ...) NEM ezen az osztályon —
- * a Params constructor `runtimeOptions` argumentumában.
- *
- * @see _specifications/ccap-mirror/02-architecture-spec.md (J szakasz)
- */
-export class DyFM_ErrorDisplay_Settings {
-  /** Display-only override a `source` mezőre (a runtime errorClientSource felülírja a UI-on). */
-  sourceLabelOverride?: string;
-
-  /** Engedélyezi a `Copy to clipboard` gombot. Default: `true`. */
-  copyEnabled?: boolean;
-
-  /** Engedélyezi a `Send to QuickInput` gombot (consumer-side QuickInput hub-bal). Default: `false`. */
-  sendToQuickInputEnabled?: boolean;
-
-  /** Mely szekciók legyenek **default expanded** (a többi collapsed indul). */
-  defaultExpandedSections?: ('message' | 'details' | 'stack')[];
-
-  /** Engedélyezi a `Show JSON` (raw error) shortcut-ot. Default: `false`. */
-  showRawJsonEnabled?: boolean;
-
-  /** `data-testid` érték. */
-  testId?: string;
-
-  constructor(set: Partial<DyFM_ErrorDisplay_Settings> = {}) {
-    Object.assign(this, set);
-  }
-}

package/src/_modules/ngx-models/_models/control-models/errors/errors-pojo.spec.ts

@@ -1,86 +0,0 @@
-import { DyFM_Error_Level } from '../../../_enums/errors/error-level.enum';
-import { DyFM_ErrorNotification_Color } from '../../../_enums/errors/error-notification-color.enum';
-import { DyFM_ErrorUi_Mode } from '../../../_enums/errors/error-ui-mode.enum';
-import { DyFM_Errors_Settings } from './errors-settings.control-model';
-import { DyFM_ErrorNotification } from './error-notification.control-model';
-import { DyFM_ErrorDisplay_Settings } from './error-settings.control-model';
-
-describe('CCAP-mirror Wave-1a — Errors POJO', () => {
-
-  describe('DyFM_ErrorDisplay_Settings', () => {
-    it('| constructs from empty input with all defaults undefined', () => {
-      const s = new DyFM_ErrorDisplay_Settings();
-      expect(s.copyEnabled).toBeUndefined();
-      expect(s.sendToQuickInputEnabled).toBeUndefined();
-      expect(s.defaultExpandedSections).toBeUndefined();
-    });
-
-    it('| copies known fields from partial input', () => {
-      const s = new DyFM_ErrorDisplay_Settings({
-        copyEnabled: true,
-        sourceLabelOverride: 'API',
-        defaultExpandedSections: ['message', 'stack'],
-        testId: 'sandbox-error',
-      });
-      expect(s.copyEnabled).toBe(true);
-      expect(s.sourceLabelOverride).toBe('API');
-      expect(s.defaultExpandedSections).toEqual(['message', 'stack']);
-      expect(s.testId).toBe('sandbox-error');
-    });
-  });
-
-  describe('DyFM_Errors_Settings', () => {
-    it('| accepts all FR-029 protection fields', () => {
-      const s = new DyFM_Errors_Settings({
-        reportEndpoint: '/errors/log',
-        loopThresholdMs: 3000,
-        loopRepeatCount: 5,
-        stormThresholdPerWindow: 50,
-        stormWindowMs: 10000,
-        popupDedupMs: 10000,
-        uiMode: DyFM_ErrorUi_Mode.both,
-        notificationStackMax: 10,
-        autoDismissMs: 10000,
-        reportSocketConnectionErrors: false,
-        stormRecoverSilenceMs: 30000,
-      });
-      expect(s.reportEndpoint).toBe('/errors/log');
-      expect(s.uiMode).toBe(DyFM_ErrorUi_Mode.both);
-      expect(s.notificationStackMax).toBe(10);
-    });
-
-    it('| empty constructor accepted (all defaults assumed by consumer)', () => {
-      const s = new DyFM_Errors_Settings();
-      expect(s.uiMode).toBeUndefined();
-    });
-  });
-
-  describe('DyFM_ErrorNotification', () => {
-    it('| throws if `id` missing', () => {
-      expect(() => new DyFM_ErrorNotification({ message: 'oh' })).toThrowError(/`id` is required/);
-    });
-
-    it('| throws if `message` missing', () => {
-      expect(() => new DyFM_ErrorNotification({ id: 'a' })).toThrowError(/`message` is required/);
-    });
-
-    it('| auto-fills `createdAt` if missing', () => {
-      const n = new DyFM_ErrorNotification({ id: 'n1', message: 'oh' });
-      expect(n.createdAt).toBeTruthy();
-      expect(new Date(n.createdAt).toString()).not.toBe('Invalid Date');
-    });
-
-    it('| respects explicit `createdAt`', () => {
-      const n = new DyFM_ErrorNotification({
-        id: 'n1',
-        message: 'oh',
-        createdAt: '2026-06-05T00:00:00.000Z',
-        level: DyFM_Error_Level.warning,
-        color: DyFM_ErrorNotification_Color.amber,
-      });
-      expect(n.createdAt).toBe('2026-06-05T00:00:00.000Z');
-      expect(n.level).toBe(DyFM_Error_Level.warning);
-      expect(n.color).toBe(DyFM_ErrorNotification_Color.amber);
-    });
-  });
-});