@lowdefy/build 3.23.2 → 4.0.0-alpha.6

package/dist/build/addDefaultPages/404.js

@@ -0,0 +1,51 @@
+/*
+  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.
+*/ export default {
+    id: '404',
+    type: 'Result',
+    style: {
+        minHeight: '100vh'
+    },
+    properties: {
+        status: 404,
+        title: '404',
+        subTitle: 'Sorry, the page you are visiting does not exist.'
+    },
+    areas: {
+        extra: {
+            blocks: [
+                {
+                    id: 'home',
+                    type: 'Button',
+                    properties: {
+                        title: 'Go to home page',
+                        type: 'Link'
+                    },
+                    events: {
+                        onClick: [
+                            {
+                                id: 'home',
+                                type: 'Link',
+                                params: {
+                                    home: true
+                                }
+                            }, 
+                        ]
+                    }
+                }, 
+            ]
+        }
+    }
+};

package/dist/build/addDefaultPages/addDefaultPages.js

@@ -0,0 +1,40 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+import page404 from './404.js';
+async function addDefaultPages({ components  }) {
+    // If not copied, the same object is mutated by build every time
+    // build runs for dev server. See #647
+    const defaultPages = [
+        JSON.parse(JSON.stringify(page404))
+    ];
+    if (type.isNone(components.pages)) {
+        components.pages = [];
+    }
+    if (!type.isArray(components.pages)) {
+        throw new Error('lowdefy.pages is not an array.');
+    }
+    const pageIds = components.pages.map((page)=>page.id
+    );
+    // deep copy to avoid mutating defaultConfig
+    const filteredDefaultPages = defaultPages.filter((defaultPage)=>!pageIds.includes(defaultPage.id)
+    );
+    components.pages = [
+        ...components.pages,
+        ...filteredDefaultPages
+    ];
+    return components;
+}
+export default addDefaultPages;

package/dist/build/buildAuth/buildAuth.js

@@ -0,0 +1,50 @@
+/* eslint-disable no-param-reassign */ /*
+  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 { type } from '@lowdefy/helpers';
+import getPageRoles from './getPageRoles.js';
+import getProtectedPages from './getProtectedPages.js';
+function buildAuth({ components  }) {
+    const protectedPages = getProtectedPages({
+        components
+    });
+    const pageRoles = getPageRoles({
+        components
+    });
+    let configPublicPages = [];
+    if (type.isArray(components.config.auth.pages.public)) {
+        configPublicPages = components.config.auth.pages.public;
+    }
+    (components.pages || []).forEach((page)=>{
+        if (pageRoles[page.id]) {
+            if (configPublicPages.includes(page.id)) {
+                throw new Error(`Page "${page.id}" is both protected by roles ${JSON.stringify(pageRoles[page.id])} and public.`);
+            }
+            page.auth = {
+                public: false,
+                roles: pageRoles[page.id]
+            };
+        } else if (protectedPages.includes(page.id)) {
+            page.auth = {
+                public: false
+            };
+        } else {
+            page.auth = {
+                public: true
+            };
+        }
+    });
+    return components;
+}
+export default buildAuth;

package/dist/build/buildAuth/getPageRoles.js

@@ -0,0 +1,33 @@
+/*
+  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.
+*/ function getPageRoles({ components  }) {
+    const roles = components.config.auth.pages.roles;
+    const pageRoles = {};
+    Object.keys(roles).forEach((roleName)=>{
+        roles[roleName].forEach((pageId)=>{
+            if (!pageRoles[pageId]) {
+                pageRoles[pageId] = new Set();
+            }
+            pageRoles[pageId].add(roleName);
+        });
+    });
+    Object.keys(pageRoles).forEach((pageId)=>{
+        pageRoles[pageId] = [
+            ...pageRoles[pageId]
+        ];
+    });
+    return pageRoles;
+}
+export default getPageRoles;

package/dist/build/buildAuth/getProtectedPages.js

@@ -0,0 +1,30 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+function getProtectedPages({ components  }) {
+    const pageIds = (components.pages || []).map((page)=>page.id
+    );
+    let protectedPages = [];
+    if (type.isArray(components.config.auth.pages.public)) {
+        protectedPages = pageIds.filter((pageId)=>!components.config.auth.pages.public.includes(pageId)
+        );
+    } else if (components.config.auth.pages.protected === true) {
+        protectedPages = pageIds;
+    } else if (type.isArray(components.config.auth.pages.protected)) {
+        protectedPages = components.config.auth.pages.protected;
+    }
+    return protectedPages;
+}
+export default getProtectedPages;

package/dist/build/buildConnections.js

@@ -0,0 +1,46 @@
+/* eslint-disable no-param-reassign */ /*
+  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 { type } from '@lowdefy/helpers';
+import countOperators from '../utils/countOperators.js';
+import createCheckDuplicateId from '../utils/createCheckDuplicateId.js';
+async function buildConnections({ components , context  }) {
+    const checkDuplicateConnectionId = createCheckDuplicateId({
+        message: 'Duplicate connectionId "{{ id }}".'
+    });
+    if (type.isArray(components.connections)) {
+        components.connections.forEach((connection)=>{
+            if (type.isUndefined(connection.id)) {
+                throw new Error(`Connection id missing.`);
+            }
+            if (!type.isString(connection.id)) {
+                throw new Error(`Connection id is not a string. Received ${JSON.stringify(connection.id)}.`);
+            }
+            checkDuplicateConnectionId({
+                id: connection.id
+            });
+            if (!type.isString(connection.type)) {
+                throw new Error(`Connection type is not a string at connection "${connection.id}". Received ${JSON.stringify(connection.type)}.`);
+            }
+            context.typeCounters.connections.increment(connection.type);
+            connection.connectionId = connection.id;
+            connection.id = `connection:${connection.id}`;
+            countOperators(connection.properties || {}, {
+                counter: context.typeCounters.operators.server
+            });
+        });
+    }
+    return components;
+}
+export default buildConnections;

package/dist/build/buildIcons.js

@@ -0,0 +1,91 @@
+/*
+  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.
+*/ const iconPackages = {
+    'react-icons/ai': /"(Ai[A-Z0-9]\w*)"/gm,
+    'react-icons/bs': /"(Bs[A-Z0-9]\w*)"/gm,
+    'react-icons/bi': /"(Bi[A-Z0-9]\w*)"/gm,
+    'react-icons/di': /"(Di[A-Z0-9]\w*)"/gm,
+    'react-icons/fi': /"(Fi[A-Z0-9]\w*)"/gm,
+    'react-icons/fc': /"(Fc[A-Z0-9]\w*)"/gm,
+    'react-icons/fa': /"(Fa[A-Z0-9]\w*)"/gm,
+    'react-icons/gi': /"(Gi[A-Z0-9]\w*)"/gm,
+    'react-icons/go': /"(Go[A-Z0-9]\w*)"/gm,
+    'react-icons/gr': /"(Gr[A-Z0-9]\w*)"/gm,
+    'react-icons/hi': /"(Hi[A-Z0-9]\w*)"/gm,
+    'react-icons/im': /"(Im[A-Z0-9]\w*)"/gm,
+    'react-icons/io': /"(IoIos[A-Z0-9]\w*)"/gm,
+    'react-icons/io5': /"(Io[A-Z0-9]\w*)"/gm,
+    'react-icons/md': /"(Md[A-Z0-9]\w*)"/gm,
+    'react-icons/ri': /"(Ri[A-Z0-9]\w*)"/gm,
+    'react-icons/si': /"(Si[A-Z0-9]\w*)"/gm,
+    'react-icons/ti': /"(Ti[A-Z0-9]\w*)"/gm,
+    'react-icons/vsc': /"(Vsc[A-Z0-9]\w*)"/gm,
+    'react-icons/wi': /"(Wi[A-Z0-9]\w*)"/gm,
+    'react-icons/cg': /"(Cg[A-Z0-9]\w*)"/gm
+};
+function getConfigIcons({ components , icons , regex  }) {
+    [
+        ...JSON.stringify(components.global || {}).matchAll(regex)
+    ].map((match)=>icons.add(match[1])
+    );
+    [
+        ...JSON.stringify(components.menus || []).matchAll(regex)
+    ].map((match)=>icons.add(match[1])
+    );
+    [
+        ...JSON.stringify(components.pages || []).matchAll(regex)
+    ].map((match)=>icons.add(match[1])
+    );
+}
+function getBlockDefaultIcons({ components , context , icons , regex  }) {
+    Object.entries(components.types.blocks).forEach(([blockName, block])=>{
+        context.types.icons[block.package][blockName].forEach((icon)=>{
+            [
+                ...JSON.stringify(icon).matchAll(regex)
+            ].map((match)=>icons.add(match[1])
+            );
+        });
+    });
+}
+function buildIcons({ components , context  }) {
+    components.icons = [];
+    Object.entries(iconPackages).forEach(([iconPackage, regex])=>{
+        const icons = new Set();
+        // TODO: Can we do better than this?
+        // Add default icons
+        if (iconPackage === 'react-icons/ai') {
+            icons.add('AiOutlineLoading3Quarters');
+            icons.add('AiOutlineExclamationCircle');
+        }
+        getConfigIcons({
+            components,
+            icons,
+            regex
+        });
+        getBlockDefaultIcons({
+            components,
+            context,
+            icons,
+            regex
+        });
+        components.icons.push({
+            icons: [
+                ...icons
+            ],
+            package: iconPackage
+        });
+    });
+}
+export default buildIcons;

package/dist/build/buildMenu.js

@@ -0,0 +1,122 @@
+/* eslint-disable no-param-reassign */ /*
+  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 { type } from '@lowdefy/helpers';
+import createCheckDuplicateId from '../utils/createCheckDuplicateId.js';
+async function buildDefaultMenu({ components , context  }) {
+    context.logger.warn('No menus found. Building default menu.');
+    const pages = type.isArray(components.pages) ? components.pages : [];
+    const menus = [
+        {
+            id: 'default',
+            links: pages.map((page, i)=>({
+                    id: `${i}`,
+                    type: 'MenuLink',
+                    pageId: page.pageId,
+                    auth: page.auth
+                })
+            ).filter((page)=>page.pageId !== '404'
+            )
+        }, 
+    ];
+    return menus;
+}
+function loopItems({ parent , menuId , pages , missingPageWarnings , checkDuplicateMenuItemId  }) {
+    if (type.isArray(parent.links)) {
+        parent.links.forEach((menuItem)=>{
+            if (menuItem.type === 'MenuLink') {
+                if (type.isString(menuItem.pageId)) {
+                    const page = pages.find((pg)=>pg.pageId === menuItem.pageId
+                    );
+                    if (!page) {
+                        missingPageWarnings.push({
+                            menuItemId: menuItem.id,
+                            pageId: menuItem.pageId
+                        });
+                        // remove menuItem from menu
+                        menuItem.remove = true;
+                        return;
+                    } else {
+                        menuItem.auth = page.auth;
+                    }
+                } else {
+                    menuItem.auth = {
+                        public: true
+                    };
+                }
+            }
+            if (menuItem.type === 'MenuGroup') {
+                menuItem.auth = {
+                    public: true
+                };
+            }
+            checkDuplicateMenuItemId({
+                id: menuItem.id,
+                menuId
+            });
+            menuItem.menuItemId = menuItem.id;
+            menuItem.id = `menuitem:${menuId}:${menuItem.id}`;
+            loopItems({
+                parent: menuItem,
+                menuId,
+                pages,
+                missingPageWarnings,
+                checkDuplicateMenuItemId
+            });
+        });
+        parent.links = parent.links.filter((item)=>item.remove !== true
+        );
+    }
+}
+async function buildMenu({ components , context  }) {
+    const pages = type.isArray(components.pages) ? components.pages : [];
+    if (type.isUndefined(components.menus) || components.menus.length === 0) {
+        components.menus = await buildDefaultMenu({
+            components,
+            context
+        });
+    }
+    const missingPageWarnings = [];
+    const checkDuplicateMenuId = createCheckDuplicateId({
+        message: 'Duplicate menuId "{{ id }}".'
+    });
+    components.menus.forEach((menu)=>{
+        if (type.isUndefined(menu.id)) {
+            throw new Error(`Menu id missing.`);
+        }
+        if (!type.isString(menu.id)) {
+            throw new Error(`Menu id is not a string. Received ${JSON.stringify(menu.id)}.`);
+        }
+        checkDuplicateMenuId({
+            id: menu.id
+        });
+        menu.menuId = menu.id;
+        menu.id = `menu:${menu.id}`;
+        const checkDuplicateMenuItemId = createCheckDuplicateId({
+            message: 'Duplicate menuItemId "{{ id }}" on menu "{{ menuId }}".'
+        });
+        loopItems({
+            parent: menu,
+            menuId: menu.menuId,
+            pages,
+            missingPageWarnings,
+            checkDuplicateMenuItemId
+        });
+    });
+    await Promise.all(missingPageWarnings.map(async (warning)=>{
+        await context.logger.warn(`Page "${warning.pageId}" referenced in menu link "${warning.menuItemId}" not found.`);
+    }));
+    return components;
+}
+export default buildMenu;

package/dist/build/buildPages/buildBlock/buildBlock.js

@@ -0,0 +1,31 @@
+/*
+  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 buildEvents from './buildEvents.js';
+import buildRequests from './buildRequests.js';
+import buildSubBlocks from './buildSubBlocks.js';
+import countBlockOperators from './countBlockOperators.js';
+import moveSubBlocksToArea from './moveSubBlocksToArea.js';
+import setBlockId from './setBlockId.js';
+import validateBlock from './validateBlock.js';
+async function buildBlock(block, pageContext) {
+    validateBlock(block, pageContext);
+    countBlockOperators(block, pageContext);
+    setBlockId(block, pageContext);
+    buildEvents(block, pageContext);
+    buildRequests(block, pageContext);
+    moveSubBlocksToArea(block, pageContext);
+    await buildSubBlocks(block, pageContext);
+}
+export default buildBlock;

package/dist/build/buildPages/buildBlock/buildEvents.js

@@ -0,0 +1,72 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+import createCheckDuplicateId from '../../../utils/createCheckDuplicateId.js';
+function checkAction(action, { blockId , checkDuplicateActionId , eventId , pageId , typeCounters  }) {
+    if (type.isUndefined(action.id)) {
+        throw new Error(`Action id missing on event "${eventId}" on block "${blockId}" on page "${pageId}".`);
+    }
+    if (!type.isString(action.id)) {
+        throw new Error(`Action id is not a string on event "${eventId}" on block "${blockId}" on page "${pageId}". Received ${JSON.stringify(action.id)}.`);
+    }
+    checkDuplicateActionId({
+        id: action.id,
+        eventId,
+        blockId,
+        pageId
+    });
+    if (!type.isString(action.type)) {
+        throw new Error(`Action type is not a string on action "${action.id}" on event "${eventId}" on block "${blockId}" on page "${pageId}". Received ${JSON.stringify(action.type)}.`);
+    }
+    typeCounters.actions.increment(action.type);
+}
+function buildEvents(block, pageContext) {
+    if (block.events) {
+        Object.keys(block.events).map((key)=>{
+            if (type.isArray(block.events[key])) {
+                block.events[key] = {
+                    try: block.events[key],
+                    catch: []
+                };
+            }
+            if (!type.isArray(block.events[key].try)) {
+                throw new Error(`Events must be an array of actions at "${block.blockId}" in event "${key}" on page "${pageContext.pageId}". Received ${JSON.stringify(block.events[key].try)}`);
+            }
+            if (!type.isArray(block.events[key].catch) && !type.isNone(block.events[key].catch)) {
+                throw new Error(`Catch events must be an array of actions at "${block.blockId}" in event "${key}" on page "${pageContext.pageId}". Received ${JSON.stringify(block.events[key].catch)}`);
+            }
+            const checkDuplicateActionId = createCheckDuplicateId({
+                message: 'Duplicate actionId "{{ id }}" on event "{{ eventId }}" on block "{{ blockId }}" on page "{{ pageId }}".'
+            });
+            block.events[key].try.map((action)=>checkAction(action, {
+                    eventId: key,
+                    blockId: block.blockId,
+                    typeCounters: pageContext.typeCounters,
+                    pageId: pageContext.pageId,
+                    checkDuplicateActionId
+                })
+            );
+            block.events[key].catch.map((action)=>checkAction(action, {
+                    eventId: key,
+                    blockId: block.blockId,
+                    typeCounters: pageContext.typeCounters,
+                    pageId: pageContext.pageId,
+                    checkDuplicateActionId
+                })
+            );
+        });
+    }
+}
+export default buildEvents;

package/dist/build/buildPages/buildBlock/buildRequests.js

@@ -0,0 +1,51 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+function buildRequest(request, pageContext) {
+    const { auth , checkDuplicateRequestId , pageId , typeCounters  } = pageContext;
+    if (type.isUndefined(request.id)) {
+        throw new Error(`Request id missing at page "${pageId}".`);
+    }
+    if (!type.isString(request.id)) {
+        throw new Error(`Request id is not a string at page "${pageId}". Received ${JSON.stringify(request.id)}.`);
+    }
+    checkDuplicateRequestId({
+        id: request.id,
+        pageId
+    });
+    if (request.id.includes('.')) {
+        throw new Error(`Request id "${request.id}" at page "${pageId}" should not include a period (".").`);
+    }
+    if (!type.isString(request.type)) {
+        throw new Error(`Request type is not a string at at request at "${request.id}" at page "${pageId}". Received ${JSON.stringify(request.type)}.`);
+    }
+    typeCounters.requests.increment(request.type);
+    if (type.isUndefined(request.payload)) request.payload = {};
+    if (!type.isObject(request.payload)) {
+        throw new Error(`Request "${request.id}" at page "${pageId}" payload should be an object.`);
+    }
+    request.auth = auth;
+    request.requestId = request.id;
+    request.pageId = pageId;
+    request.id = `request:${pageId}:${request.id}`;
+    pageContext.requests.push(request);
+}
+function buildRequests(block, pageContext) {
+    (block.requests || []).forEach((request)=>{
+        buildRequest(request, pageContext);
+    });
+    delete block.requests;
+}
+export default buildRequests;

package/dist/build/buildPages/buildBlock/buildSubBlocks.js

@@ -0,0 +1,35 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+import buildBlock from './buildBlock.js';
+async function buildSubBlocks(block, pageContext) {
+    if (type.isObject(block.areas)) {
+        let promises = [];
+        Object.keys(block.areas).forEach((key)=>{
+            if (type.isNone(block.areas[key].blocks)) {
+                block.areas[key].blocks = [];
+            }
+            if (!type.isArray(block.areas[key].blocks)) {
+                throw new Error(`Expected blocks to be an array at ${block.blockId} in area ${key} on page ${pageContext.pageId}. Received ${JSON.stringify(block.areas[key].blocks)}`);
+            }
+            const blockPromises = block.areas[key].blocks.map(async (blk)=>{
+                await buildBlock(blk, pageContext);
+            });
+            promises = promises.concat(blockPromises);
+        });
+        await Promise.all(promises);
+    }
+}
+export default buildSubBlocks;