@lowdefy/engine 4.0.0-alpha.1 → 4.0.0-alpha.10

package/dist/Actions.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2021 Lowdefy, Inc
+  Copyright 2020-2022 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -13,7 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
-import actions from './actions/index.js';
+import getActionMethods from './actions/getActionMethods.js';
 let Actions = class Actions {
     async callAsyncAction({ action , arrayIndices , block , event , index , responses  }) {
         try {
@@ -31,31 +31,33 @@ let Actions = class Actions {
             console.error(error);
         }
     }
-    async callActionLoop({ actions: actions1 , arrayIndices: arrayIndices1 , block: block1 , event: event1 , responses: responses1  }) {
-        for (const [index, action] of actions1.entries()){
+    async callActionLoop({ actions , arrayIndices , block , event , progress , responses  }) {
+        for (const [index, action] of actions.entries()){
             try {
                 if (action.async === true) {
                     this.callAsyncAction({
                         action,
-                        arrayIndices: arrayIndices1,
-                        block: block1,
-                        event: event1,
+                        arrayIndices,
+                        block,
+                        event,
                         index,
-                        responses: responses1
+                        progress,
+                        responses
                     });
                 } else {
                     const response = await this.callAction({
                         action,
-                        arrayIndices: arrayIndices1,
-                        block: block1,
-                        event: event1,
+                        arrayIndices,
+                        block,
+                        event,
                         index,
-                        responses: responses1
+                        progress,
+                        responses
                     });
-                    responses1[action.id] = response;
+                    responses[action.id] = response;
                 }
             } catch (error) {
-                responses1[action.id] = error;
+                responses[action.id] = error;
                 throw {
                     error,
                     action
@@ -63,37 +65,38 @@ let Actions = class Actions {
             }
         }
     }
-    async callActions({ actions: actions2 , arrayIndices: arrayIndices2 , block: block2 , catchActions , event: event2 , eventName  }) {
+    async callActions({ actions , arrayIndices , block , catchActions , event , eventName , progress  }) {
         const startTimestamp = new Date();
-        const responses = {
-        };
+        const responses = {};
         try {
             await this.callActionLoop({
-                actions: actions2,
-                arrayIndices: arrayIndices2,
-                block: block2,
-                event: event2,
-                responses
+                actions,
+                arrayIndices,
+                block,
+                event,
+                responses,
+                progress
             });
         } catch (error) {
             console.error(error);
             try {
                 await this.callActionLoop({
                     actions: catchActions,
-                    arrayIndices: arrayIndices2,
-                    block: block2,
-                    event: event2,
-                    responses
+                    arrayIndices,
+                    block,
+                    event,
+                    responses,
+                    progress
                 });
             } catch (errorCatch) {
                 console.error(errorCatch);
                 return {
-                    blockId: block2.blockId,
+                    blockId: block.blockId,
                     bounced: false,
                     endTimestamp: new Date(),
                     error,
                     errorCatch,
-                    event: event2,
+                    event,
                     eventName,
                     responses,
                     startTimestamp,
@@ -101,11 +104,11 @@ let Actions = class Actions {
                 };
             }
             return {
-                blockId: block2.blockId,
+                blockId: block.blockId,
                 bounced: false,
                 endTimestamp: new Date(),
                 error,
-                event: event2,
+                event,
                 eventName,
                 responses,
                 startTimestamp,
@@ -113,47 +116,46 @@ let Actions = class Actions {
             };
         }
         return {
-            blockId: block2.blockId,
+            blockId: block.blockId,
             bounced: false,
             endTimestamp: new Date(),
-            event: event2,
+            event,
             eventName,
             responses,
             startTimestamp,
             success: true
         };
     }
-    async callAction({ action: action1 , arrayIndices: arrayIndices3 , block: block3 , event: event3 , index: index1 , responses: responses2  }) {
-        if (!actions[action1.type]) {
+    async callAction({ action , arrayIndices , block , event , index , progress , responses  }) {
+        if (!this.actions[action.type]) {
             throw {
-                error: new Error(`Invalid action type "${action1.type}" at "${block3.blockId}".`),
-                type: action1.type,
-                index: index1
+                error: new Error(`Invalid action type "${action.type}" at "${block.blockId}".`),
+                type: action.type,
+                index
             };
         }
         const { output: parsedAction , errors: parserErrors  } = this.context._internal.parser.parse({
-            actions: responses2,
-            event: event3,
-            arrayIndices: arrayIndices3,
-            input: action1,
-            location: block3.blockId
+            actions: responses,
+            event,
+            arrayIndices,
+            input: action,
+            location: block.blockId
         });
         if (parserErrors.length > 0) {
             throw {
                 error: parserErrors[0],
-                type: action1.type,
-                index: index1
+                type: action.type,
+                index
             };
         }
         if (parsedAction.skip === true) {
             return {
-                type: action1.type,
+                type: action.type,
                 skipped: true,
-                index: index1
+                index
             };
         }
-        const messages = parsedAction.messages || {
-        };
+        const messages = parsedAction.messages || {};
         let response;
         const closeLoading = this.displayMessage({
             defaultMessage: 'Loading',
@@ -162,32 +164,40 @@ let Actions = class Actions {
             status: 'loading'
         });
         try {
-            response = await actions[action1.type]({
-                arrayIndices: arrayIndices3,
-                blockId: block3.blockId,
-                context: this.context,
-                event: event3,
-                params: parsedAction.params
+            response = await this.actions[action.type]({
+                methods: getActionMethods({
+                    actions: responses,
+                    arrayIndices,
+                    blockId: block.blockId,
+                    context: this.context,
+                    event
+                }),
+                document: this.context._internal.lowdefy._internal.document,
+                params: parsedAction.params,
+                window: this.context._internal.lowdefy._internal.window
             });
+            if (progress) {
+                progress();
+            }
         } catch (error) {
-            responses2[action1.id] = {
+            responses[action.id] = {
                 error,
-                index: index1,
-                type: action1.type
+                index,
+                type: action.type
             };
             const { output: parsedMessages , errors: parserErrors  } = this.context._internal.parser.parse({
-                actions: responses2,
-                event: event3,
-                arrayIndices: arrayIndices3,
-                input: action1.messages,
-                location: block3.blockId
+                actions: responses,
+                event,
+                arrayIndices,
+                input: action.messages,
+                location: block.blockId
             });
             if (parserErrors.length > 0) {
                 // this condition is very unlikely since parser errors usually occur in the first parse.
                 throw {
                     error: parserErrors[0],
-                    type: action1.type,
-                    index: index1
+                    type: action.type,
+                    index
                 };
             }
             closeLoading();
@@ -195,14 +205,13 @@ let Actions = class Actions {
                 defaultMessage: error.message,
                 duration: 6,
                 hideExplicitly: true,
-                message: (parsedMessages || {
-                }).error,
+                message: (parsedMessages || {}).error,
                 status: 'error'
             });
             throw {
-                type: action1.type,
+                type: action.type,
                 error,
-                index: index1
+                index
             };
         }
         closeLoading();
@@ -212,9 +221,9 @@ let Actions = class Actions {
             status: 'success'
         });
         return {
-            type: action1.type,
+            type: action.type,
             response,
-            index: index1
+            index
         };
     }
     displayMessage({ defaultMessage , duration , hideExplicitly , message , status  }) {
@@ -235,7 +244,7 @@ let Actions = class Actions {
         this.callActionLoop = this.callActionLoop.bind(this);
         this.callActions = this.callActions.bind(this);
         this.displayMessage = this.displayMessage.bind(this);
-        this.actions = actions;
+        this.actions = context._internal.lowdefy._internal.actions;
     }
 };
 export default Actions;

package/dist/Blocks.js

@@ -1,5 +1,5 @@
 /* eslint-disable no-param-reassign */ /*
-  Copyright 2020-2021 Lowdefy, Inc
+  Copyright 2020-2022 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -14,7 +14,6 @@
   limitations under the License.
 */ import { applyArrayIndices, get, serializer, swap, type } from '@lowdefy/helpers';
 import Events from './Events.js';
-import getFieldValues from './getFieldValues.js';
 let Blocks = class Blocks {
     loopBlocks(fn) {
         if (type.isObject(this.areas)) {
@@ -34,35 +33,31 @@ let Blocks = class Blocks {
             block.blockId = applyArrayIndices(this.arrayIndices, block.blockIdPattern);
             block.field = !type.isNone(block.fieldPattern) ? applyArrayIndices(this.arrayIndices, block.fieldPattern) : block.blockId;
             this.context._internal.RootBlocks.map[block.id] = block;
-            block.visible = type.isNone(block.visible) ? true : block.visible;
+            block.events = type.isNone(block.events) ? {} : block.events;
+            block.layout = type.isNone(block.layout) ? {} : block.layout;
+            block.loading = type.isNone(block.loading) ? false : block.loading;
+            block.properties = type.isNone(block.properties) ? {} : block.properties;
             block.required = type.isNone(block.required) ? false : block.required;
-            block.validate = type.isArray(block.validate) ? block.validate : [];
-            block.properties = type.isNone(block.properties) ? {
-            } : block.properties;
-            block.style = type.isNone(block.style) ? {
-            } : block.style;
-            block.layout = type.isNone(block.layout) ? {
-            } : block.layout;
-            block.events = type.isNone(block.events) ? {
-            } : block.events;
-            block.areasLayoutEval = {
-            };
-            block.layoutEval = {
-            };
-            block.propertiesEval = {
-            };
-            block.requiredEval = {
-            };
-            block.styleEval = {
-            };
-            block.validationEval = {
-            };
-            block.visibleEval = {
-            };
-            block.meta = this.context._internal.lowdefy._internal.blockComponents[block.type].meta;
+            block.skeleton = type.isNone(block.skeleton) ? null : block.skeleton;
+            block.style = type.isNone(block.style) ? {} : block.style;
+            block.validate = type.isNone(block.validate) ? [] : block.validate;
+            block.visible = type.isNone(block.visible) ? true : block.visible;
+            block.areasLayoutEval = {};
+            block.layoutEval = {};
+            block.loadingEval = {};
+            block.propertiesEval = {};
+            block.requiredEval = {};
+            block.skeletonEval = {};
+            block.styleEval = {};
+            block.validationEval = {};
+            block.visibleEval = {};
+            try {
+                block.meta = this.context._internal.lowdefy._internal.blockComponents[block.type].meta;
+            } catch (error) {
+                throw new Error(`Block type ${block.type} not found at ${block.blockId}. Check your plugins to make sure the block is installed. For more info, see https://docs.lowdefy.com/plugins.`);
+            }
             if (!type.isNone(block.areas)) {
-                block.areasLayout = {
-                };
+                block.areasLayout = {};
                 Object.keys(block.areas).forEach((key)=>{
                     // eslint-disable-next-line no-unused-vars
                     const { blocks , ...areaLayout } = block.areas[key];
@@ -71,12 +66,9 @@ let Blocks = class Blocks {
                     };
                 });
             } else {
-                block.areasLayout = {
-                };
+                block.areasLayout = {};
             }
-            block.requestKeys = getFieldValues('_request', block.style, block.properties, block.validate, block.visible, block.required);
-            block.methods = {
-            };
+            block.methods = {};
             block.registerMethod = (methodName, method)=>{
                 block.methods[methodName] = method;
             };
@@ -96,8 +88,7 @@ let Blocks = class Blocks {
                             0
                         ]),
                         block,
-                        initState: {
-                        }
+                        initState: {}
                     }));
                     this.context._internal.State.set(block.field, undefined);
                     // set block and subBlock values undefined, so as not to pass values to new blocks
@@ -111,8 +102,7 @@ let Blocks = class Blocks {
                             this.subBlocks[block.id].length
                         ]),
                         block,
-                        initState: {
-                        }
+                        initState: {}
                     }));
                     block.update = true;
                     this.context._internal.update();
@@ -238,26 +228,28 @@ let Blocks = class Blocks {
             }
         });
     }
-    newBlocks({ arrayIndices , block: block2 , initState: initState1  }) {
+    newBlocks({ arrayIndices , block , initState  }) {
         const SubBlocks = new Blocks({
             arrayIndices,
-            areas: block2.areas,
+            areas: block.areas,
             context: this.context
         });
-        SubBlocks.init(initState1);
+        SubBlocks.init(initState);
         return SubBlocks;
     }
     // used for update comparison
-    static blockEvalToString(block1) {
+    static blockEvalToString(block) {
         return serializer.serializeToString({
-            areasLayoutEval: block1.areasLayoutEval,
-            layoutEval: block1.layoutEval,
-            propertiesEval: block1.propertiesEval,
-            requiredEval: block1.requiredEval,
-            styleEval: block1.styleEval,
-            validationEval: block1.validationEval,
-            value: block1.value,
-            visibleEval: block1.visibleEval
+            areasLayoutEval: block.areasLayoutEval,
+            layoutEval: block.layoutEval,
+            loadingEval: block.loadingEval,
+            propertiesEval: block.propertiesEval,
+            requiredEval: block.requiredEval,
+            skeletonEval: block.skeletonEval,
+            styleEval: block.styleEval,
+            validationEval: block.validationEval,
+            value: block.value,
+            visibleEval: block.visibleEval
         });
     }
     recEval(visibleParent) {
@@ -362,6 +354,16 @@ let Blocks = class Blocks {
                     location: block.blockId,
                     arrayIndices: this.arrayIndices
                 });
+                block.loadingEval = this.context._internal.parser.parse({
+                    input: block.loading,
+                    location: block.blockId,
+                    arrayIndices: this.arrayIndices
+                });
+                block.skeletonEval = this.context._internal.parser.parse({
+                    input: block.skeleton,
+                    location: block.blockId,
+                    arrayIndices: this.arrayIndices
+                });
                 block.areasLayoutEval = this.context._internal.parser.parse({
                     input: block.areasLayout,
                     location: block.blockId,
@@ -490,27 +492,27 @@ let Blocks = class Blocks {
             });
         });
     }
-    validate(match1) {
+    validate(match) {
         this.updateStateFromRoot(); // update to recalculate validationEval to raise block errors
-        const validationErrors = this.getValidateRec(match1, []); // get all relevant raised block errors and set showValidation
+        const validationErrors = this.getValidateRec(match, []); // get all relevant raised block errors and set showValidation
         this.setBlocksCache(); // update cache to render
         return validationErrors;
     }
-    resetValidationRec(match2) {
+    resetValidationRec(match) {
         this.loopBlocks((block)=>{
-            if (match2(block.blockId)) {
+            if (match(block.blockId)) {
                 block.showValidation = false;
                 block.update = true;
             }
         });
         Object.keys(this.subBlocks).forEach((subKey)=>{
             this.subBlocks[subKey].forEach((subBlock)=>{
-                subBlock.resetValidationRec(match2);
+                subBlock.resetValidationRec(match);
             });
         });
     }
-    resetValidation(match3) {
-        this.resetValidationRec(match3);
+    resetValidation(match) {
+        this.resetValidationRec(match);
         this.setBlocksCache();
     }
     update() {
@@ -521,20 +523,18 @@ let Blocks = class Blocks {
         this.loopBlocks((block)=>{
             if (block.update) {
                 block.update = false;
-                block.loading = block.requestKeys.reduce((acc, key)=>acc || (this.context.requests[key] ? this.context.requests[key].loading : true)
-                , false);
                 block.eval = {
                     areas: block.areasLayoutEval.output,
                     events: type.isNone(block.Events.events) ? null : block.Events.events,
                     properties: block.propertiesEval.output,
+                    loading: block.loadingEval.output,
+                    skeleton: block.skeletonEval.output,
                     required: block.requiredEval.output,
                     layout: block.layoutEval.output,
                     style: block.styleEval.output,
                     validation: {
-                        ...block.validationEval.output || {
-                        },
-                        status: block.showValidation ? (block.validationEval.output || {
-                        }).status : null
+                        ...block.validationEval.output || {},
+                        status: block.showValidation ? (block.validationEval.output || {}).status : null
                     },
                     value: type.isNone(block.value) ? null : block.value,
                     visible: block.visibleEval.output
@@ -548,31 +548,14 @@ let Blocks = class Blocks {
             });
         });
     }
-    setBlocksLoadingCache() {
-        this.loopBlocks((block)=>{
-            block.loading_prev = block.loading;
-            block.loading = block.requestKeys.reduce((acc, key)=>acc || (this.context.requests[key] ? this.context.requests[key].loading : true)
-            , false);
-            if (block.loading_prev !== block.loading) {
-                this.context._internal.lowdefy._internal.updateBlock(block.id);
-            }
-        });
-        Object.keys(this.subBlocks).forEach((subKey)=>{
-            this.subBlocks[subKey].forEach((subBlock)=>{
-                subBlock.setBlocksLoadingCache();
-            });
-        });
-    }
-    constructor({ arrayIndices: arrayIndices1 , areas , context  }){
+    constructor({ arrayIndices , areas , context  }){
         this.id = Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 5);
         this.areas = serializer.copy(areas || []);
-        this.arrayIndices = type.isArray(arrayIndices1) ? arrayIndices1 : [];
+        this.arrayIndices = type.isArray(arrayIndices) ? arrayIndices : [];
         this.context = context;
-        this.map = {
-        };
+        this.map = {};
         this.recCount = 0;
-        this.subBlocks = {
-        };
+        this.subBlocks = {};
         this.getValidateRec = this.getValidateRec.bind(this);
         this.init = this.init.bind(this);
         this.newBlocks = this.newBlocks.bind(this);
@@ -585,7 +568,6 @@ let Blocks = class Blocks {
         this.resetValidation = this.resetValidation.bind(this);
         this.resetValidationRec = this.resetValidationRec.bind(this);
         this.setBlocksCache = this.setBlocksCache.bind(this);
-        this.setBlocksLoadingCache = this.setBlocksLoadingCache.bind(this);
         this.update = this.update.bind(this);
         this.updateState = this.updateState.bind(this);
         this.updateStateFromRoot = this.updateStateFromRoot.bind(this);

package/dist/Events.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2021 Lowdefy, Inc
+  Copyright 2020-2022 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -28,17 +28,16 @@ let Events = class Events {
             this.events[eventName] = this.initEvent(this.block.events[eventName]);
         });
     }
-    registerEvent({ name , actions: actions1  }) {
-        this.events[name] = this.initEvent(actions1);
+    registerEvent({ name , actions  }) {
+        this.events[name] = this.initEvent(actions);
     }
-    async triggerEvent({ name: name1 , event  }) {
-        const eventDescription = this.events[name1];
+    async triggerEvent({ name , event , progress  }) {
+        const eventDescription = this.events[name];
         let result = {
             blockId: this.block.blockId,
             event,
-            eventName: name1,
-            responses: {
-            },
+            eventName: name,
+            responses: {},
             endTimestamp: new Date(),
             startTimestamp: new Date(),
             success: true,
@@ -58,7 +57,8 @@ let Events = class Events {
                 block: this.block,
                 catchActions: eventDescription.catchActions,
                 event,
-                eventName: name1
+                eventName: name,
+                progress
             });
             eventDescription.history.unshift(res);
             this.context.eventLog.unshift(res);
@@ -73,7 +73,7 @@ let Events = class Events {
         }
         const delay = !type.isNone(eventDescription.debounce.ms) ? eventDescription.debounce.ms : this.defaultDebounceMs;
         // leading edge: bounce
-        if (this.timeouts[name1] && eventDescription.debounce.immediate === true) {
+        if (this.timeouts[name] && eventDescription.debounce.immediate === true) {
             result.bounced = true;
             eventDescription.history.unshift(result);
             this.context.eventLog.unshift(result);
@@ -81,8 +81,8 @@ let Events = class Events {
         }
         // leading edge: trigger
         if (eventDescription.debounce.immediate === true) {
-            this.timeouts[name1] = setTimeout(()=>{
-                this.timeouts[name1] = null;
+            this.timeouts[name] = setTimeout(()=>{
+                this.timeouts[name] = null;
             }, delay);
             return actionHandle();
         }
@@ -107,10 +107,8 @@ let Events = class Events {
     }
     constructor({ arrayIndices , block , context  }){
         this.defaultDebounceMs = 300;
-        this.events = {
-        };
-        this.timeouts = {
-        };
+        this.events = {};
+        this.timeouts = {};
         this.arrayIndices = arrayIndices;
         this.block = block;
         this.context = context;