@futdevpro/fsm-dynamo 1.15.20 → 1.15.22

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

@@ -0,0 +1,498 @@
+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 })
+   * @returns the data as Promise<T>, finishes when the call ends (throws error on fail)
+   */
+  async reloadData(loadBy?: T_LoadBy): 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) {
+        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 {
+        return await this.reloadData();
+      }
+    } 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;
+    }
+  }
+
+  async updateData(data: T, dontSendUpdate?: boolean): Promise<void> {
+    if (this.set && !dontSendUpdate) {
+      this.data_$.set(await this.set(data));
+    } else {
+      this.data_$.set(data);
+    }
+  }
+
+  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

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

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

@@ -0,0 +1,86 @@
+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);
+    });
+  });
+});