@lowdefy/engine 4.4.0 → 4.5.1

package/dist/Block.js

@@ -0,0 +1,439 @@
+/*
+  Copyright 2020-2024 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.
+*/ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { applyArrayIndices, get, serializer, swap, type } from '@lowdefy/helpers';
+import Events from './Events.js';
+import Areas from './Areas.js';
+let Block = class Block {
+    constructor({ context, arrayIndices }, { id, blockId, events, layout, loading, properties, required, skeleton, style, validate, visible, type: blockType, areas }){
+        _define_property(this, "_initInput", ()=>{
+            this.setValue = (value)=>{
+                this.value = type.enforceType(this.meta.valueType, value);
+                this.context._internal.State.set(this.blockId, this.value);
+                this.update = true;
+                this.context._internal.update();
+            };
+        });
+        _define_property(this, "_initList", ()=>{
+            // TODO: to initialize new object in array, the new value should be passed by method to unshiftItem and pushItem
+            this.unshiftItem = ()=>{
+                this.loopSubAreas((areasClass, i)=>{
+                    areasClass.recUpdateArrayIndices(this.arrayIndices.concat([
+                        i
+                    ]), this.arrayIndices.concat([
+                        i + 1
+                    ]));
+                });
+                this.subAreas.unshift(this.newAreas({
+                    arrayIndices: this.arrayIndices.concat([
+                        0
+                    ]),
+                    initState: {}
+                }));
+                this.context._internal.State.set(this.blockId, undefined);
+                // set area block and sub areas values undefined, so as not to pass values to new blocks
+                this.subAreas[0].recSetUndefined();
+                this.update = true;
+                this.context._internal.update();
+            };
+            this.pushItem = ()=>{
+                this.subAreas.push(this.newAreas({
+                    arrayIndices: this.arrayIndices.concat([
+                        this.subAreas.length
+                    ]),
+                    initState: {}
+                }));
+                this.update = true;
+                this.context._internal.update();
+            };
+            this.removeItem = (index)=>{
+                this.context._internal.State.removeItem(this.blockId, index);
+                const lastArea = this.subAreas[this.subAreas.length - 1];
+                lastArea.recRemoveBlocksFromMap();
+                const largerAreas = this.subAreas.slice(index + 1);
+                largerAreas.forEach((areasClass, i)=>{
+                    areasClass.recUpdateArrayIndices(this.arrayIndices.concat([
+                        index + i + 1
+                    ]), this.arrayIndices.concat([
+                        index + i
+                    ]));
+                });
+                this.subAreas.splice(index, 1);
+                this.update = true;
+                this.context._internal.update();
+            };
+            this.moveItemUp = (index)=>{
+                if (index === 0) return;
+                this.context._internal.State.swapItems(this.blockId, index - 1, index);
+                this.subAreas[index - 1].recUpdateArrayIndices(this.arrayIndices.concat([
+                    index - 1
+                ]), this.arrayIndices.concat([
+                    index
+                ]));
+                this.subAreas[index].recUpdateArrayIndices(this.arrayIndices.concat([
+                    index
+                ]), this.arrayIndices.concat([
+                    index - 1
+                ]));
+                swap(this.subAreas, index - 1, index);
+                this.update = true;
+                this.context._internal.update();
+            };
+            this.moveItemDown = (index)=>{
+                if (index === this.subAreas.length - 1) return;
+                this.context._internal.State.swapItems(this.blockId, index, index + 1);
+                this.subAreas[index + 1].recUpdateArrayIndices(this.arrayIndices.concat([
+                    index + 1
+                ]), this.arrayIndices.concat([
+                    index
+                ]));
+                this.subAreas[index].recUpdateArrayIndices(this.arrayIndices.concat([
+                    index
+                ]), this.arrayIndices.concat([
+                    index + 1
+                ]));
+                swap(this.subAreas, index, index + 1);
+                this.update = true;
+                this.context._internal.update();
+            };
+        });
+        _define_property(this, "loopSubAreas", (fn)=>{
+            if (this.subAreas) {
+                this.subAreas.forEach(fn);
+            }
+        });
+        _define_property(this, "isDisplay", ()=>{
+            return this.meta?.category === 'display';
+        });
+        _define_property(this, "isList", ()=>{
+            return this.meta?.category === 'list';
+        });
+        _define_property(this, "isInput", ()=>{
+            return this.meta?.category === 'input' || this.meta?.category === 'input-container';
+        });
+        _define_property(this, "isContainer", ()=>{
+            return this.meta?.category === 'container' || this.meta?.category === 'input-container';
+        });
+        _define_property(this, "registerMethod", (methodName, method)=>{
+            this.methods[methodName] = method;
+        });
+        _define_property(this, "newAreas", ({ arrayIndices, initState })=>{
+            const areasClass = new Areas({
+                arrayIndices,
+                areas: this.areas,
+                context: this.context
+            });
+            areasClass.init(initState);
+            return areasClass;
+        });
+        _define_property(this, "reset", (parentSubAreas, initWithState)=>{
+            this.update = true;
+            this.showValidation = false;
+            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 (this.isList()) {
+                    if (!type.isArray(this.subAreas)) {
+                        this.subAreas = [];
+                        parentSubAreas[this.id] = this.subAreas;
+                    }
+                    if (type.isArray(blockValue)) {
+                        blockValue.forEach((item, i)=>{
+                            if (!this.subAreas[i]) {
+                                this.subAreas.push(this.newAreas({
+                                    arrayIndices: this.arrayIndices.concat([
+                                        i
+                                    ]),
+                                    initState: initWithState
+                                }));
+                            } else {
+                                this.subAreas[i].reset(initWithState);
+                            }
+                        });
+                        this.subAreas.splice(blockValue.length);
+                    }
+                } else {
+                    this.value = blockValue;
+                }
+            }
+            if (this.isContainer()) {
+                if (!type.isArray(this.subAreas)) {
+                    this.subAreas = [];
+                    parentSubAreas[this.id] = this.subAreas;
+                }
+                if (!this.subAreas[0]) {
+                    this.subAreas.push(this.newAreas({
+                        arrayIndices: this.arrayIndices,
+                        initState: initWithState
+                    }));
+                } else {
+                    this.subAreas[0].reset(initWithState);
+                }
+            }
+        });
+        _define_property(this, "evaluate", (visibleParent, repeat)=>{
+            if (this.isInput()) {
+                const stateValue = get(this.context.state, this.blockId);
+                this.value = type.isUndefined(stateValue) ? this.value : stateValue;
+            }
+            const beforeVisible = this.visibleEval ? this.visibleEval.output : true;
+            if (visibleParent === false) {
+                this.visibleEval.output = false;
+            } else {
+                this.visibleEval = this.parse(this.visible);
+            }
+            if (beforeVisible !== this.visibleEval.output) {
+                repeat.value = true;
+            }
+            if (this.visibleEval.output !== false) {
+                this.propertiesEval = this.parse(this.properties);
+                this.requiredEval = this.parse(this.required);
+                this.validateEval();
+                this.styleEval = this.parse(this.style);
+                this.layoutEval = this.parse(this.layout);
+                this.loadingEval = this.parse(this.loading);
+                this.skeletonEval = this.parse(this.skeleton);
+                this.areasLayoutEval = this.parse(this.areasLayout);
+            }
+            if (this.isContainer() || this.isList()) {
+                this.loopSubAreas((areasClass)=>{
+                    repeat.value = areasClass.recEval(this.visibleEval.output) || repeat.value;
+                });
+            }
+            const after = this.evalToString();
+            if (this.before !== after) {
+                this.update = true;
+                this.before = after;
+            }
+        });
+        _define_property(this, "parse", (input)=>{
+            return this.context._internal.parser.parse({
+                input,
+                location: this.blockId,
+                arrayIndices: this.arrayIndices
+            });
+        });
+        _define_property(this, "validateEval", ()=>{
+            const requiredValidation = {
+                pass: {
+                    _not: {
+                        _type: 'none'
+                    }
+                },
+                status: 'error',
+                message: type.isString(this.requiredEval.output) ? this.requiredEval.output : 'This field is required'
+            };
+            const validation = this.requiredEval.output === false ? this.validate : [
+                ...this.validate,
+                requiredValidation
+            ];
+            this.validationEval = {
+                output: {
+                    status: null,
+                    errors: [],
+                    warnings: []
+                },
+                errors: []
+            };
+            let validationError = false;
+            let validationWarning = false;
+            validation.forEach((test)=>{
+                const parsed = this.parse(test);
+                // for parser errors
+                if (parsed.errors.length > 0) {
+                    this.validationEval.output.errors.push(parsed.output.message);
+                    this.validationEval.errors.push(parsed.errors);
+                    validationError = true;
+                    return;
+                }
+                // failed validation
+                if (!parsed.output.pass) {
+                    // no status indication on validation tests defaults to error
+                    if (!test.status || test.status === 'error') {
+                        this.validationEval.output.errors.push(parsed.output.message);
+                        validationError = true;
+                    }
+                    if (test.status === 'warning') {
+                        this.validationEval.output.warnings.push(parsed.output.message);
+                        validationWarning = true;
+                    }
+                }
+            });
+            if (validation.length > 0) {
+                this.validationEval.output.status = 'success';
+            }
+            if (validationWarning) {
+                this.validationEval.output.status = 'warning';
+            }
+            if (validationError && this.showValidation) {
+                this.validationEval.output.status = 'error';
+            }
+        });
+        _define_property(this, "evalToString", ()=>{
+            return serializer.serializeToString({
+                areasLayoutEval: this.areasLayoutEval,
+                layoutEval: this.layoutEval,
+                loadingEval: this.loadingEval,
+                propertiesEval: this.propertiesEval,
+                requiredEval: this.requiredEval,
+                skeletonEval: this.skeletonEval,
+                styleEval: this.styleEval,
+                validationEval: this.validationEval,
+                value: this.value,
+                visibleEval: this.visibleEval
+            });
+        });
+        _define_property(this, "updateState", (toSet)=>{
+            if (!this.isVisible()) return;
+            if (this.isContainer() || this.isList()) {
+                if (this.subAreas && this.subAreas.length > 0) {
+                    this.loopSubAreas((subAreasClass)=>subAreasClass.updateState());
+                    return; // Don't add to set
+                } else {
+                    this.context._internal.State.set(this.blockId, type.enforceType(this.meta.valueType, null));
+                }
+            }
+            if (this.isInput()) {
+                this.context._internal.State.set(this.blockId, this.value);
+            }
+            toSet.add(this.blockId);
+        });
+        _define_property(this, "isVisible", ()=>{
+            return this.visibleEval.output !== false;
+        });
+        _define_property(this, "updateArrayIndices", ()=>{
+            this.blockId = applyArrayIndices(this.arrayIndices, this.blockIdPattern);
+            this.context._internal.RootAreas.map[this.blockId] = this;
+        });
+        _define_property(this, "getValidate", (match)=>{
+            if (!match(this.blockId)) return null;
+            this.showValidation = true;
+            this.update = true;
+            if (this.visibleEval.output !== false && this.validationEval.output && this.validationEval.output.errors.length > 0) {
+                this.validationEval.output.status = 'error';
+                return {
+                    blockId: this.blockId,
+                    validation: this.validationEval.output
+                };
+            }
+            return null;
+        });
+        _define_property(this, "deleteFromMap", ()=>{
+            delete this.context._internal.RootAreas.map[this.blockId];
+        });
+        _define_property(this, "resetValidation", (match)=>{
+            if (!match(this.blockId)) return;
+            this.showValidation = false;
+            this.update = true;
+        });
+        _define_property(this, "render", ()=>{
+            if (!this.update) return;
+            this.update = false;
+            this.eval = {
+                areas: this.areasLayoutEval.output,
+                events: type.isNone(this.Events.events) ? null : this.Events.events,
+                properties: this.propertiesEval.output,
+                loading: this.loadingEval.output,
+                skeleton: this.skeletonEval.output,
+                required: this.requiredEval.output,
+                layout: this.layoutEval.output,
+                style: this.styleEval.output,
+                validation: {
+                    ...this.validationEval.output || {},
+                    status: this.showValidation || this.validationEval.output?.status === 'warning' ? this.validationEval.output?.status : null
+                },
+                value: type.isNone(this.value) ? null : this.value,
+                visible: this.visibleEval.output
+            };
+            this.context._internal.lowdefy._internal.updateBlock(this.id);
+        });
+        this.context = context;
+        this.arrayIndices = arrayIndices;
+        this.idPattern = id;
+        this.blockIdPattern = blockId;
+        this.id = applyArrayIndices(this.arrayIndices, this.idPattern);
+        this.blockId = applyArrayIndices(this.arrayIndices, this.blockIdPattern);
+        this.events = type.isNone(events) ? {} : events;
+        this.layout = type.isNone(layout) ? {} : layout;
+        this.loading = type.isNone(loading) ? false : loading;
+        this.properties = type.isNone(properties) ? {} : properties;
+        this.required = type.isNone(required) ? false : required;
+        this.skeleton = type.isNone(skeleton) ? null : skeleton;
+        this.style = type.isNone(style) ? {} : style;
+        this.validate = type.isNone(validate) ? [] : validate;
+        this.visible = type.isNone(visible) ? true : visible;
+        this.type = blockType;
+        this.areas = areas;
+        this.areasLayoutEval = {};
+        this.layoutEval = {};
+        this.loadingEval = {};
+        this.propertiesEval = {};
+        this.requiredEval = {};
+        this.skeletonEval = {};
+        this.styleEval = {};
+        this.validationEval = {};
+        this.visibleEval = {};
+        try {
+            this.meta = this.context._internal.lowdefy._internal.blockComponents[this.type].meta;
+        } catch (error) {
+            throw new Error(`Block type ${this.type} not found at ${this.blockId}. Check your plugins to make sure the block is installed. For more info, see https://docs.lowdefy.com/plugins.`);
+        }
+        if (!this.isContainer() && !this.isDisplay() && !this.isInput() && !this.isList()) {
+            throw new Error(`Block type ${this.type}.meta.category must be either "container", "display", "input", "list", or "input-container".`);
+        }
+        if (!type.isNone(areas)) {
+            this.areasLayout = {};
+            Object.keys(areas).forEach((key)=>{
+                // eslint-disable-next-line no-unused-vars
+                const { blocks, ...areaLayout } = areas[key];
+                this.areasLayout[key] = {
+                    ...areaLayout
+                };
+            });
+        } else {
+            this.areasLayout = {};
+        }
+        this.methods = {};
+        if (this.isList()) {
+            this._initList();
+        }
+        if (this.isInput()) {
+            this._initInput();
+        }
+        this.Events = new Events({
+            arrayIndices: this.arrayIndices,
+            block: this,
+            context: this.context
+        });
+        this.triggerEvent = this.Events.triggerEvent;
+        this.registerEvent = this.Events.registerEvent;
+    }
+};
+export default Block;

package/dist/Requests.js

@@ -54,6 +54,7 @@ let Requests = class Requests {
             });
             throw error;
         }
+        // evaluate operators
         const { output: payload, errors: parserErrors } = this.context._internal.parser.parse({
             actions,
             event,

package/dist/actions/createCallAPI.js

@@ -0,0 +1,24 @@
+/*
+  Copyright 2020-2024 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 callAPIHandler from '../callAPIHandler.js';
+function createCallAPI({ blockId, context }) {
+    return function callAPI(params) {
+        return callAPIHandler(context, {
+            blockId,
+            params
+        });
+    };
+}
+export default createCallAPI;

package/dist/actions/createCallMethod.js

@@ -16,7 +16,7 @@
 function createCallMethod({ arrayIndices, context }) {
     return function callMethod(params) {
         const { blockId, method, args = [] } = params;
-        const blockMethod = context._internal.RootBlocks.map[applyArrayIndices(arrayIndices, blockId)].methods[method];
+        const blockMethod = context._internal.RootAreas.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)}".`);
         }

package/dist/actions/createReset.js

@@ -16,7 +16,7 @@
 function createReset({ context }) {
     return function reset() {
         context._internal.State.resetState();
-        context._internal.RootBlocks.reset(serializer.deserializeFromString(context._internal.State.frozenState));
+        context._internal.RootAreas.reset(serializer.deserializeFromString(context._internal.State.frozenState));
     };
 }
 export default createReset;

package/dist/actions/createResetValidation.js

@@ -15,7 +15,7 @@
 */ import getBlockMatcher from '../getBlockMatcher.js';
 function createResetValidation({ context }) {
     return function resetValidation(params) {
-        context._internal.RootBlocks.resetValidation(getBlockMatcher(params));
+        context._internal.RootAreas.resetValidation(getBlockMatcher(params));
     };
 }
 export default createResetValidation;

package/dist/actions/createSetGlobal.js

@@ -18,7 +18,7 @@ const createSetGlobal = ({ arrayIndices, context })=>{
         Object.keys(params).forEach((key)=>{
             set(context._internal.lowdefy.lowdefyGlobal, applyArrayIndices(arrayIndices, key), params[key]);
         });
-        context._internal.RootBlocks.reset();
+        context._internal.RootAreas.reset();
         context._internal.update();
     };
 };

package/dist/actions/createSetState.js

@@ -18,7 +18,7 @@ function createSetState({ arrayIndices, context }) {
         Object.keys(params).forEach((key)=>{
             context._internal.State.set(applyArrayIndices(arrayIndices, key), params[key]);
         });
-        context._internal.RootBlocks.reset();
+        context._internal.RootAreas.reset();
         context._internal.update();
     };
 }

package/dist/actions/createValidate.js

@@ -15,7 +15,7 @@
 */ import getBlockMatcher from '../getBlockMatcher.js';
 function createValidate({ context }) {
     return function validate(params) {
-        const validationErrors = context._internal.RootBlocks.validate(getBlockMatcher(params));
+        const validationErrors = context._internal.RootAreas.validate(getBlockMatcher(params));
         if (validationErrors.length > 0) {
             const error = new Error(`Your input has ${validationErrors.length} validation error${validationErrors.length !== 1 ? 's' : ''}.`);
             throw error;

package/dist/actions/getActionMethods.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import createCallMethod from './createCallMethod.js';
+import createCallAPI from './createCallAPI.js';
 import createGetActions from './createGetActions.js';
 import createGetBlockId from './createGetBlockId.js';
 import createGetEvent from './createGetEvent.js';
@@ -36,6 +37,7 @@ import createUpdateSession from './createUpdateSession.js';
 import createValidate from './createValidate.js';
 function getActionMethods(props) {
     return {
+        callAPI: createCallAPI(props),
         callMethod: createCallMethod(props),
         displayMessage: createDisplayMessage(props),
         getActions: createGetActions(props),

package/dist/callAPIHandler.js

@@ -0,0 +1,63 @@
+/*
+  Copyright 2020-2024 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 { serializer } from '@lowdefy/helpers';
+async function callAPIHandler(context, { blockId, params }) {
+    if (!context._internal.lowdefy.apiResponses[params.endpointId]) {
+        context._internal.lowdefy.apiResponses[params.endpointId] = [];
+    }
+    const api = {
+        ...params,
+        blockId,
+        loading: true,
+        success: null,
+        pageId: context.pageId,
+        startTimestamp: new Date(),
+        endTimestamp: null
+    };
+    context._internal.lowdefy.apiResponses[api.endpointId].unshift(api);
+    let apiResponse;
+    try {
+        apiResponse = await context._internal.lowdefy._internal.callAPI({
+            blockId: api.blockId,
+            pageId: context.pageId,
+            payload: serializer.serialize(api.payload),
+            endpointId: api.endpointId
+        });
+    } catch (error) {
+        api.error = error;
+        api.loading = false;
+        api.response = null;
+        api.status = 'error';
+        api.success = false;
+        api.endTimestamp = new Date();
+        api.responseTime = api.endTimestamp - api.startTimestamp;
+        context._internal.update();
+        throw error;
+    }
+    const { error, response, status, success } = apiResponse;
+    api.error = serializer.deserialize(error);
+    api.loading = false;
+    api.response = serializer.deserialize(response);
+    api.status = status;
+    api.success = success;
+    api.endTimestamp = new Date();
+    api.responseTime = api.endTimestamp - api.startTimestamp;
+    context._internal.update();
+    if (!success) {
+        throw serializer.deserialize(error);
+    }
+    return api;
+}
+export default callAPIHandler;

package/dist/getContext.js

@@ -14,7 +14,7 @@
   limitations under the License.
 */ import { WebParser } from '@lowdefy/operators';
 import Actions from './Actions.js';
-import Blocks from './Blocks.js';
+import Areas from './Areas.js';
 import Requests from './Requests.js';
 import State from './State.js';
 const blockData = ({ areas, blockId, blocks, events, field, id, layout, pageId, properties, requests, required, style, type, validate, visible })=>({
@@ -72,7 +72,7 @@ function getContext({ config, jsMap = {}, lowdefy, resetContext = {
     _internal.State = new State(ctx);
     _internal.Actions = new Actions(ctx);
     _internal.Requests = new Requests(ctx);
-    _internal.RootBlocks = new Blocks({
+    _internal.RootAreas = new Areas({
         areas: {
             root: {
                 blocks: [
@@ -82,14 +82,14 @@ function getContext({ config, jsMap = {}, lowdefy, resetContext = {
         },
         context: ctx
     });
-    _internal.RootBlocks.init();
+    _internal.RootAreas.init();
     _internal.update = ()=>{
-        _internal.RootBlocks.update();
+        _internal.RootAreas.update();
     };
     _internal.runOnInit = async (progress)=>{
         progress();
         if (!_internal.onInitDone) {
-            await _internal.RootBlocks.areas.root.blocks[0].triggerEvent({
+            await _internal.RootAreas.areas.root.blocks[0].triggerEvent({
                 name: 'onInit',
                 progress
             });
@@ -100,7 +100,7 @@ function getContext({ config, jsMap = {}, lowdefy, resetContext = {
     };
     _internal.runOnInitAsync = async (progress)=>{
         if (_internal.onInitDone && !_internal.onInitAsyncDone) {
-            await _internal.RootBlocks.areas.root.blocks[0].triggerEvent({
+            await _internal.RootAreas.areas.root.blocks[0].triggerEvent({
                 name: 'onInitAsync',
                 progress
             });

package/dist/index.js

@@ -13,11 +13,11 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import Actions from './Actions.js';
-import Events from './Events.js';
-import Blocks from './Blocks.js';
+import Areas from './Areas.js';
 import createLink from './createLink.js';
+import Events from './Events.js';
+import getContext from './getContext.js';
 import Requests from './Requests.js';
 import State from './State.js';
-import getContext from './getContext.js';
-export { Actions, Events, Blocks, createLink, Requests, State };
+export { Actions, Areas, createLink, Events, Requests, State };
 export default getContext;