@lowdefy/engine 5.0.0 → 5.2.0

package/dist/Block.js

@@ -171,8 +171,28 @@ let Block = class Block {
             if (this.isInput() || this.isList()) {
                 let blockValue = get(initWithState, this.blockId);
                 if (type.isUndefined(blockValue)) {
-                    blockValue = type.isUndefined(this.meta.initValue) ? type.enforceType(this.meta.valueType, null) : this.meta.initValue;
-                    this.context._internal.State.set(this.blockId, blockValue);
+                    // If the block was hidden in the previous eval cycle, Slots.updateState
+                    // deleted its state field. Without this guard, every SetState would
+                    // wipe the in-memory value back to the enforceType default. The next
+                    // updateState republishes this.value (inputs) or sub-block state
+                    // (lists) when the block becomes visible, or leaves the field deleted
+                    // if it stays hidden. This makes SetState-driven visibility toggles
+                    // consistent with setValue-driven toggles.
+                    const wasInvisible = this.visibleEval && this.visibleEval.output === false;
+                    const inputHasValue = this.isInput() && !type.isUndefined(this.value);
+                    const listHasSubSlots = this.isList() && type.isArray(this.subSlots) && this.subSlots.length > 0;
+                    if (wasInvisible && (inputHasValue || listHasSubSlots)) {
+                        // For inputs, reuse this.value below.
+                        // For lists, leave blockValue undefined so the rebuild loop skips
+                        // (preserving subSlots). Sub-block this.value stays in memory and
+                        // is republished by updateState once the list becomes visible.
+                        if (inputHasValue) {
+                            blockValue = this.value;
+                        }
+                    } else {
+                        blockValue = type.isUndefined(this.meta.initValue) ? type.enforceType(this.meta.valueType, null) : this.meta.initValue;
+                        this.context._internal.State.set(this.blockId, blockValue);
+                    }
                 }
                 if (this.isList()) {
                     if (!type.isArray(this.subSlots)) {

package/dist/Requests.js

@@ -16,31 +16,47 @@
 let Requests = class Requests {
     callRequests({ actionId, actions, arrayIndices, blockId, event, params } = {}) {
         if (type.isObject(params) && params.all === true) {
+            const { holdValue } = params;
             return Promise.all(Object.keys(this.requestConfig).map((requestId)=>this.callRequest({
                     actionId,
                     arrayIndices,
                     blockId,
                     event,
+                    holdValue,
                     requestId
                 })));
         }
         let requestIds = [];
-        if (type.isString(params)) requestIds = [
-            params
-        ];
-        if (type.isArray(params)) requestIds = params;
+        let holdValue;
+        if (type.isString(params)) {
+            requestIds = [
+                params
+            ];
+        } else if (type.isArray(params)) {
+            requestIds = params;
+        } else if (type.isObject(params)) {
+            holdValue = params.holdValue;
+            if (type.isString(params.requestId)) {
+                requestIds = [
+                    params.requestId
+                ];
+            } else if (type.isArray(params.requestIds)) {
+                requestIds = params.requestIds;
+            }
+        }
         const requests = requestIds.map((requestId)=>this.callRequest({
                 actionId,
                 actions,
                 requestId,
                 blockId,
                 event,
-                arrayIndices
+                arrayIndices,
+                holdValue
             }));
         this.context._internal.update(); // update to render request reset
         return Promise.all(requests);
     }
-    async callRequest({ actionId, actions, arrayIndices, blockId, event, requestId }) {
+    async callRequest({ actionId, actions, arrayIndices, blockId, event, holdValue, requestId }) {
         const requestConfig = this.requestConfig[requestId];
         if (!this.context.requests[requestId]) {
             this.context.requests[requestId] = [];
@@ -67,14 +83,18 @@ let Requests = class Requests {
         if (parserErrors.length > 0) {
             throw parserErrors[0];
         }
+        const previousResponse = this.context.requests[requestId][0]?.response ?? null;
         const request = {
             actionId,
             blockId,
             loading: true,
             payload,
             requestId,
-            response: null
+            response: holdValue ? previousResponse : null
         };
+        if (holdValue) {
+            request.holdValue = true;
+        }
         this.context.requests[requestId].unshift(request);
         return this.fetch(request);
     }

package/dist/callAPIHandler.js

@@ -17,6 +17,8 @@ async function callAPIHandler(context, { blockId, params }) {
     if (!context._internal.lowdefy.apiResponses[params.endpointId]) {
         context._internal.lowdefy.apiResponses[params.endpointId] = [];
     }
+    const holdValue = params.holdValue === true;
+    const previousResponse = context._internal.lowdefy.apiResponses[params.endpointId][0]?.response ?? null;
     const api = {
         ...params,
         blockId,
@@ -26,6 +28,10 @@ async function callAPIHandler(context, { blockId, params }) {
         startTimestamp: new Date(),
         endTimestamp: null
     };
+    if (holdValue) {
+        api.holdValue = true;
+        api.response = previousResponse;
+    }
     context._internal.lowdefy.apiResponses[api.endpointId].unshift(api);
     let apiResponse;
     try {
@@ -38,7 +44,9 @@ async function callAPIHandler(context, { blockId, params }) {
     } catch (error) {
         api.error = error;
         api.loading = false;
-        api.response = null;
+        if (!holdValue) {
+            api.response = null;
+        }
         api.status = 'error';
         api.success = false;
         api.endTimestamp = new Date();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/engine",
-  "version": "5.0.0",
+  "version": "5.2.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -30,16 +30,16 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/errors": "5.0.0",
-    "@lowdefy/helpers": "5.0.0",
-    "@lowdefy/operators": "5.0.0"
+    "@lowdefy/errors": "5.2.0",
+    "@lowdefy/helpers": "5.2.0",
+    "@lowdefy/operators": "5.2.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@lowdefy/actions-core": "5.0.0",
-    "@lowdefy/build": "5.0.0",
-    "@lowdefy/operators-js": "5.0.0",
-    "@lowdefy/operators-mql": "5.0.0",
+    "@lowdefy/actions-core": "5.2.0",
+    "@lowdefy/build": "5.2.0",
+    "@lowdefy/operators-js": "5.2.0",
+    "@lowdefy/operators-mql": "5.2.0",
     "@swc/cli": "0.8.0",
     "@swc/core": "1.15.18",
     "@swc/jest": "0.2.39",