@lowdefy/engine 4.0.0-alpha.5 → 4.0.0-alpha.8

package/dist/Actions.js

@@ -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,31 @@ 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 , 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
+                        responses
                     });
                 } else {
                     const response = await this.callAction({
                         action,
-                        arrayIndices: arrayIndices1,
-                        block: block1,
-                        event: event1,
+                        arrayIndices,
+                        block,
+                        event,
                         index,
-                        responses: responses1
+                        responses
                     });
-                    responses1[action.id] = response;
+                    responses[action.id] = response;
                 }
             } catch (error) {
-                responses1[action.id] = error;
+                responses[action.id] = error;
                 throw {
                     error,
                     action
@@ -63,16 +63,15 @@ let Actions = class Actions {
             }
         }
     }
-    async callActions({ actions: actions2 , arrayIndices: arrayIndices2 , block: block2 , catchActions , event: event2 , eventName  }) {
+    async callActions({ actions , arrayIndices , block , catchActions , event , eventName  }) {
         const startTimestamp = new Date();
-        const responses = {
-        };
+        const responses = {};
         try {
             await this.callActionLoop({
-                actions: actions2,
-                arrayIndices: arrayIndices2,
-                block: block2,
-                event: event2,
+                actions,
+                arrayIndices,
+                block,
+                event,
                 responses
             });
         } catch (error) {
@@ -80,20 +79,20 @@ let Actions = class Actions {
             try {
                 await this.callActionLoop({
                     actions: catchActions,
-                    arrayIndices: arrayIndices2,
-                    block: block2,
-                    event: event2,
+                    arrayIndices,
+                    block,
+                    event,
                     responses
                 });
             } 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 +100,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 +112,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 , 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 +160,37 @@ 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
             });
         } 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 +198,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 +214,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 +237,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

@@ -37,32 +37,20 @@ let Blocks = class Blocks {
             block.visible = type.isNone(block.visible) ? true : block.visible;
             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.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;
             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 +59,10 @@ 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 +82,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 +96,7 @@ let Blocks = class Blocks {
                             this.subBlocks[block.id].length
                         ]),
                         block,
-                        initState: {
-                        }
+                        initState: {}
                     }));
                     block.update = true;
                     this.context._internal.update();
@@ -238,26 +222,26 @@ 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,
+            propertiesEval: block.propertiesEval,
+            requiredEval: block.requiredEval,
+            styleEval: block.styleEval,
+            validationEval: block.validationEval,
+            value: block.value,
+            visibleEval: block.visibleEval
         });
     }
     recEval(visibleParent) {
@@ -490,27 +474,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() {
@@ -531,10 +515,8 @@ let Blocks = class Blocks {
                     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
@@ -563,16 +545,14 @@ let Blocks = class Blocks {
             });
         });
     }
-    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);

package/dist/Events.js

@@ -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  }) {
+        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,7 @@ let Events = class Events {
                 block: this.block,
                 catchActions: eventDescription.catchActions,
                 event,
-                eventName: name1
+                eventName: name
             });
             eventDescription.history.unshift(res);
             this.context.eventLog.unshift(res);
@@ -73,7 +72,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 +80,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 +106,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;

package/dist/Requests.js

@@ -14,9 +14,8 @@
   limitations under the License.
 */ import { get, serializer, type } from '@lowdefy/helpers';
 let Requests = class Requests {
-    callRequests({ actions , arrayIndices , event , params  } = {
-    }) {
-        if (params.all === true) {
+    callRequests({ actions , arrayIndices , event , params  } = {}) {
+        if (type.isObject(params) && params.all === true) {
             return Promise.all(Object.keys(this.requestConfig).map((requestId)=>this.callRequest({
                     requestId,
                     event,
@@ -37,7 +36,7 @@ let Requests = class Requests {
             })
         ));
     }
-    callRequest({ actions: actions1 , arrayIndices: arrayIndices1 , event: event1 , requestId  }) {
+    callRequest({ actions , arrayIndices , event , requestId  }) {
         const request = this.requestConfig[requestId];
         if (!request) {
             const error = new Error(`Configuration Error: Request ${requestId} not defined on page.`);
@@ -58,9 +57,9 @@ let Requests = class Requests {
             };
         }
         const { output: payload , errors: parserErrors  } = this.context._internal.parser.parse({
-            actions: actions1,
-            event: event1,
-            arrayIndices: arrayIndices1,
+            actions,
+            event,
+            arrayIndices,
             input: request.payload,
             location: requestId
         });
@@ -73,8 +72,8 @@ let Requests = class Requests {
             payload
         });
     }
-    async fetch({ requestId: requestId1 , payload  }) {
-        this.context.requests[requestId1].loading = true;
+    async fetch({ requestId , payload  }) {
+        this.context.requests[requestId].loading = true;
         if (this.context._internal.RootBlocks) {
             this.context._internal.RootBlocks.setBlocksLoadingCache();
         }
@@ -82,18 +81,18 @@ let Requests = class Requests {
             const response = await this.context._internal.lowdefy._internal.callRequest({
                 pageId: this.context.pageId,
                 payload: serializer.serialize(payload),
-                requestId: requestId1
+                requestId
             });
             const deserializedResponse = serializer.deserialize(get(response, 'response', {
                 default: null
             }));
-            this.context.requests[requestId1].response = deserializedResponse;
-            this.context.requests[requestId1].loading = false;
+            this.context.requests[requestId].response = deserializedResponse;
+            this.context.requests[requestId].loading = false;
             this.context._internal.update();
             return deserializedResponse;
         } catch (error) {
-            this.context.requests[requestId1].error.unshift(error);
-            this.context.requests[requestId1].loading = false;
+            this.context.requests[requestId].error.unshift(error);
+            this.context.requests[requestId].loading = false;
             this.context._internal.update();
             throw error;
         }
@@ -103,8 +102,7 @@ let Requests = class Requests {
         this.callRequests = this.callRequests.bind(this);
         this.callRequest = this.callRequest.bind(this);
         this.fetch = this.fetch.bind(this);
-        this.requestConfig = {
-        };
+        this.requestConfig = {};
         (this.context._internal.rootBlock.requests || []).forEach((request)=>{
             this.requestConfig[request.requestId] = request;
         });

package/dist/State.js

@@ -32,10 +32,10 @@ let State = class State {
     set(field, value) {
         set(this.context.state, field, value);
     }
-    del(field1) {
-        unset(this.context.state, field1);
+    del(field) {
+        unset(this.context.state, field);
         // remove all empty objects from state as an effect of deleted values
-        const fields = field1.split('.');
+        const fields = field.split('.');
         if (fields.length > 1) {
             const parent = fields.slice(0, fields.length - 1).join('.');
             const parentValue = get(this.context.state, parent);
@@ -44,15 +44,15 @@ let State = class State {
             }
         }
     }
-    swapItems(field2, from, to) {
-        const arr = get(this.context.state, field2);
+    swapItems(field, from, to) {
+        const arr = get(this.context.state, field);
         if (!type.isArray(arr) || from < 0 || to < 0 || from >= arr.length || to >= arr.length) {
             return;
         }
         swap(arr, from, to);
     }
-    removeItem(field3, index) {
-        const arr = get(this.context.state, field3);
+    removeItem(field, index) {
+        const arr = get(this.context.state, field);
         if (!type.isArray(arr) || index < 0 || index >= arr.length) {
             return;
         }

package/dist/actions/createCallMethod.js

@@ -0,0 +1,29 @@
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { applyArrayIndices, type } from '@lowdefy/helpers';
+function createCallMethod({ arrayIndices , context  }) {
+    return function callMethod(params) {
+        const { blockId , method , args =[]  } = params;
+        const blockMethod = context._internal.RootBlocks.map[applyArrayIndices(arrayIndices, blockId)].methods[method];
+        if (!type.isArray(args)) {
+            throw new Error(`Failed to call method "${method}" on block "${blockId}": "args" should be an array. Received "${JSON.stringify(params)}".`);
+        }
+        if (!type.isFunction(blockMethod)) {
+            throw new Error(`Failed to call method "${method}" on block "${blockId}". Check if "${method}" is a valid block method for block "${blockId}". Received "${JSON.stringify(params)}".`);
+        }
+        return blockMethod(...args);
+    };
+}
+export default createCallMethod;