xmlui 0.10.19 → 0.10.21

package/dist/scripts/src/components-core/script-runner/eval-tree-async.js

@@ -147,20 +147,18 @@ function evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext
     });
 }
 function evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!expr.exprs || expr.exprs.length === 0) {
-            throw new Error(`Missing expression sequence`);
-        }
-        const result = expr.exprs.map((e) => __awaiter(this, void 0, void 0, function* () {
-            const value = yield evaluator(thisStack, e, evalContext, thread);
-            (0, eval_tree_common_1.setExprValue)(e, { value }, thread);
-            thisStack.pop();
-            return value;
-        }));
-        const lastObj = result[result.length - 1];
-        thisStack.push(lastObj);
-        return lastObj;
-    });
+    if (!expr.exprs || expr.exprs.length === 0) {
+        throw new Error(`Missing expression sequence`);
+    }
+    const result = expr.exprs.map((e) => __awaiter(this, void 0, void 0, function* () {
+        const value = yield evaluator(thisStack, e, evalContext, thread);
+        (0, eval_tree_common_1.setExprValue)(e, { value }, thread);
+        thisStack.pop();
+        return value;
+    }));
+    const lastObj = result[result.length - 1];
+    thisStack.push(lastObj);
+    return lastObj;
 }
 function evalArrayLiteralAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -274,7 +272,7 @@ function evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread) {
         const rootScope = (0, eval_tree_common_1.getRootIdScope)(leftValue, evalContext, thread);
         const updatesState = rootScope && rootScope.type !== "block";
         if (updatesState && evalContext.onWillUpdate) {
-            evalContext.onWillUpdate(rootScope, rootScope.name, "assignment");
+            void evalContext.onWillUpdate(rootScope, rootScope.name, "assignment");
         }
         yield evaluator(thisStack, leftValue, evalContext, thread);
         thisStack.pop();
@@ -284,7 +282,7 @@ function evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread) {
         yield completeExprValue(expr.expr, thread);
         const value = (0, eval_tree_common_1.evalAssignmentCore)(thisStack, expr, evalContext, thread);
         if (updatesState && evalContext.onDidUpdate) {
-            evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
+            void evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
         }
         return value;
     });
@@ -294,14 +292,14 @@ function evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, thread) {
         const rootScope = (0, eval_tree_common_1.getRootIdScope)(expr.expr, evalContext, thread);
         const updatesState = rootScope && rootScope.type !== "block";
         if (updatesState && evalContext.onWillUpdate) {
-            evalContext.onWillUpdate(rootScope, rootScope.name, "pre-post");
+            void evalContext.onWillUpdate(rootScope, rootScope.name, "pre-post");
         }
         yield evaluator(thisStack, expr.expr, evalContext, thread);
         thisStack.pop();
         yield completeExprValue(expr.expr, thread);
         const value = (0, eval_tree_common_1.evalPreOrPostCore)(thisStack, expr, evalContext, thread);
         if (updatesState && evalContext.onDidUpdate) {
-            evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
+            void evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
         }
         return value;
     });
@@ -352,17 +350,17 @@ function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, th
                 }
                 else {
                     if (arg.type === ScriptingSourceTree_1.T_ARROW_EXPRESSION) {
-                        const funcArg = yield createArrowFunctionAsync(evaluator, arg);
-                        const wrappedFunc = (...args) => __awaiter(this, void 0, void 0, function* () {
+                        const funcArg = createArrowFunctionAsync(evaluator, arg);
+                        const wrappedFunc = (...args) => {
                             return funcArg(arg.args, evalContext, thread, ...args);
-                        });
+                        };
                         functionArgs.push(wrappedFunc);
                     }
                     else {
                         yield evaluator([], arg, evalContext, thread);
                         const funcArg = yield completeExprValue(arg, thread);
                         if (funcArg === null || funcArg === void 0 ? void 0 : funcArg._ARROW_EXPR_) {
-                            const wrappedFuncArg = yield createArrowFunctionAsync(evaluator, funcArg);
+                            const wrappedFuncArg = createArrowFunctionAsync(evaluator, funcArg);
                             const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, ...args);
                             functionArgs.push(wrappedFunc);
                         }
@@ -398,14 +396,14 @@ function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, th
         const rootScope = (0, eval_tree_common_1.getRootIdScope)(expr.obj, evalContext, thread);
         const updatesState = rootScope && rootScope.type !== "block";
         if (updatesState && evalContext.onWillUpdate) {
-            evalContext.onWillUpdate(rootScope, rootScope.name, "function-call");
+            void evalContext.onWillUpdate(rootScope, rootScope.name, "function-call");
         }
         const value = ((_d = evalContext.options) === null || _d === void 0 ? void 0 : _d.defaultToOptionalMemberAccess)
             ? functionObj === null || functionObj === void 0 ? void 0 : functionObj.call(currentContext, ...functionArgs)
             : functionObj.call(currentContext, ...functionArgs);
         let returnValue = yield completePromise(value);
         if (updatesState && evalContext.onDidUpdate) {
-            evalContext.onDidUpdate(rootScope, rootScope.name, "function-call");
+            void evalContext.onDidUpdate(rootScope, rootScope.name, "function-call");
         }
         // --- Done.
         (0, eval_tree_common_1.setExprValue)(expr, { value: returnValue }, thread);
@@ -414,183 +412,179 @@ function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, th
     });
 }
 function createArrowFunctionAsync(evaluator, expr) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // --- Use this function, it evaluates the arrow function
-        return (...args) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            // --- Prepare the variables to pass
-            const runTimeEvalContext = args[1];
-            const runtimeThread = args[2];
-            // --- Create the thread that runs the arrow function
-            const workingThread = {
-                parent: runtimeThread,
-                childThreads: [],
-                blocks: [{ vars: {} }],
-                loops: [],
-                breakLabelValue: -1,
-                closures: expr.closureContext,
-            };
-            runtimeThread.childThreads.push(workingThread);
-            // --- Create a block for a named arrow function
-            if (expr.name) {
-                const functionBlock = { vars: {} };
-                (_a = workingThread.blocks) !== null && _a !== void 0 ? _a : (workingThread.blocks = []);
-                workingThread.blocks.push(functionBlock);
-                functionBlock.vars[expr.name] = expr;
-                functionBlock.constVars = new Set([expr.name]);
-            }
-            // --- Assign argument values to names
-            const arrowBlock = { vars: {} };
-            (_b = workingThread.blocks) !== null && _b !== void 0 ? _b : (workingThread.blocks = []);
-            workingThread.blocks.push(arrowBlock);
-            const argSpecs = args[0];
-            let restFound = false;
-            for (let i = 0; i < argSpecs.length; i++) {
-                // --- Turn argument specification into processable variable declarations
-                const argSpec = argSpecs[i];
-                let decl;
-                switch (argSpec.type) {
-                    case ScriptingSourceTree_1.T_IDENTIFIER: {
-                        decl = {
-                            type: ScriptingSourceTree_1.T_VAR_DECLARATION,
-                            id: argSpec.name,
-                        };
-                        break;
-                    }
-                    case ScriptingSourceTree_1.T_DESTRUCTURE: {
-                        decl = {
-                            type: ScriptingSourceTree_1.T_VAR_DECLARATION,
-                            id: argSpec.id,
-                            aDestr: argSpec.aDestr,
-                            oDestr: argSpec.oDestr,
-                        };
-                        break;
-                    }
-                    case ScriptingSourceTree_1.T_SPREAD_EXPRESSION: {
-                        restFound = true;
-                        decl = {
-                            type: ScriptingSourceTree_1.T_VAR_DECLARATION,
-                            id: argSpec.expr.name,
-                        };
-                        break;
-                    }
-                    default:
-                        throw new Error("Unexpected arrow argument specification");
-                }
-                if (decl) {
-                    if (restFound) {
-                        // --- Get the rest of the arguments
-                        const restArgs = args.slice(i + 3);
-                        let argVals = [];
-                        for (const arg of restArgs) {
-                            if (arg === null || arg === void 0 ? void 0 : arg._EXPRESSION_) {
-                                argVals.push(yield evaluator([], arg, runTimeEvalContext, runtimeThread));
-                            }
-                            else {
-                                argVals.push(arg);
-                            }
-                        }
-                        yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVals);
-                    }
-                    else {
-                        // --- Get the actual value to work with
-                        let argVal = args[i + 3];
-                        if (argVal === null || argVal === void 0 ? void 0 : argVal._EXPRESSION_) {
-                            argVal = yield evaluator([], argVal, runTimeEvalContext, runtimeThread);
-                        }
-                        yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVal);
-                    }
-                }
-            }
-            // --- Evaluate the arrow expression body
-            let returnValue;
-            let statements;
-            switch (expr.statement.type) {
-                case ScriptingSourceTree_1.T_EMPTY_STATEMENT:
-                    statements = [];
+    // --- Use this function, it evaluates the arrow function
+    return (...args) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        // --- Prepare the variables to pass
+        const runTimeEvalContext = args[1];
+        const runtimeThread = args[2];
+        // --- Create the thread that runs the arrow function
+        const workingThread = {
+            parent: runtimeThread,
+            childThreads: [],
+            blocks: [{ vars: {} }],
+            loops: [],
+            breakLabelValue: -1,
+            closures: expr.closureContext,
+        };
+        runtimeThread.childThreads.push(workingThread);
+        // --- Create a block for a named arrow function
+        if (expr.name) {
+            const functionBlock = { vars: {} };
+            (_a = workingThread.blocks) !== null && _a !== void 0 ? _a : (workingThread.blocks = []);
+            workingThread.blocks.push(functionBlock);
+            functionBlock.vars[expr.name] = expr;
+            functionBlock.constVars = new Set([expr.name]);
+        }
+        // --- Assign argument values to names
+        const arrowBlock = { vars: {} };
+        (_b = workingThread.blocks) !== null && _b !== void 0 ? _b : (workingThread.blocks = []);
+        workingThread.blocks.push(arrowBlock);
+        const argSpecs = args[0];
+        let restFound = false;
+        for (let i = 0; i < argSpecs.length; i++) {
+            // --- Turn argument specification into processable variable declarations
+            const argSpec = argSpecs[i];
+            let decl;
+            switch (argSpec.type) {
+                case ScriptingSourceTree_1.T_IDENTIFIER: {
+                    decl = {
+                        type: ScriptingSourceTree_1.T_VAR_DECLARATION,
+                        id: argSpec.name,
+                    };
                     break;
-                case ScriptingSourceTree_1.T_EXPRESSION_STATEMENT:
-                    // --- Create a new thread for the call
-                    statements = [
-                        {
-                            type: ScriptingSourceTree_1.T_RETURN_STATEMENT,
-                            expr: expr.statement.expr,
-                        },
-                    ];
+                }
+                case ScriptingSourceTree_1.T_DESTRUCTURE: {
+                    decl = {
+                        type: ScriptingSourceTree_1.T_VAR_DECLARATION,
+                        id: argSpec.id,
+                        aDestr: argSpec.aDestr,
+                        oDestr: argSpec.oDestr,
+                    };
                     break;
-                case ScriptingSourceTree_1.T_BLOCK_STATEMENT:
-                    // --- Create a new thread for the call
-                    statements = expr.statement.stmts;
+                }
+                case ScriptingSourceTree_1.T_SPREAD_EXPRESSION: {
+                    restFound = true;
+                    decl = {
+                        type: ScriptingSourceTree_1.T_VAR_DECLARATION,
+                        id: argSpec.expr.name,
+                    };
                     break;
+                }
                 default:
-                    throw new Error(`Arrow expression with a body of '${expr.statement.type}' is not supported yet.`);
+                    throw new Error("Unexpected arrow argument specification");
             }
-            // --- Process the statement with a new processor
-            yield (0, process_statement_async_1.processStatementQueueAsync)(statements, runTimeEvalContext, workingThread);
-            // --- Return value is in a return value slot
-            returnValue = workingThread.returnValue;
-            // --- Remove the current working thread
-            const workingIndex = runtimeThread.childThreads.indexOf(workingThread);
-            if (workingIndex < 0) {
-                throw new Error("Cannot find thread to remove.");
+            if (decl) {
+                if (restFound) {
+                    // --- Get the rest of the arguments
+                    const restArgs = args.slice(i + 3);
+                    let argVals = [];
+                    for (const arg of restArgs) {
+                        if (arg === null || arg === void 0 ? void 0 : arg._EXPRESSION_) {
+                            argVals.push(yield evaluator([], arg, runTimeEvalContext, runtimeThread));
+                        }
+                        else {
+                            argVals.push(arg);
+                        }
+                    }
+                    yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVals);
+                }
+                else {
+                    // --- Get the actual value to work with
+                    let argVal = args[i + 3];
+                    if (argVal === null || argVal === void 0 ? void 0 : argVal._EXPRESSION_) {
+                        argVal = yield evaluator([], argVal, runTimeEvalContext, runtimeThread);
+                    }
+                    yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVal);
+                }
             }
-            runtimeThread.childThreads.splice(workingIndex, 1);
-            // --- Remove the function level block
-            workingThread.blocks.pop();
-            // --- Return the function value
-            return returnValue;
-        });
+        }
+        // --- Evaluate the arrow expression body
+        let returnValue;
+        let statements;
+        switch (expr.statement.type) {
+            case ScriptingSourceTree_1.T_EMPTY_STATEMENT:
+                statements = [];
+                break;
+            case ScriptingSourceTree_1.T_EXPRESSION_STATEMENT:
+                // --- Create a new thread for the call
+                statements = [
+                    {
+                        type: ScriptingSourceTree_1.T_RETURN_STATEMENT,
+                        expr: expr.statement.expr,
+                    },
+                ];
+                break;
+            case ScriptingSourceTree_1.T_BLOCK_STATEMENT:
+                // --- Create a new thread for the call
+                statements = expr.statement.stmts;
+                break;
+            default:
+                throw new Error(`Arrow expression with a body of '${expr.statement.type}' is not supported yet.`);
+        }
+        // --- Process the statement with a new processor
+        yield (0, process_statement_async_1.processStatementQueueAsync)(statements, runTimeEvalContext, workingThread);
+        // --- Return value is in a return value slot
+        returnValue = workingThread.returnValue;
+        // --- Remove the current working thread
+        const workingIndex = runtimeThread.childThreads.indexOf(workingThread);
+        if (workingIndex < 0) {
+            throw new Error("Cannot find thread to remove.");
+        }
+        runtimeThread.childThreads.splice(workingIndex, 1);
+        // --- Remove the function level block
+        workingThread.blocks.pop();
+        // --- Return the function value
+        return returnValue;
     });
 }
 // --- Completes all promises within the input
 function completePromise(input) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const visited = new Map();
-        return completePromiseInternal(input);
-        function completePromiseInternal(input) {
-            return __awaiter(this, void 0, void 0, function* () {
-                // --- No need to resolve undefined or null
-                if (input === undefined || input === null)
-                    return input;
-                // --- Already visited?
-                const resolved = visited.get(input);
-                if (resolved)
-                    return resolved;
-                // --- Resolve the chain of promises
-                if ((0, eval_tree_common_1.isPromise)(input)) {
-                    const awaited = yield input;
-                    visited.set(input, awaited);
-                    return completePromiseInternal(awaited);
-                }
-                // --- In any other cases, we keep the input reference
-                visited.set(input, input);
-                // --- Resolve promises within an array
-                if (Array.isArray(input)) {
-                    for (let i = 0; i < input.length; i++) {
-                        const completedPromise = yield completePromiseInternal(input[i]);
-                        if (input[i] !== completedPromise) {
-                            //prevent write if it's the same reference (can cause problems in frozen objects)
-                            input.splice(i, 1, completedPromise);
-                        }
+    const visited = new Map();
+    return completePromiseInternal(input);
+    function completePromiseInternal(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // --- No need to resolve undefined or null
+            if (input === undefined || input === null)
+                return input;
+            // --- Already visited?
+            const resolved = visited.get(input);
+            if (resolved)
+                return resolved;
+            // --- Resolve the chain of promises
+            if ((0, eval_tree_common_1.isPromise)(input)) {
+                const awaited = yield input;
+                visited.set(input, awaited);
+                return completePromiseInternal(awaited);
+            }
+            // --- In any other cases, we keep the input reference
+            visited.set(input, input);
+            // --- Resolve promises within an array
+            if (Array.isArray(input)) {
+                for (let i = 0; i < input.length; i++) {
+                    const completedPromise = yield completePromiseInternal(input[i]);
+                    if (input[i] !== completedPromise) {
+                        //prevent write if it's the same reference (can cause problems in frozen objects)
+                        input.splice(i, 1, completedPromise);
                     }
-                    return input;
                 }
-                // --- Resolve promises in object properties
-                if ((0, lodash_es_1.isPlainObject)(input)) {
-                    for (const key of Object.keys(input)) {
-                        let completedPromise = yield completePromiseInternal(input[key]);
-                        if (input[key] !== completedPromise) {
-                            //prevent write if it's the same reference (can cause problems in frozen objects)
-                            input[key] = completedPromise;
-                        }
+                return input;
+            }
+            // --- Resolve promises in object properties
+            if ((0, lodash_es_1.isPlainObject)(input)) {
+                for (const key of Object.keys(input)) {
+                    let completedPromise = yield completePromiseInternal(input[key]);
+                    if (input[key] !== completedPromise) {
+                        //prevent write if it's the same reference (can cause problems in frozen objects)
+                        input[key] = completedPromise;
                     }
-                    return input;
                 }
-                // --- Done.
                 return input;
-            });
-        }
-    });
+            }
+            // --- Done.
+            return input;
+        });
+    }
 }
 function evalTemplateLiteralAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {

package/dist/scripts/src/components-core/script-runner/eval-tree-sync.js

@@ -272,7 +272,7 @@ function evalAssignment(evaluator, thisStack, expr, evalContext, thread) {
     const rootScope = (0, eval_tree_common_1.getRootIdScope)(leftValue, evalContext, thread);
     const updatesState = rootScope && rootScope.type !== "block";
     if (updatesState && evalContext.onWillUpdate) {
-        evalContext.onWillUpdate(rootScope, rootScope.name, "assignment");
+        void evalContext.onWillUpdate(rootScope, rootScope.name, "assignment");
     }
     evaluator(thisStack, leftValue, evalContext, thread);
     thisStack.pop();
@@ -280,7 +280,7 @@ function evalAssignment(evaluator, thisStack, expr, evalContext, thread) {
     thisStack.pop();
     const value = (0, eval_tree_common_1.evalAssignmentCore)(thisStack, expr, evalContext, thread);
     if (updatesState && evalContext.onDidUpdate) {
-        evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
+        void evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
     }
     return value;
 }
@@ -288,13 +288,13 @@ function evalPreOrPost(evaluator, thisStack, expr, evalContext, thread) {
     const rootScope = (0, eval_tree_common_1.getRootIdScope)(expr.expr, evalContext, thread);
     const updatesState = rootScope && rootScope.type !== "block";
     if (updatesState && evalContext.onWillUpdate) {
-        evalContext.onWillUpdate(rootScope, rootScope.name, "pre-post");
+        void evalContext.onWillUpdate(rootScope, rootScope.name, "pre-post");
     }
     evaluator(thisStack, expr.expr, evalContext, thread);
     thisStack.pop();
     const value = (0, eval_tree_common_1.evalPreOrPostCore)(thisStack, expr, evalContext, thread);
     if (updatesState && evalContext.onDidUpdate) {
-        evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
+        void evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
     }
     return value;
 }
@@ -380,13 +380,13 @@ function evalFunctionInvocation(evaluator, thisStack, expr, evalContext, thread)
     const rootScope = (0, eval_tree_common_1.getRootIdScope)(expr.obj, evalContext, thread);
     const updatesState = rootScope && rootScope.type !== "block";
     if (updatesState && evalContext.onWillUpdate) {
-        evalContext.onWillUpdate(rootScope, rootScope.name, "function-call");
+        void evalContext.onWillUpdate(rootScope, rootScope.name, "function-call");
     }
     const value = ((_d = evalContext.options) === null || _d === void 0 ? void 0 : _d.defaultToOptionalMemberAccess)
         ? functionObj === null || functionObj === void 0 ? void 0 : functionObj.call(currentContext, ...functionArgs)
         : functionObj.call(currentContext, ...functionArgs);
     if (updatesState && evalContext.onDidUpdate) {
-        evalContext.onDidUpdate(rootScope, rootScope.name, "function-call");
+        void evalContext.onDidUpdate(rootScope, rootScope.name, "function-call");
     }
     (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
     thisStack.push(value);

package/dist/scripts/src/components-core/script-runner/process-statement-sync.js

@@ -46,7 +46,7 @@ function processStatementQueue(statements, evalContext, thread) {
         let outcome;
         try {
             // --- Sign that the statement is about to start
-            (_a = evalContext === null || evalContext === void 0 ? void 0 : evalContext.onStatementStarted) === null || _a === void 0 ? void 0 : _a.call(evalContext, evalContext, queueItem.statement);
+            void ((_a = evalContext === null || evalContext === void 0 ? void 0 : evalContext.onStatementStarted) === null || _a === void 0 ? void 0 : _a.call(evalContext, evalContext, queueItem.statement));
             // --- Execute the statement
             outcome = processStatement(queueItem.statement, (_b = queueItem.execInfo) !== null && _b !== void 0 ? _b : {}, evalContext, thread);
         }
@@ -85,7 +85,7 @@ function processStatementQueue(statements, evalContext, thread) {
             }
         }
         // --- Sign that the statement has been completed
-        (_c = evalContext === null || evalContext === void 0 ? void 0 : evalContext.onStatementCompleted) === null || _c === void 0 ? void 0 : _c.call(evalContext, evalContext, queueItem.statement);
+        void ((_c = evalContext === null || evalContext === void 0 ? void 0 : evalContext.onStatementCompleted) === null || _c === void 0 ? void 0 : _c.call(evalContext, evalContext, queueItem.statement));
         // --- Provide diagnostics
         if (queue.length > diagInfo.maxQueueLength) {
             diagInfo.maxQueueLength = queue.length;

package/dist/scripts/src/components-core/utils/actionUtils.js

@@ -22,7 +22,7 @@ function invalidateQueries(invalidates, appContext, state) {
             }
             arrayToInvalidate.forEach((invalidate) => {
                 var _a;
-                (_a = appContext.queryClient) === null || _a === void 0 ? void 0 : _a.invalidateQueries(new DataLoaderQueryKeyGenerator_1.DataLoaderQueryKeyGenerator((0, extractParam_1.extractParam)(state, invalidate, appContext), undefined, appContext === null || appContext === void 0 ? void 0 : appContext.appGlobals.apiUrl, undefined, undefined).asPredicate());
+                void ((_a = appContext.queryClient) === null || _a === void 0 ? void 0 : _a.invalidateQueries(new DataLoaderQueryKeyGenerator_1.DataLoaderQueryKeyGenerator((0, extractParam_1.extractParam)(state, invalidate, appContext), undefined, appContext === null || appContext === void 0 ? void 0 : appContext.appGlobals.apiUrl, undefined, undefined).asPredicate()));
             });
         }
         else {

package/dist/scripts/src/components-core/utils/hooks.js

@@ -320,7 +320,7 @@ const useRealBackground = (element) => {
     (0, react_1.useEffect)(() => {
         return setCounter((prev) => prev + 1);
     }, [activeThemeTone, activeThemeId]);
-    return (0, react_1.useMemo)(() => (element ? realBackgroundColor(element) : "transparent"), [element, counter]);
+    return (0, react_1.useMemo)(() => (element ? realBackgroundColor(element) : "transparent"), [element]);
 };
 exports.useRealBackground = useRealBackground;
 // export const useIsInViewport = (ref, observerOptions) => {

package/dist/scripts/src/components-core/utils/misc.js

@@ -70,10 +70,10 @@ function randomUUID() {
 }
 function readCookie(name) {
     const nameEQ = name + "=";
-    const ca = document.cookie.split(';');
+    const ca = document.cookie.split(";");
     for (let i = 0; i < ca.length; i++) {
         let c = ca[i];
-        while (c.charAt(0) === ' ')
+        while (c.charAt(0) === " ")
             c = c.substring(1, c.length);
         if (c.indexOf(nameEQ) === 0)
             return c.substring(nameEQ.length, c.length);
@@ -466,7 +466,7 @@ function toHashObject(arr, keyProp, valueProp) {
     }, {});
 }
 function findByField(arr, field, value) {
-    return (arr !== null && arr !== void 0 ? arr : []).find(item => item[field || ""] === value);
+    return (arr !== null && arr !== void 0 ? arr : []).find((item) => item[field || ""] === value);
 }
 function distinct(arr) {
     if (!Array.isArray(arr) || !arr || !arr.length) {
@@ -485,7 +485,7 @@ function distinct(arr) {
  */
 function asyncThrottle(func, wait, options) {
     const throttled = (0, lodash_es_1.throttle)((resolve, reject, args) => {
-        func(...args)
+        void func(...args)
             .then(resolve)
             .catch(reject);
     }, wait, options);