@futdevpro/fsm-dynamo 1.16.39 → 1.20.2

package/build/_modules/data-handler/_models/data-handler.control-model.js

@@ -1,360 +1,360 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyFM_DataHandler = void 0;
-const __1 = require("../../..");
-const rxjs_1 = require("rxjs");
-/**
- * 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',
- * });
- */
-class DyFM_DataHandler {
-    name;
-    /**
-     * BehaviorSubject that holds the current data value.
-     * This is the source of truth for data in DyFM.
-     */
-    data_BS;
-    /**
-     * Observable that emits the current data value.
-     * Derived from the BehaviorSubject.
-     */
-    data$;
-    /**
-     * BehaviorSubject that indicates whether the data has been loaded.
-     * True when data is loaded, false otherwise.
-     */
-    loaded_BS;
-    /**
-     * Observable that indicates whether the data has been loaded.
-     */
-    loaded$;
-    /**
-     * BehaviorSubject that tracks the current loading operation.
-     * Contains information about the ongoing data load operation or false if no load is in progress.
-     */
-    loadInProgress_BS;
-    /**
-     * Observable that tracks the current loading operation.
-     */
-    loadInProgress$;
-    /**
-     * last loaded by will work properly only if you use the Dynamo form of "_id" for loading
-     */
-    lastLoadedBy; // for lists
-    defaultLoadBy; // for lists
-    /** this will handle the data loading from the api */
-    get;
-    /** this will handle the data setting to the data handler */
-    set;
-    /** 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)
-     */
-    getPostProcesses = [];
-    noId;
-    waitsOnLoad = [];
-    dependentDataHandlers = [];
-    debugLog;
-    /**
-     * 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, 
-    /** is in construct?
-     * so the dependent data handlers are not added here, but in the extended class */
-    skipDependencyConnections) {
-        // TODO: + TRYTOGETTYPE(this.data);
-        if (!set.name) {
-            set.name = 'Unnamed DataHandler ' + (+new Date());
-            __1.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;
-        // Initialize BehaviorSubjects
-        this.data_BS = new rxjs_1.BehaviorSubject(set.defaultValue);
-        this.data$ = this.data_BS.asObservable();
-        this.loaded_BS = new rxjs_1.BehaviorSubject(false);
-        this.loaded$ = this.loaded_BS.asObservable();
-        this.loadInProgress_BS = new rxjs_1.BehaviorSubject(false);
-        this.loadInProgress$ = this.loadInProgress_BS.asObservable();
-        if (set.get) {
-            this.get = set.get;
-        }
-        if (set.set) {
-            this.set = set.set;
-        }
-        this.noId = !!set.noId;
-        if (set.defaultLoadBy) {
-            this.defaultLoadBy = set.defaultLoadBy;
-        }
-        if (!skipDependencyConnections) {
-            if (set.dependencyDataHandler) {
-                this.addDependencyDataHandler(set.dependencyDataHandler);
-            }
-            if (set.dependentDataHandlers) {
-                this.addDependentDataHandlers(set.dependentDataHandlers, true);
-            }
-        }
-        if (set.getPostProcess) {
-            this.getPostProcesses.push(set.getPostProcess);
-        }
-    }
-    addDependencyDataHandler(dependencyDataHandler) {
-        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_DataHandler)) {
-                throw new Error(`DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
-                    `\n  Dependent DataHandler is not instance of DyFM_DataHandler! (${this.name})`);
-            }
-            dependencyDataHandler.addDependentDataHandlers([this]);
-        }
-        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, isInConstruct) {
-        dependentDataHandlers.forEach((dependent_DH) => {
-            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_DataHandler)) {
-                throw new Error(`DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
-                    `\n  Dependent DataHandler is not instance of DyFM_DataHandler! (${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_BS) {
-                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) => {
-                    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;
-                });
-            }
-            this.getPostProcesses.push(async (newData) => {
-                if (newData && newData._id && newData._id !== dependent_DH.lastLoadedBy) {
-                    dependent_DH.reloadData(newData._id);
-                }
-                else if (!newData) {
-                    dependent_DH.clear();
-                }
-                return newData;
-            });
-            if (!isInConstruct && this.data) {
-                dependent_DH.reloadData(this.data._id);
-            }
-        });
-    }
-    /**
-     * 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, opts) {
-        try {
-            const loadInProgress = this.loadInProgress_BS.value;
-            const useLoadBy = loadBy ??
-                this.data?._id ??
-                this.lastLoadedBy ??
-                this.defaultLoadBy;
-            if (!useLoadBy && !this.noId) {
-                // BFR-MASTERPROMPTER-024: a getData not-loaded-yet útján (silentMissingId) a console.error
-                // kimarad — a boot-race ID-hiány nem caller-hiba; a throw változatlanul megy.
-                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_BS.next({
-                loadBy: useLoadBy,
-                progress: loadProgress
-            });
-            loadProgress.finally(() => {
-                this.loadInProgress_BS.next(false);
-            });
-            return await loadProgress;
-        }
-        catch (error) {
-            this.loadInProgress_BS.next(false);
-            this.loaded_BS.next(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() {
-        if (!this.data) {
-            const loadProgress = this.loadInProgress_BS.value;
-            if (loadProgress) {
-                return await loadProgress.progress;
-            }
-            else {
-                // BFR-MASTERPROMPTER-024: not-loaded-yet út → silent missing-ID (a throw marad).
-                return await this.reloadData(undefined, { silentMissingId: true });
-            }
-        }
-        else {
-            return this.data;
-        }
-    }
-    async doReloadDataBy(loadedBy) {
-        try {
-            this.lastLoadedBy = loadedBy;
-            return await this.processLoadResult(await this.get(loadedBy), loadedBy);
-        }
-        catch (error) {
-            this.resolveWaitsOnLoad();
-            throw error;
-        }
-    }
-    /**
-     * A DataHandler adatának közvetlen frissítése egy már ismert value-val, szerver-round-trip NÉLKÜL
-     * (pl. login-response → user_DH.updateData). Alapból CSAK a saját data_BS-t frissíti.
-     *
-     * @param reloadDependents opt-in (BFR-MASTERPROMPTER-013): ha true, a `reloadData` post-process
-     *   dependent-reload-láncát is meghajtja — a függő DataHandler-ek (pl. token-balance) újratöltődnek
-     *   az új adat `_id`-jével. A `reloadData` (hard-nav boot) útján ez a lánc automatikus, de az
-     *   `updateData` (round-trip-mentes) útján eddig NEM futott → a friss SPA-login után a dependent-DH
-     *   adatok üresek maradtak hard-reload-ig. DEFAULT false (backward-safe): az `updateData` fő szándéka
-     *   ÉPP a szerver-hívás elkerülése, ezért a vak dependent-reload nem kívánt HTTP-flood-ot okozhatna.
-     */
-    async updateData(data, dontSendUpdate, reloadDependents) {
-        if (this.set && !dontSendUpdate) {
-            this.data_BS.next(await this.set(data));
-        }
-        else {
-            this.data_BS.next(data);
-        }
-        if (reloadDependents) {
-            // ugyanaz a reload-vagy-clear logika, mint a reloadData post-process-e (dependent-lánc)
-            this.dependentDataHandlers?.forEach((dependent_DH) => {
-                if (data && data._id && data._id !== dependent_DH.lastLoadedBy) {
-                    dependent_DH.reloadData(data._id);
-                }
-                else if (!data) {
-                    dependent_DH.clear();
-                }
-            });
-        }
-    }
-    clear(dontClearDependents) {
-        this.data_BS.next(undefined);
-        this.lastLoadedBy = undefined;
-        if (!dontClearDependents) {
-            this.dependentDataHandlers.forEach((ddh) => {
-                ddh.clear();
-            });
-        }
-    }
-    async processLoadResult(result, loadedBy) {
-        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) {
-                __1.DyFM_Log.warn(`DYNAMO DH.processLoadResult (${this.name}) WARN: ` +
-                    `\nPost process returned null or undefined!`, '\n\n', new Error());
-            }
-        }
-        this.data_BS.next(result);
-        this.loaded_BS.next(true);
-        this.resolveWaitsOnLoad();
-        return result;
-    }
-    resolveWaitsOnLoad() {
-        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() {
-        let resolve;
-        const promise = new Promise((r) => { resolve = r; });
-        this.waitsOnLoad.push({ promise, resolve });
-        return promise;
-    }
-}
-exports.DyFM_DataHandler = DyFM_DataHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyFM_DataHandler = void 0;
+const __1 = require("../../..");
+const rxjs_1 = require("rxjs");
+/**
+ * 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',
+ * });
+ */
+class DyFM_DataHandler {
+    name;
+    /**
+     * BehaviorSubject that holds the current data value.
+     * This is the source of truth for data in DyFM.
+     */
+    data_BS;
+    /**
+     * Observable that emits the current data value.
+     * Derived from the BehaviorSubject.
+     */
+    data$;
+    /**
+     * BehaviorSubject that indicates whether the data has been loaded.
+     * True when data is loaded, false otherwise.
+     */
+    loaded_BS;
+    /**
+     * Observable that indicates whether the data has been loaded.
+     */
+    loaded$;
+    /**
+     * BehaviorSubject that tracks the current loading operation.
+     * Contains information about the ongoing data load operation or false if no load is in progress.
+     */
+    loadInProgress_BS;
+    /**
+     * Observable that tracks the current loading operation.
+     */
+    loadInProgress$;
+    /**
+     * last loaded by will work properly only if you use the Dynamo form of "_id" for loading
+     */
+    lastLoadedBy; // for lists
+    defaultLoadBy; // for lists
+    /** this will handle the data loading from the api */
+    get;
+    /** this will handle the data setting to the data handler */
+    set;
+    /** 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)
+     */
+    getPostProcesses = [];
+    noId;
+    waitsOnLoad = [];
+    dependentDataHandlers = [];
+    debugLog;
+    /**
+     * 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, 
+    /** is in construct?
+     * so the dependent data handlers are not added here, but in the extended class */
+    skipDependencyConnections) {
+        // TODO: + TRYTOGETTYPE(this.data);
+        if (!set.name) {
+            set.name = 'Unnamed DataHandler ' + (+new Date());
+            __1.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;
+        // Initialize BehaviorSubjects
+        this.data_BS = new rxjs_1.BehaviorSubject(set.defaultValue);
+        this.data$ = this.data_BS.asObservable();
+        this.loaded_BS = new rxjs_1.BehaviorSubject(false);
+        this.loaded$ = this.loaded_BS.asObservable();
+        this.loadInProgress_BS = new rxjs_1.BehaviorSubject(false);
+        this.loadInProgress$ = this.loadInProgress_BS.asObservable();
+        if (set.get) {
+            this.get = set.get;
+        }
+        if (set.set) {
+            this.set = set.set;
+        }
+        this.noId = !!set.noId;
+        if (set.defaultLoadBy) {
+            this.defaultLoadBy = set.defaultLoadBy;
+        }
+        if (!skipDependencyConnections) {
+            if (set.dependencyDataHandler) {
+                this.addDependencyDataHandler(set.dependencyDataHandler);
+            }
+            if (set.dependentDataHandlers) {
+                this.addDependentDataHandlers(set.dependentDataHandlers, true);
+            }
+        }
+        if (set.getPostProcess) {
+            this.getPostProcesses.push(set.getPostProcess);
+        }
+    }
+    addDependencyDataHandler(dependencyDataHandler) {
+        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_DataHandler)) {
+                throw new Error(`DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
+                    `\n  Dependent DataHandler is not instance of DyFM_DataHandler! (${this.name})`);
+            }
+            dependencyDataHandler.addDependentDataHandlers([this]);
+        }
+        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, isInConstruct) {
+        dependentDataHandlers.forEach((dependent_DH) => {
+            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_DataHandler)) {
+                throw new Error(`DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
+                    `\n  Dependent DataHandler is not instance of DyFM_DataHandler! (${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_BS) {
+                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) => {
+                    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;
+                });
+            }
+            this.getPostProcesses.push(async (newData) => {
+                if (newData && newData._id && newData._id !== dependent_DH.lastLoadedBy) {
+                    dependent_DH.reloadData(newData._id);
+                }
+                else if (!newData) {
+                    dependent_DH.clear();
+                }
+                return newData;
+            });
+            if (!isInConstruct && this.data) {
+                dependent_DH.reloadData(this.data._id);
+            }
+        });
+    }
+    /**
+     * 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, opts) {
+        try {
+            const loadInProgress = this.loadInProgress_BS.value;
+            const useLoadBy = loadBy ??
+                this.data?._id ??
+                this.lastLoadedBy ??
+                this.defaultLoadBy;
+            if (!useLoadBy && !this.noId) {
+                // BFR-MASTERPROMPTER-024: a getData not-loaded-yet útján (silentMissingId) a console.error
+                // kimarad — a boot-race ID-hiány nem caller-hiba; a throw változatlanul megy.
+                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_BS.next({
+                loadBy: useLoadBy,
+                progress: loadProgress
+            });
+            loadProgress.finally(() => {
+                this.loadInProgress_BS.next(false);
+            });
+            return await loadProgress;
+        }
+        catch (error) {
+            this.loadInProgress_BS.next(false);
+            this.loaded_BS.next(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() {
+        if (!this.data) {
+            const loadProgress = this.loadInProgress_BS.value;
+            if (loadProgress) {
+                return await loadProgress.progress;
+            }
+            else {
+                // BFR-MASTERPROMPTER-024: not-loaded-yet út → silent missing-ID (a throw marad).
+                return await this.reloadData(undefined, { silentMissingId: true });
+            }
+        }
+        else {
+            return this.data;
+        }
+    }
+    async doReloadDataBy(loadedBy) {
+        try {
+            this.lastLoadedBy = loadedBy;
+            return await this.processLoadResult(await this.get(loadedBy), loadedBy);
+        }
+        catch (error) {
+            this.resolveWaitsOnLoad();
+            throw error;
+        }
+    }
+    /**
+     * A DataHandler adatának közvetlen frissítése egy már ismert value-val, szerver-round-trip NÉLKÜL
+     * (pl. login-response → user_DH.updateData). Alapból CSAK a saját data_BS-t frissíti.
+     *
+     * @param reloadDependents opt-in (BFR-MASTERPROMPTER-013): ha true, a `reloadData` post-process
+     *   dependent-reload-láncát is meghajtja — a függő DataHandler-ek (pl. token-balance) újratöltődnek
+     *   az új adat `_id`-jével. A `reloadData` (hard-nav boot) útján ez a lánc automatikus, de az
+     *   `updateData` (round-trip-mentes) útján eddig NEM futott → a friss SPA-login után a dependent-DH
+     *   adatok üresek maradtak hard-reload-ig. DEFAULT false (backward-safe): az `updateData` fő szándéka
+     *   ÉPP a szerver-hívás elkerülése, ezért a vak dependent-reload nem kívánt HTTP-flood-ot okozhatna.
+     */
+    async updateData(data, dontSendUpdate, reloadDependents) {
+        if (this.set && !dontSendUpdate) {
+            this.data_BS.next(await this.set(data));
+        }
+        else {
+            this.data_BS.next(data);
+        }
+        if (reloadDependents) {
+            // ugyanaz a reload-vagy-clear logika, mint a reloadData post-process-e (dependent-lánc)
+            this.dependentDataHandlers?.forEach((dependent_DH) => {
+                if (data && data._id && data._id !== dependent_DH.lastLoadedBy) {
+                    dependent_DH.reloadData(data._id);
+                }
+                else if (!data) {
+                    dependent_DH.clear();
+                }
+            });
+        }
+    }
+    clear(dontClearDependents) {
+        this.data_BS.next(undefined);
+        this.lastLoadedBy = undefined;
+        if (!dontClearDependents) {
+            this.dependentDataHandlers.forEach((ddh) => {
+                ddh.clear();
+            });
+        }
+    }
+    async processLoadResult(result, loadedBy) {
+        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) {
+                __1.DyFM_Log.warn(`DYNAMO DH.processLoadResult (${this.name}) WARN: ` +
+                    `\nPost process returned null or undefined!`, '\n\n', new Error());
+            }
+        }
+        this.data_BS.next(result);
+        this.loaded_BS.next(true);
+        this.resolveWaitsOnLoad();
+        return result;
+    }
+    resolveWaitsOnLoad() {
+        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() {
+        let resolve;
+        const promise = new Promise((r) => { resolve = r; });
+        this.waitsOnLoad.push({ promise, resolve });
+        return promise;
+    }
+}
+exports.DyFM_DataHandler = DyFM_DataHandler;
 //# sourceMappingURL=data-handler.control-model.js.map