@lowdefy/client 4.0.0-alpha.9

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,
+            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,
+                user: lowdefy.user,
+                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,
+                user: lowdefy.user,
+                validation: block.eval.validation
+            })));
+    }
+};
+export default CategorySwitch;

package/dist/block/Container.js

@@ -0,0 +1,77 @@
+/*
+  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 { Area, BlockLayout, layoutParamsToArea } from '@lowdefy/layout';
+import { makeCssClass } from '@lowdefy/block-utils';
+import Block from './Block.js';
+const Container = ({ block , Blocks , Component , context , loading , lowdefy  })=>{
+    const content = {};
+    // eslint-disable-next-line prefer-destructuring
+    const areas = Blocks.subBlocks[block.id][0].areas;
+    Object.keys(areas).forEach((areaKey, i)=>{
+        content[areaKey] = (areaStyle)=>/*#__PURE__*/ React.createElement(Area, {
+                id: `ar-${block.blockId}-${areaKey}`,
+                key: `ar-${block.blockId}-${areaKey}-${i}`,
+                area: layoutParamsToArea({
+                    area: block.eval.areas[areaKey] || {},
+                    areaKey,
+                    layout: block.eval.layout || {}
+                }),
+                areaStyle: [
+                    areaStyle,
+                    block.eval.areas[areaKey] && block.eval.areas[areaKey].style
+                ],
+                highlightBorders: lowdefy.lowdefyGlobal.highlightBorders,
+                makeCssClass: makeCssClass
+            }, areas[areaKey].blocks.map((bl, k)=>/*#__PURE__*/ React.createElement(Block, {
+                    key: `co-${bl.blockId}-${k}`,
+                    Blocks: Blocks.subBlocks[block.id][0],
+                    block: bl,
+                    context: context,
+                    parentLoading: loading,
+                    lowdefy: lowdefy
+                })
+            ))
+        ;
+    });
+    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,
+        content: content,
+        events: block.eval.events,
+        key: block.blockId,
+        loading: loading,
+        menus: lowdefy.menus,
+        pageId: lowdefy.pageId,
+        properties: block.eval.properties,
+        required: block.eval.required,
+        user: lowdefy.user,
+        validation: block.eval.validation
+    })));
+};
+export default Container;

package/dist/block/List.js

@@ -0,0 +1,86 @@
+/*
+  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 { Area, BlockLayout, layoutParamsToArea } from '@lowdefy/layout';
+import { makeCssClass } from '@lowdefy/block-utils';
+import Block from './Block.js';
+const List = ({ block , Blocks , Component , context , loading , lowdefy  })=>{
+    const content = {};
+    const contentList = [];
+    Blocks.subBlocks[block.id].forEach((SBlock)=>{
+        Object.keys(SBlock.areas).forEach((areaKey)=>{
+            content[areaKey] = (areaStyle)=>/*#__PURE__*/ React.createElement(Area, {
+                    id: `ar-${block.blockId}-${SBlock.id}-${areaKey}`,
+                    key: `ar-${block.blockId}-${SBlock.id}-${areaKey}`,
+                    area: layoutParamsToArea({
+                        area: block.eval.areas[areaKey] || {},
+                        areaKey,
+                        layout: block.eval.layout || {}
+                    }),
+                    areaStyle: [
+                        areaStyle,
+                        block.eval.areas[areaKey] && block.eval.areas[areaKey].style
+                    ],
+                    highlightBorders: lowdefy.lowdefyGlobal.highlightBorders,
+                    makeCssClass: makeCssClass
+                }, SBlock.areas[areaKey].blocks.map((bl)=>/*#__PURE__*/ React.createElement(Block, {
+                        key: `ls-${bl.blockId}`,
+                        Blocks: SBlock,
+                        block: bl,
+                        context: context,
+                        parentLoading: loading,
+                        lowdefy: lowdefy
+                    })
+                ))
+            ;
+        });
+        contentList.push({
+            ...content
+        });
+    });
+    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,
+            moveItemDown: block.moveItemDown,
+            moveItemUp: block.moveItemUp,
+            pushItem: block.pushItem,
+            registerEvent: block.registerEvent,
+            registerMethod: block.registerMethod,
+            removeItem: block.removeItem,
+            triggerEvent: block.triggerEvent,
+            unshiftItem: block.unshiftItem
+        }),
+        basePath: lowdefy.basePath,
+        blockId: block.blockId,
+        components: lowdefy._internal.components,
+        events: block.eval.events,
+        key: block.blockId,
+        list: contentList,
+        loading: loading,
+        menus: lowdefy.menus,
+        pageId: lowdefy.pageId,
+        properties: block.eval.properties,
+        required: block.eval.required,
+        user: lowdefy.user,
+        validation: block.eval.validation
+    })));
+};
+export default List;

package/dist/block/LoadingBlock.js

@@ -0,0 +1,84 @@
+/*
+  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 } from 'react';
+import { BlockLayout } from '@lowdefy/layout';
+import { makeCssClass } from '@lowdefy/block-utils';
+import LoadingContainer from './LoadingContainer.js';
+import LoadingList from './LoadingList.js';
+const blockMethods = {
+    makeCssClass,
+    moveItemDown: ()=>{},
+    moveItemUp: ()=>{},
+    pushItem: ()=>{},
+    registerEvent: ()=>{},
+    registerMethod: ()=>{},
+    removeItem: ()=>{},
+    setValue: ()=>{},
+    triggerEvent: ()=>{},
+    unshiftItem: ()=>{}
+};
+const LoadingBlock = ({ blockLayout , blockId , context , lowdefy , skeleton  })=>{
+    let Component = lowdefy._internal.blockComponents[skeleton.type];
+    useEffect(()=>{
+        if (!lowdefy._internal.blockComponents[skeleton.type]) {
+            console.warn(`Skeleton block type not found for ${skeleton.type} in ${blockId}. Only '@lowdefy/blocks-basic' and '@lowdefy/blocks-loaders' block types are supported for skeletons.`);
+        }
+        return;
+    }, []);
+    if (!Component) {
+        // default to box when a skeleton block is not found - should be a basic or loader block.
+        Component = lowdefy._internal.blockComponents.Box;
+    }
+    const layout = skeleton.layout || blockLayout || {};
+    switch(Component.meta.category){
+        case 'list':
+            return(/*#__PURE__*/ React.createElement(LoadingList, {
+                blockId: blockId,
+                Component: Component,
+                context: context,
+                layout: layout,
+                lowdefy: lowdefy,
+                skeleton: skeleton
+            }));
+        case 'container':
+            return(/*#__PURE__*/ React.createElement(LoadingContainer, {
+                blockId: blockId,
+                Component: Component,
+                context: context,
+                layout: layout,
+                lowdefy: lowdefy,
+                skeleton: skeleton
+            }));
+        default:
+            return(/*#__PURE__*/ React.createElement(BlockLayout, {
+                blockStyle: skeleton.style,
+                highlightBorders: lowdefy.lowdefyGlobal.highlightBorders,
+                id: `s-bl-${blockId}-${skeleton.id}`,
+                layout: layout,
+                makeCssClass: makeCssClass
+            }, /*#__PURE__*/ React.createElement(Component, {
+                basePath: lowdefy.basePath,
+                blockId: blockId,
+                components: lowdefy._internal.components,
+                key: `s-${blockId}-${skeleton.id}`,
+                menus: lowdefy.menus,
+                methods: blockMethods,
+                pageId: lowdefy.pageId,
+                properties: skeleton.properties,
+                user: lowdefy.user
+            })));
+    }
+};
+export default LoadingBlock;

package/dist/block/LoadingContainer.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 { Area, BlockLayout, layoutParamsToArea } from '@lowdefy/layout';
+import { makeCssClass } from '@lowdefy/block-utils';
+import LoadingBlock from './LoadingBlock.js';
+const LoadingContainer = ({ blockId , Component , context , layout , lowdefy , skeleton  })=>{
+    const content = {};
+    // eslint-disable-next-line prefer-destructuring
+    Object.keys(skeleton.areas).forEach((areaKey, i)=>{
+        content[areaKey] = (areaStyle)=>/*#__PURE__*/ React.createElement(Area, {
+                area: layoutParamsToArea({
+                    area: skeleton.areas[areaKey] || {},
+                    areaKey,
+                    layout
+                }),
+                areaStyle: [
+                    areaStyle,
+                    skeleton.areas[areaKey] && skeleton.areas[areaKey].style
+                ],
+                highlightBorders: lowdefy.lowdefyGlobal.highlightBorders,
+                id: `s-ar-${blockId}-${skeleton.id}-${areaKey}`,
+                key: `s-ar-${blockId}-${skeleton.id}-${areaKey}-${i}`,
+                makeCssClass: makeCssClass
+            }, skeleton.areas[areaKey].blocks.map((skl, k)=>/*#__PURE__*/ React.createElement(LoadingBlock, {
+                    blockId: blockId,
+                    context: context,
+                    key: `s-co-${skl.id}-${k}`,
+                    lowdefy: lowdefy,
+                    skeleton: skl
+                })
+            ))
+        ;
+    });
+    return(/*#__PURE__*/ React.createElement(BlockLayout, {
+        blockStyle: skeleton.style,
+        highlightBorders: lowdefy.lowdefyGlobal.highlightBorders,
+        id: `s-bl-${blockId}-${skeleton.id}`,
+        layout: layout,
+        makeCssClass: makeCssClass
+    }, /*#__PURE__*/ React.createElement(Component, {
+        basePath: lowdefy.basePath,
+        blockId: blockId,
+        components: lowdefy._internal.components,
+        content: content,
+        key: skeleton.id,
+        menus: lowdefy.menus,
+        methods: {
+            makeCssClass
+        },
+        pageId: lowdefy.pageId,
+        properties: skeleton.properties,
+        user: lowdefy.user
+    })));
+};
+export default LoadingContainer;

package/dist/block/LoadingList.js

@@ -0,0 +1,72 @@
+/*
+  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 { Area, BlockLayout, layoutParamsToArea } from '@lowdefy/layout';
+import { makeCssClass } from '@lowdefy/block-utils';
+import LoadingBlock from './LoadingBlock.js';
+const LoadingList = ({ blockId , Component , context , layout , lowdefy , skeleton  })=>{
+    const content = {};
+    const contentList = [];
+    new Array(3).forEach(()=>{
+        Object.keys(skeleton.areas).forEach((areaKey, i)=>{
+            content[areaKey] = (areaStyle)=>/*#__PURE__*/ React.createElement(Area, {
+                    area: layoutParamsToArea({
+                        area: skeleton.areas[areaKey] || {},
+                        areaKey,
+                        layout
+                    }),
+                    areaStyle: [
+                        areaStyle,
+                        skeleton.areas[areaKey] && skeleton.areas[areaKey].style
+                    ],
+                    highlightBorders: lowdefy.lowdefyGlobal.highlightBorders,
+                    id: `s-ar-${blockId}-${skeleton.id}-${areaKey}`,
+                    key: `s-ar-${blockId}-${skeleton.id}-${areaKey}-${i}`,
+                    makeCssClass: makeCssClass
+                }, skeleton.areas[areaKey].blocks.map((skl, k)=>/*#__PURE__*/ React.createElement(LoadingBlock, {
+                        blockId: blockId,
+                        context: context,
+                        key: `s-co-${skl.id}-${k}`,
+                        lowdefy: lowdefy,
+                        skeleton: skl
+                    })
+                ))
+            ;
+        });
+        contentList.push({
+            ...content
+        });
+    });
+    return(/*#__PURE__*/ React.createElement(BlockLayout, {
+        blockStyle: skeleton.style,
+        highlightBorders: lowdefy.lowdefyGlobal.highlightBorders,
+        id: `s-bl-${blockId}-${skeleton.id}`,
+        layout: layout,
+        makeCssClass: makeCssClass
+    }, /*#__PURE__*/ React.createElement(Component, {
+        basePath: lowdefy.basePath,
+        blockId: blockId,
+        components: lowdefy._internal.components,
+        list: contentList,
+        menus: lowdefy.menus,
+        methods: {
+            makeCssClass
+        },
+        pageId: lowdefy.pageId,
+        properties: skeleton.properties,
+        user: lowdefy.user
+    })));
+};
+export default LoadingList;

package/dist/callRequest.js

@@ -0,0 +1,25 @@
+/*
+  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 request from './request.js';
+function callRequest({ pageId , payload , requestId  }) {
+    return request({
+        url: `/api/request/${pageId}/${requestId}`,
+        method: 'POST',
+        body: {
+            payload
+        }
+    });
+}
+export default callRequest;

package/dist/createIcon.js

@@ -0,0 +1,103 @@
+/*
+  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 classNames from 'classnames';
+import { omit, type } from '@lowdefy/helpers';
+import Icon from '@ant-design/icons';
+import { blockDefaultProps, makeCssClass } from '@lowdefy/block-utils';
+import ErrorBoundary from './ErrorBoundary.js';
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+const lowdefyProps = [
+    'actionLog',
+    'basePath',
+    'components',
+    'content',
+    'eventLog',
+    'list',
+    'loading',
+    'menus',
+    'pageId',
+    'registerEvent',
+    'registerMethod',
+    'schemaErrors',
+    'user',
+    'validation', 
+];
+const createIcon = (Icons)=>{
+    const AiOutlineLoading3Quarters = Icons['AiOutlineLoading3Quarters'];
+    const AiOutlineExclamationCircle = Icons['AiOutlineExclamationCircle'];
+    const IconBlock = ({ blockId , events , methods , onClick , properties , ...props })=>{
+        const propertiesObj = type.isString(properties) ? {
+            name: properties
+        } : properties;
+        const spin = (propertiesObj.spin || events.onClick && events.onClick.loading) && !propertiesObj.disableLoadingIcon;
+        const iconProps = {
+            id: blockId,
+            className: classNames({
+                [makeCssClass([
+                    {
+                        cursor: (onClick || events.onClick) && 'pointer'
+                    },
+                    propertiesObj.style, 
+                ])]: true,
+                'icon-spin': spin
+            }),
+            rotate: propertiesObj.rotate,
+            color: propertiesObj.color,
+            title: propertiesObj.name,
+            size: propertiesObj.size,
+            // twoToneColor: propertiesObj.color, // TODO: track https://github.com/react-icons/react-icons/issues/508
+            ...omit(props, lowdefyProps)
+        };
+        let IconComp = Icons[propertiesObj.name];
+        if (!IconComp) {
+            IconComp = AiOutlineExclamationCircle;
+        }
+        return(/*#__PURE__*/ React.createElement(React.Fragment, null, spin ? /*#__PURE__*/ React.createElement(AiOutlineLoading3Quarters, _extends({}, iconProps)) : /*#__PURE__*/ React.createElement(ErrorBoundary, {
+            fallback: ()=>/*#__PURE__*/ React.createElement(AiOutlineExclamationCircle, _extends({}, {
+                    ...iconProps,
+                    color: '#F00'
+                }))
+        }, /*#__PURE__*/ React.createElement(IconComp, _extends({
+            id: blockId,
+            onClick: onClick || events.onClick && (()=>methods.triggerEvent({
+                    name: 'onClick'
+                })
+            ),
+            size: propertiesObj.size,
+            title: propertiesObj.title
+        }, iconProps)))));
+    };
+    const AntIcon = (all)=>/*#__PURE__*/ React.createElement(Icon, {
+            component: ()=>/*#__PURE__*/ React.createElement(IconBlock, _extends({}, all))
+        })
+    ;
+    AntIcon.defaultProps = blockDefaultProps;
+    return AntIcon;
+};
+export default createIcon;