@lowdefy/client 4.0.0-alpha.29 → 4.0.0-alpha.31

package/dist/Client.js

@@ -0,0 +1,68 @@
+/*
+  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.
+  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 React from 'react';
+import Block from './block/Block.js';
+import Context from './Context.js';
+import DisplayMessage from './DisplayMessage.js';
+import Head from './Head.js';
+import ProgressBarController from './ProgressBarController.js';
+import initLowdefyContext from './initLowdefyContext.js';
+const Client = ({ auth , Components , config , resetContext ={
+    reset: false,
+    setReset: ()=>undefined
+} , router , stage , types , window ,  })=>{
+    const lowdefy = initLowdefyContext({
+        auth,
+        Components,
+        config,
+        router,
+        stage,
+        types,
+        window
+    });
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(ProgressBarController, {
+        id: "lowdefy-progress-bar",
+        key: `${config.pageConfig.id}-progress-bar`,
+        lowdefy: lowdefy,
+        resetContext: resetContext
+    }), /*#__PURE__*/ React.createElement(DisplayMessage, {
+        id: "lowdefy-display-message",
+        key: `${config.pageConfig.id}-display-message`,
+        Component: lowdefy._internal.blockComponents.Message,
+        methods: {
+            registerMethod: (_, method)=>{
+                lowdefy._internal.displayMessage = method;
+            }
+        }
+    }), /*#__PURE__*/ React.createElement(Context, {
+        key: config.pageConfig.id,
+        config: config.pageConfig,
+        lowdefy: lowdefy,
+        resetContext: resetContext
+    }, (context)=>{
+        if (!context._internal.onInitDone) return '';
+        return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(Head, {
+            Component: Components.Head,
+            properties: context._internal.RootBlocks.map[config.pageConfig.blockId].eval.properties
+        }), /*#__PURE__*/ React.createElement(Block, {
+            block: context._internal.RootBlocks.map[config.pageConfig.blockId],
+            Blocks: context._internal.RootBlocks,
+            context: context,
+            lowdefy: lowdefy,
+            parentLoading: false
+        }));
+    }));
+};
+export default Client;

package/dist/Context.js

@@ -0,0 +1,45 @@
+/*
+  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.
+  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 React from 'react';
+import getContext from '@lowdefy/engine';
+import MountEvents from './MountEvents.js';
+const Context = ({ children , config , lowdefy , resetContext  })=>{
+    const context = getContext({
+        config,
+        lowdefy,
+        resetContext
+    });
+    return /*#__PURE__*/ React.createElement(MountEvents, {
+        context: context,
+        triggerEvent: async ()=>{
+            await context._internal.runOnInit(()=>{
+                lowdefy._internal.progress.dispatch({
+                    type: 'increment'
+                });
+            });
+        },
+        triggerEventAsync: ()=>{
+            context._internal.runOnInitAsync(()=>{
+                lowdefy._internal.progress.dispatch({
+                    type: 'increment'
+                });
+            });
+        }
+    }, (loadingOnInit)=>{
+        if (loadingOnInit) return '';
+        return children(context);
+    });
+};
+export default Context;

package/dist/DisplayMessage.js

@@ -0,0 +1,29 @@
+/*
+  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.
+  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 React from 'react';
+import { makeCssClass } from '@lowdefy/block-utils';
+const DisplayMessage = ({ Component , id , methods  })=>{
+    return /*#__PURE__*/ React.createElement(Component, {
+        blockId: id,
+        key: id,
+        methods: {
+            makeCssClass,
+            registerMethod: methods.registerMethod,
+            triggerEvent: ()=>undefined
+        },
+        properties: {}
+    });
+};
+export default DisplayMessage;

package/dist/ErrorBoundary.js

@@ -0,0 +1,52 @@
+/*
+  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.
+  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 React, { Component } from 'react';
+import ErrorPage from './ErrorPage.js';
+let ErrorBoundary = class ErrorBoundary extends Component {
+    static getDerivedStateFromError(error) {
+        return {
+            hasError: true,
+            error
+        };
+    }
+    render() {
+        const { children , description , fallback , fullPage , message , name  } = this.props;
+        const { hasError , error  } = this.state;
+        if (hasError) {
+            if (fallback) {
+                return fallback(error);
+            }
+            if (fullPage) {
+                return /*#__PURE__*/ React.createElement(ErrorPage, {
+                    code: error.number,
+                    description: description || error.description,
+                    message: message || error.message,
+                    name: name || error.name
+                });
+            }
+            // Throw to console but fail silently to user?
+            return '';
+        }
+        return children;
+    }
+    constructor(props){
+        super(props);
+        this.state = {
+            hasError: false,
+            error: null
+        };
+    }
+};
+export default ErrorBoundary;

package/dist/ErrorPage.js

@@ -0,0 +1,60 @@
+/*
+  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.
+  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 React from 'react';
+const ErrorPage = ({ code , description , message , name  })=>/*#__PURE__*/ React.createElement("div", {
+        style: {
+            height: '100%',
+            fontFamily: 'system-ui',
+            margin: 0,
+            display: 'flex',
+            justifyContent: 'center',
+            alignItems: 'center'
+        }
+    }, /*#__PURE__*/ React.createElement("div", {
+        style: {
+            flex: '0 1 auto',
+            fontSize: '4.3em',
+            fontWeight: '100',
+            paddingRight: 30
+        }
+    }, code || 500), /*#__PURE__*/ React.createElement("div", {
+        style: {
+            flex: '0 1 auto',
+            paddingLeft: 30,
+            maxWidth: 400,
+            borderLeft: '1px solid #aeaeae'
+        }
+    }, /*#__PURE__*/ React.createElement("div", {
+        style: {
+            fontSize: '1.3em',
+            fontWeight: '300',
+            paddingBottom: 10
+        }
+    }, name || 'Error'), /*#__PURE__*/ React.createElement("div", {
+        style: {
+            fontSize: '0.9em'
+        }
+    }, message || 'An error has occurred.'), /*#__PURE__*/ React.createElement("div", {
+        style: {
+            fontSize: '0.9em'
+        }
+    }, description), /*#__PURE__*/ React.createElement("div", {
+        style: {
+            paddingTop: 20
+        }
+    }, /*#__PURE__*/ React.createElement("a", {
+        href: "/"
+    }, "Return to home page"))));
+export default ErrorPage;

package/dist/Head.js

@@ -0,0 +1,19 @@
+/*
+  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.
+  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 React from 'react';
+const BindHead = ({ Component , properties  })=>{
+    return /*#__PURE__*/ React.createElement(Component, null, /*#__PURE__*/ React.createElement("title", null, properties.title));
+};
+export default BindHead;

package/dist/MountEvents.js

@@ -0,0 +1,37 @@
+/*
+  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.
+  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 React, { useEffect, useState } from 'react';
+const MountEvents = ({ children , context , triggerEvent , triggerEventAsync  })=>{
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(()=>{
+        setLoading(true);
+        const mount = async ()=>{
+            try {
+                await triggerEvent();
+                triggerEventAsync();
+                setLoading(false);
+            } catch (err) {
+                setError(err);
+            }
+        };
+        mount();
+    }, [
+        context
+    ]);
+    if (error) throw error;
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, children(loading));
+};
+export default MountEvents;

package/dist/ProgressBarController.js

@@ -0,0 +1,82 @@
+/*
+  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 React, { useReducer, useEffect } from 'react';
+import { makeCssClass } from '@lowdefy/block-utils';
+const initialState = {
+    progress: 0,
+    onMounts: 0
+};
+function reducer(state, action) {
+    switch(action.type){
+        case 'increment':
+            return {
+                ...state,
+                progress: state.progress + (100 - state.progress) / 3
+            };
+        case 'increment-on-mount':
+            return {
+                ...state,
+                onMounts: state.onMounts + 1
+            };
+        case 'auto-increment':
+            return {
+                ...state,
+                progress: state.progress + (100 - state.progress) / 200
+            };
+        case 'done':
+            return {
+                progress: state.onMounts - 1 === 0 ? 100 : state.progress,
+                onMounts: state.onMounts - 1
+            };
+        case 'reset':
+            return {
+                progress: 0,
+                onMounts: 0
+            };
+        default:
+            throw new Error('Invalid action type for ProgressBarController reducer.');
+    }
+}
+const ProgressBarController = ({ id , lowdefy , resetContext  })=>{
+    const [state, dispatch] = useReducer(reducer, initialState);
+    const ProgressBar = lowdefy._internal.blockComponents.ProgressBar;
+    lowdefy._internal.progress.state = state;
+    lowdefy._internal.progress.dispatch = dispatch;
+    useEffect(()=>{
+        const timer = state.progress < 95 && setInterval(()=>dispatch({
+                type: 'auto-increment'
+            }), 500);
+        return ()=>clearInterval(timer);
+    }, [
+        state
+    ]);
+    if (resetContext.reset && state.progress === 100) {
+        dispatch({
+            type: 'reset'
+        });
+    }
+    return /*#__PURE__*/ React.createElement(ProgressBar, {
+        basePath: lowdefy.basePath,
+        blockId: id,
+        components: lowdefy._internal.components,
+        menus: lowdefy.menus,
+        methods: {
+            makeCssClass
+        },
+        pageId: lowdefy.pageId,
+        properties: state
+    });
+};
+export default ProgressBarController;

package/dist/auth/createAuthMethods.js

@@ -0,0 +1,66 @@
+/*
+  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.
+  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, urlQuery as urlQueryFn } from '@lowdefy/helpers';
+function getCallbackUrl({ lowdefy , callbackUrl ={}  }) {
+    const { home , pageId , urlQuery , url  } = callbackUrl;
+    if ([
+        !home,
+        !pageId,
+        !url
+    ].filter((v)=>!v).length > 1) {
+        throw Error(`Invalid Link: To avoid ambiguity, only one of 'home', 'pageId' or 'url' can be defined.`);
+    }
+    const query = type.isNone(urlQuery) ? '' : `${urlQueryFn.stringify(urlQuery)}`;
+    if (home === true) {
+        return `/${lowdefy.home.configured ? '' : lowdefy.home.pageId}${query ? `?${query}` : ''}`;
+    }
+    if (type.isString(pageId)) {
+        return `/${pageId}${query ? `?${query}` : ''}`;
+    }
+    if (type.isString(url)) {
+        return `${url}${query ? `?${query}` : ''}`;
+    }
+    return undefined;
+}
+function createAuthMethods({ lowdefy , auth  }) {
+    // login and logout are Lowdefy function that handle action params
+    // signIn and signOut are the next-auth methods
+    function login({ authUrl , callbackUrl , providerId , ...rest } = {}) {
+        if (type.isNone(providerId) && auth.authConfig.providers.length === 1) {
+            providerId = auth.authConfig.providers[0].id;
+        }
+        auth.signIn(providerId, {
+            ...rest,
+            callbackUrl: getCallbackUrl({
+                lowdefy,
+                callbackUrl
+            })
+        }, authUrl?.urlQuery);
+    }
+    function logout({ callbackUrl , redirect  } = {}) {
+        auth.signOut({
+            callbackUrl: getCallbackUrl({
+                lowdefy,
+                callbackUrl
+            }),
+            redirect
+        });
+    }
+    return {
+        login,
+        logout
+    };
+}
+export default createAuthMethods;

package/dist/block/Block.js

@@ -0,0 +1,60 @@
+/*
+  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.
+  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 React, { useState } from 'react';
+import CategorySwitch from './CategorySwitch.js';
+import ErrorBoundary from '../ErrorBoundary.js';
+import MountEvents from '../MountEvents.js';
+const Block = ({ block , Blocks , context , lowdefy , parentLoading  })=>{
+    const [updates, setUpdate] = useState(0);
+    lowdefy._internal.updaters[block.id] = ()=>setUpdate(updates + 1);
+    return /*#__PURE__*/ React.createElement(ErrorBoundary, null, /*#__PURE__*/ React.createElement(MountEvents, {
+        context: context,
+        triggerEvent: async ()=>{
+            context._internal.lowdefy._internal.progress.dispatch({
+                type: 'increment-on-mount',
+                id: block.id
+            });
+            await block.triggerEvent({
+                name: 'onMount',
+                progress: ()=>{
+                    lowdefy._internal.progress.dispatch({
+                        type: 'increment'
+                    });
+                }
+            });
+        },
+        triggerEventAsync: ()=>{
+            block.triggerEvent({
+                name: 'onMountAsync',
+                progress: ()=>{
+                    lowdefy._internal.progress.dispatch({
+                        type: 'increment'
+                    });
+                }
+            });
+            lowdefy._internal.progress.dispatch({
+                type: 'done'
+            });
+        }
+    }, (eventLoading)=>/*#__PURE__*/ React.createElement(CategorySwitch, {
+            block: block,
+            Blocks: Blocks,
+            context: context,
+            loading: eventLoading || parentLoading || block.eval.loading,
+            lowdefy: lowdefy,
+            updates: updates
+        })));
+};
+export default Block;

package/dist/block/CategorySwitch.js

@@ -0,0 +1,116 @@
+/*
+  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.
+  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 React from 'react';
+import { BlockLayout } from '@lowdefy/layout';
+import { makeCssClass } from '@lowdefy/block-utils';
+import { type } from '@lowdefy/helpers';
+import Container from './Container.js';
+import List from './List.js';
+import LoadingBlock from './LoadingBlock.js';
+const CategorySwitch = ({ block , Blocks , context , loading , lowdefy  })=>{
+    if (!block.eval) return null; // TODO: check Renderer updates before eval is executed for the first time on lists. See #520
+    if (block.eval.visible === false) return /*#__PURE__*/ React.createElement("div", {
+        id: `vs-${block.blockId}`,
+        style: {
+            display: 'none'
+        }
+    });
+    const Component = lowdefy._internal.blockComponents[block.type];
+    if (loading && type.isObject(block.eval.skeleton)) {
+        return /*#__PURE__*/ React.createElement(LoadingBlock, {
+            blockLayout: block.eval.layout,
+            blockProperties: block.eval.properties,
+            blockStyle: block.eval.style,
+            context: context,
+            lowdefy: lowdefy,
+            skeleton: block.eval.skeleton
+        });
+    }
+    switch(Component.meta.category){
+        case 'list':
+            return /*#__PURE__*/ React.createElement(List, {
+                block: block,
+                Blocks: Blocks,
+                Component: Component,
+                context: context,
+                loading: loading,
+                lowdefy: lowdefy
+            });
+        case 'container':
+            return /*#__PURE__*/ React.createElement(Container, {
+                block: block,
+                Blocks: Blocks,
+                Component: Component,
+                context: context,
+                loading: loading,
+                lowdefy: lowdefy
+            });
+        case 'input':
+            return /*#__PURE__*/ React.createElement(BlockLayout, {
+                id: `bl-${block.blockId}`,
+                blockStyle: block.eval.style,
+                highlightBorders: lowdefy.lowdefyGlobal.highlightBorders,
+                layout: block.eval.layout,
+                makeCssClass: makeCssClass
+            }, /*#__PURE__*/ React.createElement(Component, {
+                methods: Object.assign(block.methods, {
+                    makeCssClass,
+                    registerEvent: block.registerEvent,
+                    registerMethod: block.registerMethod,
+                    setValue: block.setValue,
+                    triggerEvent: block.triggerEvent
+                }),
+                basePath: lowdefy.basePath,
+                blockId: block.blockId,
+                components: lowdefy._internal.components,
+                events: block.eval.events,
+                key: block.blockId,
+                loading: loading,
+                menus: lowdefy.menus,
+                pageId: lowdefy.pageId,
+                properties: block.eval.properties,
+                required: block.eval.required,
+                validation: block.eval.validation,
+                value: block.value
+            }));
+        default:
+            return /*#__PURE__*/ React.createElement(BlockLayout, {
+                id: `bl-${block.blockId}`,
+                blockStyle: block.eval.style,
+                highlightBorders: lowdefy.lowdefyGlobal.highlightBorders,
+                layout: block.eval.layout,
+                makeCssClass: makeCssClass
+            }, /*#__PURE__*/ React.createElement(Component, {
+                methods: Object.assign(block.methods, {
+                    makeCssClass,
+                    registerEvent: block.registerEvent,
+                    registerMethod: block.registerMethod,
+                    triggerEvent: block.triggerEvent
+                }),
+                basePath: lowdefy.basePath,
+                blockId: block.blockId,
+                components: lowdefy._internal.components,
+                events: block.eval.events,
+                key: block.blockId,
+                loading: loading,
+                menus: lowdefy.menus,
+                pageId: lowdefy.pageId,
+                properties: block.eval.properties,
+                required: block.eval.required,
+                validation: block.eval.validation
+            }));
+    }
+};
+export default CategorySwitch;