@webiny/app-dynamic-pages 0.0.0-unstable.2aaa1916d9

package/admin/PageTemplateDialog/CreateTemplateDialog.js

@@ -0,0 +1,200 @@
+import _styled from "@emotion/styled/base";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import React, { useState } from "react";
+import { css } from "emotion";
+import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
+import { Icon } from "@webiny/ui/Icon";
+import { ButtonDefault } from "@webiny/ui/Button";
+import { List, ListItem } from "@webiny/ui/List";
+import { Dialog, DialogTitle, DialogContent, DialogActions, DialogCancel } from "@webiny/ui/Dialog";
+import { CircularProgress } from "@webiny/ui/Progress";
+import { useModels } from "@webiny/app-headless-cms";
+import { ReactComponent as ArrowRightIcon } from "@webiny/icons/keyboard_arrow_right.svg";
+import { ReactComponent as InfoIcon } from "@webiny/icons/info.svg";
+import { ReactComponent as ArticleIcon } from "@webiny/icons/article.svg";
+import { ReactComponent as DatabaseIcon } from "@webiny/icons/dashboard.svg";
+const dialogStyles = css`
+    .mdc-dialog__surface {
+        width: 600px;
+        min-width: 600px;
+    }
+
+    .mdc-dialog__content {
+        padding-top: 0 !important;
+    }
+
+    .content-wrapper:focus-visible {
+        outline: none;
+    }
+`;
+const Info = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1ualc005"
+} : {
+  target: "e1ualc005",
+  label: "Info"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1ci36am",
+  styles: "display:flex;align-items:center;padding:12px;margin-top:12px;background:var(--mdc-theme-background);color:var(--mdc-theme-text-secondary-on-background);fill:var(--mdc-theme-text-secondary-on-background);cursor:pointer;& svg{margin-right:12px;}"
+} : {
+  name: "1ci36am",
+  styles: "display:flex;align-items:center;padding:12px;margin-top:12px;background:var(--mdc-theme-background);color:var(--mdc-theme-text-secondary-on-background);fill:var(--mdc-theme-text-secondary-on-background);cursor:pointer;& svg{margin-right:12px;}",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["CreateTemplateDialog.tsx"],"names":[],"mappings":"AAkCuB","file":"CreateTemplateDialog.tsx","sourcesContent":["import React, { useState } from \"react\";\nimport { css } from \"emotion\";\nimport styled from \"@emotion/styled\";\nimport { FontAwesomeIcon } from \"@fortawesome/react-fontawesome\";\nimport type { IconProp } from \"@fortawesome/fontawesome-svg-core\";\n\nimport { Icon } from \"@webiny/ui/Icon\";\nimport { ButtonDefault } from \"@webiny/ui/Button\";\nimport { List, ListItem } from \"@webiny/ui/List\";\nimport { Dialog, DialogTitle, DialogContent, DialogActions, DialogCancel } from \"@webiny/ui/Dialog\";\nimport { CircularProgress } from \"@webiny/ui/Progress\";\nimport { useModels } from \"@webiny/app-headless-cms\";\nimport type { CmsModel } from \"@webiny/app-headless-cms/types\";\n\nimport { ReactComponent as ArrowRightIcon } from \"@webiny/icons/keyboard_arrow_right.svg\";\nimport { ReactComponent as InfoIcon } from \"@webiny/icons/info.svg\";\nimport { ReactComponent as ArticleIcon } from \"@webiny/icons/article.svg\";\nimport { ReactComponent as DatabaseIcon } from \"@webiny/icons/dashboard.svg\";\n\nconst dialogStyles = css`\n    .mdc-dialog__surface {\n        width: 600px;\n        min-width: 600px;\n    }\n\n    .mdc-dialog__content {\n        padding-top: 0 !important;\n    }\n\n    .content-wrapper:focus-visible {\n        outline: none;\n    }\n`;\n\nconst Info = styled.div`\n    display: flex;\n    align-items: center;\n    padding: 12px;\n    margin-top: 12px;\n    background: var(--mdc-theme-background);\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n    cursor: pointer;\n\n    & svg {\n        margin-right: 12px;\n    }\n`;\n\nconst ListItemStyled = styled(ListItem)`\n    padding-top: 8px;\n    padding-bottom: 8px;\n    height: auto;\n    min-height: 64px;\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n\n    & svg {\n        flex-shrink: 0;\n    }\n\n    .arrow-right {\n        margin-left: auto;\n    }\n`;\n\nconst ListItemContent = styled.div`\n    display: grid;\n    padding-left: 21px;\n    padding-right: 21px;\n`;\n\nconst Title = styled.div`\n    font-size: 20px;\n`;\n\nconst Highlight = styled.div`\n    color: var(--mdc-theme-primary);\n`;\n\nconst DynamicTemplatesInfo = styled.div`\n    padding: 24px;\n    font-size: 20px;\n    line-height: 24px;\n    color: var(--mdc-theme-text-secondary-on-background);\n`;\n\nconst leftButton = css`\n    margin-right: auto;\n`;\n\ninterface ModelIconProps {\n    model: CmsModel;\n}\nconst ModelIcon: React.FC<ModelIconProps> = ({ model }) => {\n    return (\n        <FontAwesomeIcon\n            style={{ color: \"var(--mdc-theme-text-secondary-on-background)\" }}\n            icon={(model.icon || \"fas/star\").split(\"/\") as IconProp}\n            width={32}\n            size={\"2x\"}\n        />\n    );\n};\n\ntype HeadlessPageTemplateItemProps = {\n    icon: React.ReactElement<any>;\n    name: string;\n    description?: string;\n    highlight?: string;\n    onClick: () => void;\n    hasNestedFields?: boolean;\n};\n\nconst HeadlessPageTemplateItem: React.FC<HeadlessPageTemplateItemProps> = ({\n    icon,\n    name,\n    description,\n    highlight,\n    onClick,\n    hasNestedFields\n}) => {\n    return (\n        <ListItemStyled onClick={onClick}>\n            <Icon icon={icon} />\n            <ListItemContent>\n                <Title>{name}</Title>\n                {description}\n                <Highlight>{highlight}</Highlight>\n            </ListItemContent>\n            {hasNestedFields && <ArrowRightIcon className=\"arrow-right\" />}\n        </ListItemStyled>\n    );\n};\n\ntype CreateTemplateDialogProps = {\n    open: boolean;\n    onClose: () => void;\n    onDynamicTemplateSelect: (model: CmsModel) => void;\n    onStaticTemplateSelect: () => void;\n    existingDynamicTemplateModelIds: string[];\n};\n\nexport const CreateTemplateDialog: React.FC<CreateTemplateDialogProps> = ({\n    open,\n    onClose,\n    onDynamicTemplateSelect,\n    onStaticTemplateSelect,\n    existingDynamicTemplateModelIds\n}) => {\n    const [dynamicTemplateSelect, setDynamicTemplateSelect] = useState(false);\n    const { models, loading } = useModels();\n\n    return (\n        <Dialog open={open} className={dialogStyles} onClose={onClose}>\n            <DialogTitle>What type of a template you wish to create?</DialogTitle>\n            <DynamicTemplatesInfo>\n                Select a Headless Page Template for which you want to create a dynamic page\n                template:\n            </DynamicTemplatesInfo>\n            <DialogContent>\n                <div className=\"content-wrapper\" tabIndex={0}>\n                    {dynamicTemplateSelect ? (\n                        <>\n                            {loading && <CircularProgress />}\n                            <List>\n                                {models.map((model, index) => (\n                                    <HeadlessPageTemplateItem\n                                        key={index}\n                                        icon={<ModelIcon model={model} />}\n                                        name={model.name}\n                                        description={model.description}\n                                        highlight={\n                                            existingDynamicTemplateModelIds.some(\n                                                id => id === model.modelId\n                                            )\n                                                ? \"Template already exists, click to edit.\"\n                                                : undefined\n                                        }\n                                        onClick={() => onDynamicTemplateSelect(model)}\n                                    />\n                                ))}\n                            </List>\n                        </>\n                    ) : (\n                        <>\n                            <HeadlessPageTemplateItem\n                                icon={<ArticleIcon width={36} height={36} />}\n                                name={\"Static template\"}\n                                description={\"Used for creating new Page Builder pages.\"}\n                                onClick={onStaticTemplateSelect}\n                            />\n                            <HeadlessPageTemplateItem\n                                icon={<DatabaseIcon width={36} height={36} />}\n                                name={\"Dynamic template\"}\n                                description={\n                                    \"Used for auto-generating pages  from Headless CMS entries.\"\n                                }\n                                onClick={() => setDynamicTemplateSelect(true)}\n                                hasNestedFields\n                            />\n                            <Info>\n                                <InfoIcon />\n                                Click here to learn about different template types.\n                            </Info>\n                        </>\n                    )}\n                </div>\n            </DialogContent>\n            <DialogActions>\n                {dynamicTemplateSelect && (\n                    <ButtonDefault\n                        onClick={() => {\n                            setDynamicTemplateSelect(false);\n                        }}\n                        className={leftButton}\n                    >\n                        &lt; Go back\n                    </ButtonDefault>\n                )}\n                <DialogCancel onClick={onClose}>Cancel</DialogCancel>\n            </DialogActions>\n        </Dialog>\n    );\n};\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const ListItemStyled = /*#__PURE__*/_styled(ListItem, process.env.NODE_ENV === "production" ? {
+  target: "e1ualc004"
+} : {
+  target: "e1ualc004",
+  label: "ListItemStyled"
+})(process.env.NODE_ENV === "production" ? {
+  name: "mv3wdt",
+  styles: "padding-top:8px;padding-bottom:8px;height:auto;min-height:64px;color:var(--mdc-theme-text-secondary-on-background);fill:var(--mdc-theme-text-secondary-on-background);& svg{flex-shrink:0;}.arrow-right{margin-left:auto;}"
+} : {
+  name: "mv3wdt",
+  styles: "padding-top:8px;padding-bottom:8px;height:auto;min-height:64px;color:var(--mdc-theme-text-secondary-on-background);fill:var(--mdc-theme-text-secondary-on-background);& svg{flex-shrink:0;}.arrow-right{margin-left:auto;}",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["CreateTemplateDialog.tsx"],"names":[],"mappings":"AAiDuC","file":"CreateTemplateDialog.tsx","sourcesContent":["import React, { useState } from \"react\";\nimport { css } from \"emotion\";\nimport styled from \"@emotion/styled\";\nimport { FontAwesomeIcon } from \"@fortawesome/react-fontawesome\";\nimport type { IconProp } from \"@fortawesome/fontawesome-svg-core\";\n\nimport { Icon } from \"@webiny/ui/Icon\";\nimport { ButtonDefault } from \"@webiny/ui/Button\";\nimport { List, ListItem } from \"@webiny/ui/List\";\nimport { Dialog, DialogTitle, DialogContent, DialogActions, DialogCancel } from \"@webiny/ui/Dialog\";\nimport { CircularProgress } from \"@webiny/ui/Progress\";\nimport { useModels } from \"@webiny/app-headless-cms\";\nimport type { CmsModel } from \"@webiny/app-headless-cms/types\";\n\nimport { ReactComponent as ArrowRightIcon } from \"@webiny/icons/keyboard_arrow_right.svg\";\nimport { ReactComponent as InfoIcon } from \"@webiny/icons/info.svg\";\nimport { ReactComponent as ArticleIcon } from \"@webiny/icons/article.svg\";\nimport { ReactComponent as DatabaseIcon } from \"@webiny/icons/dashboard.svg\";\n\nconst dialogStyles = css`\n    .mdc-dialog__surface {\n        width: 600px;\n        min-width: 600px;\n    }\n\n    .mdc-dialog__content {\n        padding-top: 0 !important;\n    }\n\n    .content-wrapper:focus-visible {\n        outline: none;\n    }\n`;\n\nconst Info = styled.div`\n    display: flex;\n    align-items: center;\n    padding: 12px;\n    margin-top: 12px;\n    background: var(--mdc-theme-background);\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n    cursor: pointer;\n\n    & svg {\n        margin-right: 12px;\n    }\n`;\n\nconst ListItemStyled = styled(ListItem)`\n    padding-top: 8px;\n    padding-bottom: 8px;\n    height: auto;\n    min-height: 64px;\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n\n    & svg {\n        flex-shrink: 0;\n    }\n\n    .arrow-right {\n        margin-left: auto;\n    }\n`;\n\nconst ListItemContent = styled.div`\n    display: grid;\n    padding-left: 21px;\n    padding-right: 21px;\n`;\n\nconst Title = styled.div`\n    font-size: 20px;\n`;\n\nconst Highlight = styled.div`\n    color: var(--mdc-theme-primary);\n`;\n\nconst DynamicTemplatesInfo = styled.div`\n    padding: 24px;\n    font-size: 20px;\n    line-height: 24px;\n    color: var(--mdc-theme-text-secondary-on-background);\n`;\n\nconst leftButton = css`\n    margin-right: auto;\n`;\n\ninterface ModelIconProps {\n    model: CmsModel;\n}\nconst ModelIcon: React.FC<ModelIconProps> = ({ model }) => {\n    return (\n        <FontAwesomeIcon\n            style={{ color: \"var(--mdc-theme-text-secondary-on-background)\" }}\n            icon={(model.icon || \"fas/star\").split(\"/\") as IconProp}\n            width={32}\n            size={\"2x\"}\n        />\n    );\n};\n\ntype HeadlessPageTemplateItemProps = {\n    icon: React.ReactElement<any>;\n    name: string;\n    description?: string;\n    highlight?: string;\n    onClick: () => void;\n    hasNestedFields?: boolean;\n};\n\nconst HeadlessPageTemplateItem: React.FC<HeadlessPageTemplateItemProps> = ({\n    icon,\n    name,\n    description,\n    highlight,\n    onClick,\n    hasNestedFields\n}) => {\n    return (\n        <ListItemStyled onClick={onClick}>\n            <Icon icon={icon} />\n            <ListItemContent>\n                <Title>{name}</Title>\n                {description}\n                <Highlight>{highlight}</Highlight>\n            </ListItemContent>\n            {hasNestedFields && <ArrowRightIcon className=\"arrow-right\" />}\n        </ListItemStyled>\n    );\n};\n\ntype CreateTemplateDialogProps = {\n    open: boolean;\n    onClose: () => void;\n    onDynamicTemplateSelect: (model: CmsModel) => void;\n    onStaticTemplateSelect: () => void;\n    existingDynamicTemplateModelIds: string[];\n};\n\nexport const CreateTemplateDialog: React.FC<CreateTemplateDialogProps> = ({\n    open,\n    onClose,\n    onDynamicTemplateSelect,\n    onStaticTemplateSelect,\n    existingDynamicTemplateModelIds\n}) => {\n    const [dynamicTemplateSelect, setDynamicTemplateSelect] = useState(false);\n    const { models, loading } = useModels();\n\n    return (\n        <Dialog open={open} className={dialogStyles} onClose={onClose}>\n            <DialogTitle>What type of a template you wish to create?</DialogTitle>\n            <DynamicTemplatesInfo>\n                Select a Headless Page Template for which you want to create a dynamic page\n                template:\n            </DynamicTemplatesInfo>\n            <DialogContent>\n                <div className=\"content-wrapper\" tabIndex={0}>\n                    {dynamicTemplateSelect ? (\n                        <>\n                            {loading && <CircularProgress />}\n                            <List>\n                                {models.map((model, index) => (\n                                    <HeadlessPageTemplateItem\n                                        key={index}\n                                        icon={<ModelIcon model={model} />}\n                                        name={model.name}\n                                        description={model.description}\n                                        highlight={\n                                            existingDynamicTemplateModelIds.some(\n                                                id => id === model.modelId\n                                            )\n                                                ? \"Template already exists, click to edit.\"\n                                                : undefined\n                                        }\n                                        onClick={() => onDynamicTemplateSelect(model)}\n                                    />\n                                ))}\n                            </List>\n                        </>\n                    ) : (\n                        <>\n                            <HeadlessPageTemplateItem\n                                icon={<ArticleIcon width={36} height={36} />}\n                                name={\"Static template\"}\n                                description={\"Used for creating new Page Builder pages.\"}\n                                onClick={onStaticTemplateSelect}\n                            />\n                            <HeadlessPageTemplateItem\n                                icon={<DatabaseIcon width={36} height={36} />}\n                                name={\"Dynamic template\"}\n                                description={\n                                    \"Used for auto-generating pages  from Headless CMS entries.\"\n                                }\n                                onClick={() => setDynamicTemplateSelect(true)}\n                                hasNestedFields\n                            />\n                            <Info>\n                                <InfoIcon />\n                                Click here to learn about different template types.\n                            </Info>\n                        </>\n                    )}\n                </div>\n            </DialogContent>\n            <DialogActions>\n                {dynamicTemplateSelect && (\n                    <ButtonDefault\n                        onClick={() => {\n                            setDynamicTemplateSelect(false);\n                        }}\n                        className={leftButton}\n                    >\n                        &lt; Go back\n                    </ButtonDefault>\n                )}\n                <DialogCancel onClick={onClose}>Cancel</DialogCancel>\n            </DialogActions>\n        </Dialog>\n    );\n};\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const ListItemContent = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1ualc003"
+} : {
+  target: "e1ualc003",
+  label: "ListItemContent"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1i68tbr",
+  styles: "display:grid;padding-left:21px;padding-right:21px"
+} : {
+  name: "1i68tbr",
+  styles: "display:grid;padding-left:21px;padding-right:21px",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["CreateTemplateDialog.tsx"],"names":[],"mappings":"AAkEkC","file":"CreateTemplateDialog.tsx","sourcesContent":["import React, { useState } from \"react\";\nimport { css } from \"emotion\";\nimport styled from \"@emotion/styled\";\nimport { FontAwesomeIcon } from \"@fortawesome/react-fontawesome\";\nimport type { IconProp } from \"@fortawesome/fontawesome-svg-core\";\n\nimport { Icon } from \"@webiny/ui/Icon\";\nimport { ButtonDefault } from \"@webiny/ui/Button\";\nimport { List, ListItem } from \"@webiny/ui/List\";\nimport { Dialog, DialogTitle, DialogContent, DialogActions, DialogCancel } from \"@webiny/ui/Dialog\";\nimport { CircularProgress } from \"@webiny/ui/Progress\";\nimport { useModels } from \"@webiny/app-headless-cms\";\nimport type { CmsModel } from \"@webiny/app-headless-cms/types\";\n\nimport { ReactComponent as ArrowRightIcon } from \"@webiny/icons/keyboard_arrow_right.svg\";\nimport { ReactComponent as InfoIcon } from \"@webiny/icons/info.svg\";\nimport { ReactComponent as ArticleIcon } from \"@webiny/icons/article.svg\";\nimport { ReactComponent as DatabaseIcon } from \"@webiny/icons/dashboard.svg\";\n\nconst dialogStyles = css`\n    .mdc-dialog__surface {\n        width: 600px;\n        min-width: 600px;\n    }\n\n    .mdc-dialog__content {\n        padding-top: 0 !important;\n    }\n\n    .content-wrapper:focus-visible {\n        outline: none;\n    }\n`;\n\nconst Info = styled.div`\n    display: flex;\n    align-items: center;\n    padding: 12px;\n    margin-top: 12px;\n    background: var(--mdc-theme-background);\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n    cursor: pointer;\n\n    & svg {\n        margin-right: 12px;\n    }\n`;\n\nconst ListItemStyled = styled(ListItem)`\n    padding-top: 8px;\n    padding-bottom: 8px;\n    height: auto;\n    min-height: 64px;\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n\n    & svg {\n        flex-shrink: 0;\n    }\n\n    .arrow-right {\n        margin-left: auto;\n    }\n`;\n\nconst ListItemContent = styled.div`\n    display: grid;\n    padding-left: 21px;\n    padding-right: 21px;\n`;\n\nconst Title = styled.div`\n    font-size: 20px;\n`;\n\nconst Highlight = styled.div`\n    color: var(--mdc-theme-primary);\n`;\n\nconst DynamicTemplatesInfo = styled.div`\n    padding: 24px;\n    font-size: 20px;\n    line-height: 24px;\n    color: var(--mdc-theme-text-secondary-on-background);\n`;\n\nconst leftButton = css`\n    margin-right: auto;\n`;\n\ninterface ModelIconProps {\n    model: CmsModel;\n}\nconst ModelIcon: React.FC<ModelIconProps> = ({ model }) => {\n    return (\n        <FontAwesomeIcon\n            style={{ color: \"var(--mdc-theme-text-secondary-on-background)\" }}\n            icon={(model.icon || \"fas/star\").split(\"/\") as IconProp}\n            width={32}\n            size={\"2x\"}\n        />\n    );\n};\n\ntype HeadlessPageTemplateItemProps = {\n    icon: React.ReactElement<any>;\n    name: string;\n    description?: string;\n    highlight?: string;\n    onClick: () => void;\n    hasNestedFields?: boolean;\n};\n\nconst HeadlessPageTemplateItem: React.FC<HeadlessPageTemplateItemProps> = ({\n    icon,\n    name,\n    description,\n    highlight,\n    onClick,\n    hasNestedFields\n}) => {\n    return (\n        <ListItemStyled onClick={onClick}>\n            <Icon icon={icon} />\n            <ListItemContent>\n                <Title>{name}</Title>\n                {description}\n                <Highlight>{highlight}</Highlight>\n            </ListItemContent>\n            {hasNestedFields && <ArrowRightIcon className=\"arrow-right\" />}\n        </ListItemStyled>\n    );\n};\n\ntype CreateTemplateDialogProps = {\n    open: boolean;\n    onClose: () => void;\n    onDynamicTemplateSelect: (model: CmsModel) => void;\n    onStaticTemplateSelect: () => void;\n    existingDynamicTemplateModelIds: string[];\n};\n\nexport const CreateTemplateDialog: React.FC<CreateTemplateDialogProps> = ({\n    open,\n    onClose,\n    onDynamicTemplateSelect,\n    onStaticTemplateSelect,\n    existingDynamicTemplateModelIds\n}) => {\n    const [dynamicTemplateSelect, setDynamicTemplateSelect] = useState(false);\n    const { models, loading } = useModels();\n\n    return (\n        <Dialog open={open} className={dialogStyles} onClose={onClose}>\n            <DialogTitle>What type of a template you wish to create?</DialogTitle>\n            <DynamicTemplatesInfo>\n                Select a Headless Page Template for which you want to create a dynamic page\n                template:\n            </DynamicTemplatesInfo>\n            <DialogContent>\n                <div className=\"content-wrapper\" tabIndex={0}>\n                    {dynamicTemplateSelect ? (\n                        <>\n                            {loading && <CircularProgress />}\n                            <List>\n                                {models.map((model, index) => (\n                                    <HeadlessPageTemplateItem\n                                        key={index}\n                                        icon={<ModelIcon model={model} />}\n                                        name={model.name}\n                                        description={model.description}\n                                        highlight={\n                                            existingDynamicTemplateModelIds.some(\n                                                id => id === model.modelId\n                                            )\n                                                ? \"Template already exists, click to edit.\"\n                                                : undefined\n                                        }\n                                        onClick={() => onDynamicTemplateSelect(model)}\n                                    />\n                                ))}\n                            </List>\n                        </>\n                    ) : (\n                        <>\n                            <HeadlessPageTemplateItem\n                                icon={<ArticleIcon width={36} height={36} />}\n                                name={\"Static template\"}\n                                description={\"Used for creating new Page Builder pages.\"}\n                                onClick={onStaticTemplateSelect}\n                            />\n                            <HeadlessPageTemplateItem\n                                icon={<DatabaseIcon width={36} height={36} />}\n                                name={\"Dynamic template\"}\n                                description={\n                                    \"Used for auto-generating pages  from Headless CMS entries.\"\n                                }\n                                onClick={() => setDynamicTemplateSelect(true)}\n                                hasNestedFields\n                            />\n                            <Info>\n                                <InfoIcon />\n                                Click here to learn about different template types.\n                            </Info>\n                        </>\n                    )}\n                </div>\n            </DialogContent>\n            <DialogActions>\n                {dynamicTemplateSelect && (\n                    <ButtonDefault\n                        onClick={() => {\n                            setDynamicTemplateSelect(false);\n                        }}\n                        className={leftButton}\n                    >\n                        &lt; Go back\n                    </ButtonDefault>\n                )}\n                <DialogCancel onClick={onClose}>Cancel</DialogCancel>\n            </DialogActions>\n        </Dialog>\n    );\n};\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const Title = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1ualc002"
+} : {
+  target: "e1ualc002",
+  label: "Title"
+})(process.env.NODE_ENV === "production" ? {
+  name: "14is9qy",
+  styles: "font-size:20px"
+} : {
+  name: "14is9qy",
+  styles: "font-size:20px",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["CreateTemplateDialog.tsx"],"names":[],"mappings":"AAwEwB","file":"CreateTemplateDialog.tsx","sourcesContent":["import React, { useState } from \"react\";\nimport { css } from \"emotion\";\nimport styled from \"@emotion/styled\";\nimport { FontAwesomeIcon } from \"@fortawesome/react-fontawesome\";\nimport type { IconProp } from \"@fortawesome/fontawesome-svg-core\";\n\nimport { Icon } from \"@webiny/ui/Icon\";\nimport { ButtonDefault } from \"@webiny/ui/Button\";\nimport { List, ListItem } from \"@webiny/ui/List\";\nimport { Dialog, DialogTitle, DialogContent, DialogActions, DialogCancel } from \"@webiny/ui/Dialog\";\nimport { CircularProgress } from \"@webiny/ui/Progress\";\nimport { useModels } from \"@webiny/app-headless-cms\";\nimport type { CmsModel } from \"@webiny/app-headless-cms/types\";\n\nimport { ReactComponent as ArrowRightIcon } from \"@webiny/icons/keyboard_arrow_right.svg\";\nimport { ReactComponent as InfoIcon } from \"@webiny/icons/info.svg\";\nimport { ReactComponent as ArticleIcon } from \"@webiny/icons/article.svg\";\nimport { ReactComponent as DatabaseIcon } from \"@webiny/icons/dashboard.svg\";\n\nconst dialogStyles = css`\n    .mdc-dialog__surface {\n        width: 600px;\n        min-width: 600px;\n    }\n\n    .mdc-dialog__content {\n        padding-top: 0 !important;\n    }\n\n    .content-wrapper:focus-visible {\n        outline: none;\n    }\n`;\n\nconst Info = styled.div`\n    display: flex;\n    align-items: center;\n    padding: 12px;\n    margin-top: 12px;\n    background: var(--mdc-theme-background);\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n    cursor: pointer;\n\n    & svg {\n        margin-right: 12px;\n    }\n`;\n\nconst ListItemStyled = styled(ListItem)`\n    padding-top: 8px;\n    padding-bottom: 8px;\n    height: auto;\n    min-height: 64px;\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n\n    & svg {\n        flex-shrink: 0;\n    }\n\n    .arrow-right {\n        margin-left: auto;\n    }\n`;\n\nconst ListItemContent = styled.div`\n    display: grid;\n    padding-left: 21px;\n    padding-right: 21px;\n`;\n\nconst Title = styled.div`\n    font-size: 20px;\n`;\n\nconst Highlight = styled.div`\n    color: var(--mdc-theme-primary);\n`;\n\nconst DynamicTemplatesInfo = styled.div`\n    padding: 24px;\n    font-size: 20px;\n    line-height: 24px;\n    color: var(--mdc-theme-text-secondary-on-background);\n`;\n\nconst leftButton = css`\n    margin-right: auto;\n`;\n\ninterface ModelIconProps {\n    model: CmsModel;\n}\nconst ModelIcon: React.FC<ModelIconProps> = ({ model }) => {\n    return (\n        <FontAwesomeIcon\n            style={{ color: \"var(--mdc-theme-text-secondary-on-background)\" }}\n            icon={(model.icon || \"fas/star\").split(\"/\") as IconProp}\n            width={32}\n            size={\"2x\"}\n        />\n    );\n};\n\ntype HeadlessPageTemplateItemProps = {\n    icon: React.ReactElement<any>;\n    name: string;\n    description?: string;\n    highlight?: string;\n    onClick: () => void;\n    hasNestedFields?: boolean;\n};\n\nconst HeadlessPageTemplateItem: React.FC<HeadlessPageTemplateItemProps> = ({\n    icon,\n    name,\n    description,\n    highlight,\n    onClick,\n    hasNestedFields\n}) => {\n    return (\n        <ListItemStyled onClick={onClick}>\n            <Icon icon={icon} />\n            <ListItemContent>\n                <Title>{name}</Title>\n                {description}\n                <Highlight>{highlight}</Highlight>\n            </ListItemContent>\n            {hasNestedFields && <ArrowRightIcon className=\"arrow-right\" />}\n        </ListItemStyled>\n    );\n};\n\ntype CreateTemplateDialogProps = {\n    open: boolean;\n    onClose: () => void;\n    onDynamicTemplateSelect: (model: CmsModel) => void;\n    onStaticTemplateSelect: () => void;\n    existingDynamicTemplateModelIds: string[];\n};\n\nexport const CreateTemplateDialog: React.FC<CreateTemplateDialogProps> = ({\n    open,\n    onClose,\n    onDynamicTemplateSelect,\n    onStaticTemplateSelect,\n    existingDynamicTemplateModelIds\n}) => {\n    const [dynamicTemplateSelect, setDynamicTemplateSelect] = useState(false);\n    const { models, loading } = useModels();\n\n    return (\n        <Dialog open={open} className={dialogStyles} onClose={onClose}>\n            <DialogTitle>What type of a template you wish to create?</DialogTitle>\n            <DynamicTemplatesInfo>\n                Select a Headless Page Template for which you want to create a dynamic page\n                template:\n            </DynamicTemplatesInfo>\n            <DialogContent>\n                <div className=\"content-wrapper\" tabIndex={0}>\n                    {dynamicTemplateSelect ? (\n                        <>\n                            {loading && <CircularProgress />}\n                            <List>\n                                {models.map((model, index) => (\n                                    <HeadlessPageTemplateItem\n                                        key={index}\n                                        icon={<ModelIcon model={model} />}\n                                        name={model.name}\n                                        description={model.description}\n                                        highlight={\n                                            existingDynamicTemplateModelIds.some(\n                                                id => id === model.modelId\n                                            )\n                                                ? \"Template already exists, click to edit.\"\n                                                : undefined\n                                        }\n                                        onClick={() => onDynamicTemplateSelect(model)}\n                                    />\n                                ))}\n                            </List>\n                        </>\n                    ) : (\n                        <>\n                            <HeadlessPageTemplateItem\n                                icon={<ArticleIcon width={36} height={36} />}\n                                name={\"Static template\"}\n                                description={\"Used for creating new Page Builder pages.\"}\n                                onClick={onStaticTemplateSelect}\n                            />\n                            <HeadlessPageTemplateItem\n                                icon={<DatabaseIcon width={36} height={36} />}\n                                name={\"Dynamic template\"}\n                                description={\n                                    \"Used for auto-generating pages  from Headless CMS entries.\"\n                                }\n                                onClick={() => setDynamicTemplateSelect(true)}\n                                hasNestedFields\n                            />\n                            <Info>\n                                <InfoIcon />\n                                Click here to learn about different template types.\n                            </Info>\n                        </>\n                    )}\n                </div>\n            </DialogContent>\n            <DialogActions>\n                {dynamicTemplateSelect && (\n                    <ButtonDefault\n                        onClick={() => {\n                            setDynamicTemplateSelect(false);\n                        }}\n                        className={leftButton}\n                    >\n                        &lt; Go back\n                    </ButtonDefault>\n                )}\n                <DialogCancel onClick={onClose}>Cancel</DialogCancel>\n            </DialogActions>\n        </Dialog>\n    );\n};\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const Highlight = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1ualc001"
+} : {
+  target: "e1ualc001",
+  label: "Highlight"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1re7mf9",
+  styles: "color:var(--mdc-theme-primary)"
+} : {
+  name: "1re7mf9",
+  styles: "color:var(--mdc-theme-primary)",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["CreateTemplateDialog.tsx"],"names":[],"mappings":"AA4E4B","file":"CreateTemplateDialog.tsx","sourcesContent":["import React, { useState } from \"react\";\nimport { css } from \"emotion\";\nimport styled from \"@emotion/styled\";\nimport { FontAwesomeIcon } from \"@fortawesome/react-fontawesome\";\nimport type { IconProp } from \"@fortawesome/fontawesome-svg-core\";\n\nimport { Icon } from \"@webiny/ui/Icon\";\nimport { ButtonDefault } from \"@webiny/ui/Button\";\nimport { List, ListItem } from \"@webiny/ui/List\";\nimport { Dialog, DialogTitle, DialogContent, DialogActions, DialogCancel } from \"@webiny/ui/Dialog\";\nimport { CircularProgress } from \"@webiny/ui/Progress\";\nimport { useModels } from \"@webiny/app-headless-cms\";\nimport type { CmsModel } from \"@webiny/app-headless-cms/types\";\n\nimport { ReactComponent as ArrowRightIcon } from \"@webiny/icons/keyboard_arrow_right.svg\";\nimport { ReactComponent as InfoIcon } from \"@webiny/icons/info.svg\";\nimport { ReactComponent as ArticleIcon } from \"@webiny/icons/article.svg\";\nimport { ReactComponent as DatabaseIcon } from \"@webiny/icons/dashboard.svg\";\n\nconst dialogStyles = css`\n    .mdc-dialog__surface {\n        width: 600px;\n        min-width: 600px;\n    }\n\n    .mdc-dialog__content {\n        padding-top: 0 !important;\n    }\n\n    .content-wrapper:focus-visible {\n        outline: none;\n    }\n`;\n\nconst Info = styled.div`\n    display: flex;\n    align-items: center;\n    padding: 12px;\n    margin-top: 12px;\n    background: var(--mdc-theme-background);\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n    cursor: pointer;\n\n    & svg {\n        margin-right: 12px;\n    }\n`;\n\nconst ListItemStyled = styled(ListItem)`\n    padding-top: 8px;\n    padding-bottom: 8px;\n    height: auto;\n    min-height: 64px;\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n\n    & svg {\n        flex-shrink: 0;\n    }\n\n    .arrow-right {\n        margin-left: auto;\n    }\n`;\n\nconst ListItemContent = styled.div`\n    display: grid;\n    padding-left: 21px;\n    padding-right: 21px;\n`;\n\nconst Title = styled.div`\n    font-size: 20px;\n`;\n\nconst Highlight = styled.div`\n    color: var(--mdc-theme-primary);\n`;\n\nconst DynamicTemplatesInfo = styled.div`\n    padding: 24px;\n    font-size: 20px;\n    line-height: 24px;\n    color: var(--mdc-theme-text-secondary-on-background);\n`;\n\nconst leftButton = css`\n    margin-right: auto;\n`;\n\ninterface ModelIconProps {\n    model: CmsModel;\n}\nconst ModelIcon: React.FC<ModelIconProps> = ({ model }) => {\n    return (\n        <FontAwesomeIcon\n            style={{ color: \"var(--mdc-theme-text-secondary-on-background)\" }}\n            icon={(model.icon || \"fas/star\").split(\"/\") as IconProp}\n            width={32}\n            size={\"2x\"}\n        />\n    );\n};\n\ntype HeadlessPageTemplateItemProps = {\n    icon: React.ReactElement<any>;\n    name: string;\n    description?: string;\n    highlight?: string;\n    onClick: () => void;\n    hasNestedFields?: boolean;\n};\n\nconst HeadlessPageTemplateItem: React.FC<HeadlessPageTemplateItemProps> = ({\n    icon,\n    name,\n    description,\n    highlight,\n    onClick,\n    hasNestedFields\n}) => {\n    return (\n        <ListItemStyled onClick={onClick}>\n            <Icon icon={icon} />\n            <ListItemContent>\n                <Title>{name}</Title>\n                {description}\n                <Highlight>{highlight}</Highlight>\n            </ListItemContent>\n            {hasNestedFields && <ArrowRightIcon className=\"arrow-right\" />}\n        </ListItemStyled>\n    );\n};\n\ntype CreateTemplateDialogProps = {\n    open: boolean;\n    onClose: () => void;\n    onDynamicTemplateSelect: (model: CmsModel) => void;\n    onStaticTemplateSelect: () => void;\n    existingDynamicTemplateModelIds: string[];\n};\n\nexport const CreateTemplateDialog: React.FC<CreateTemplateDialogProps> = ({\n    open,\n    onClose,\n    onDynamicTemplateSelect,\n    onStaticTemplateSelect,\n    existingDynamicTemplateModelIds\n}) => {\n    const [dynamicTemplateSelect, setDynamicTemplateSelect] = useState(false);\n    const { models, loading } = useModels();\n\n    return (\n        <Dialog open={open} className={dialogStyles} onClose={onClose}>\n            <DialogTitle>What type of a template you wish to create?</DialogTitle>\n            <DynamicTemplatesInfo>\n                Select a Headless Page Template for which you want to create a dynamic page\n                template:\n            </DynamicTemplatesInfo>\n            <DialogContent>\n                <div className=\"content-wrapper\" tabIndex={0}>\n                    {dynamicTemplateSelect ? (\n                        <>\n                            {loading && <CircularProgress />}\n                            <List>\n                                {models.map((model, index) => (\n                                    <HeadlessPageTemplateItem\n                                        key={index}\n                                        icon={<ModelIcon model={model} />}\n                                        name={model.name}\n                                        description={model.description}\n                                        highlight={\n                                            existingDynamicTemplateModelIds.some(\n                                                id => id === model.modelId\n                                            )\n                                                ? \"Template already exists, click to edit.\"\n                                                : undefined\n                                        }\n                                        onClick={() => onDynamicTemplateSelect(model)}\n                                    />\n                                ))}\n                            </List>\n                        </>\n                    ) : (\n                        <>\n                            <HeadlessPageTemplateItem\n                                icon={<ArticleIcon width={36} height={36} />}\n                                name={\"Static template\"}\n                                description={\"Used for creating new Page Builder pages.\"}\n                                onClick={onStaticTemplateSelect}\n                            />\n                            <HeadlessPageTemplateItem\n                                icon={<DatabaseIcon width={36} height={36} />}\n                                name={\"Dynamic template\"}\n                                description={\n                                    \"Used for auto-generating pages  from Headless CMS entries.\"\n                                }\n                                onClick={() => setDynamicTemplateSelect(true)}\n                                hasNestedFields\n                            />\n                            <Info>\n                                <InfoIcon />\n                                Click here to learn about different template types.\n                            </Info>\n                        </>\n                    )}\n                </div>\n            </DialogContent>\n            <DialogActions>\n                {dynamicTemplateSelect && (\n                    <ButtonDefault\n                        onClick={() => {\n                            setDynamicTemplateSelect(false);\n                        }}\n                        className={leftButton}\n                    >\n                        &lt; Go back\n                    </ButtonDefault>\n                )}\n                <DialogCancel onClick={onClose}>Cancel</DialogCancel>\n            </DialogActions>\n        </Dialog>\n    );\n};\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const DynamicTemplatesInfo = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1ualc000"
+} : {
+  target: "e1ualc000",
+  label: "DynamicTemplatesInfo"
+})(process.env.NODE_ENV === "production" ? {
+  name: "17uojnc",
+  styles: "padding:24px;font-size:20px;line-height:24px;color:var(--mdc-theme-text-secondary-on-background)"
+} : {
+  name: "17uojnc",
+  styles: "padding:24px;font-size:20px;line-height:24px;color:var(--mdc-theme-text-secondary-on-background)",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["CreateTemplateDialog.tsx"],"names":[],"mappings":"AAgFuC","file":"CreateTemplateDialog.tsx","sourcesContent":["import React, { useState } from \"react\";\nimport { css } from \"emotion\";\nimport styled from \"@emotion/styled\";\nimport { FontAwesomeIcon } from \"@fortawesome/react-fontawesome\";\nimport type { IconProp } from \"@fortawesome/fontawesome-svg-core\";\n\nimport { Icon } from \"@webiny/ui/Icon\";\nimport { ButtonDefault } from \"@webiny/ui/Button\";\nimport { List, ListItem } from \"@webiny/ui/List\";\nimport { Dialog, DialogTitle, DialogContent, DialogActions, DialogCancel } from \"@webiny/ui/Dialog\";\nimport { CircularProgress } from \"@webiny/ui/Progress\";\nimport { useModels } from \"@webiny/app-headless-cms\";\nimport type { CmsModel } from \"@webiny/app-headless-cms/types\";\n\nimport { ReactComponent as ArrowRightIcon } from \"@webiny/icons/keyboard_arrow_right.svg\";\nimport { ReactComponent as InfoIcon } from \"@webiny/icons/info.svg\";\nimport { ReactComponent as ArticleIcon } from \"@webiny/icons/article.svg\";\nimport { ReactComponent as DatabaseIcon } from \"@webiny/icons/dashboard.svg\";\n\nconst dialogStyles = css`\n    .mdc-dialog__surface {\n        width: 600px;\n        min-width: 600px;\n    }\n\n    .mdc-dialog__content {\n        padding-top: 0 !important;\n    }\n\n    .content-wrapper:focus-visible {\n        outline: none;\n    }\n`;\n\nconst Info = styled.div`\n    display: flex;\n    align-items: center;\n    padding: 12px;\n    margin-top: 12px;\n    background: var(--mdc-theme-background);\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n    cursor: pointer;\n\n    & svg {\n        margin-right: 12px;\n    }\n`;\n\nconst ListItemStyled = styled(ListItem)`\n    padding-top: 8px;\n    padding-bottom: 8px;\n    height: auto;\n    min-height: 64px;\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n\n    & svg {\n        flex-shrink: 0;\n    }\n\n    .arrow-right {\n        margin-left: auto;\n    }\n`;\n\nconst ListItemContent = styled.div`\n    display: grid;\n    padding-left: 21px;\n    padding-right: 21px;\n`;\n\nconst Title = styled.div`\n    font-size: 20px;\n`;\n\nconst Highlight = styled.div`\n    color: var(--mdc-theme-primary);\n`;\n\nconst DynamicTemplatesInfo = styled.div`\n    padding: 24px;\n    font-size: 20px;\n    line-height: 24px;\n    color: var(--mdc-theme-text-secondary-on-background);\n`;\n\nconst leftButton = css`\n    margin-right: auto;\n`;\n\ninterface ModelIconProps {\n    model: CmsModel;\n}\nconst ModelIcon: React.FC<ModelIconProps> = ({ model }) => {\n    return (\n        <FontAwesomeIcon\n            style={{ color: \"var(--mdc-theme-text-secondary-on-background)\" }}\n            icon={(model.icon || \"fas/star\").split(\"/\") as IconProp}\n            width={32}\n            size={\"2x\"}\n        />\n    );\n};\n\ntype HeadlessPageTemplateItemProps = {\n    icon: React.ReactElement<any>;\n    name: string;\n    description?: string;\n    highlight?: string;\n    onClick: () => void;\n    hasNestedFields?: boolean;\n};\n\nconst HeadlessPageTemplateItem: React.FC<HeadlessPageTemplateItemProps> = ({\n    icon,\n    name,\n    description,\n    highlight,\n    onClick,\n    hasNestedFields\n}) => {\n    return (\n        <ListItemStyled onClick={onClick}>\n            <Icon icon={icon} />\n            <ListItemContent>\n                <Title>{name}</Title>\n                {description}\n                <Highlight>{highlight}</Highlight>\n            </ListItemContent>\n            {hasNestedFields && <ArrowRightIcon className=\"arrow-right\" />}\n        </ListItemStyled>\n    );\n};\n\ntype CreateTemplateDialogProps = {\n    open: boolean;\n    onClose: () => void;\n    onDynamicTemplateSelect: (model: CmsModel) => void;\n    onStaticTemplateSelect: () => void;\n    existingDynamicTemplateModelIds: string[];\n};\n\nexport const CreateTemplateDialog: React.FC<CreateTemplateDialogProps> = ({\n    open,\n    onClose,\n    onDynamicTemplateSelect,\n    onStaticTemplateSelect,\n    existingDynamicTemplateModelIds\n}) => {\n    const [dynamicTemplateSelect, setDynamicTemplateSelect] = useState(false);\n    const { models, loading } = useModels();\n\n    return (\n        <Dialog open={open} className={dialogStyles} onClose={onClose}>\n            <DialogTitle>What type of a template you wish to create?</DialogTitle>\n            <DynamicTemplatesInfo>\n                Select a Headless Page Template for which you want to create a dynamic page\n                template:\n            </DynamicTemplatesInfo>\n            <DialogContent>\n                <div className=\"content-wrapper\" tabIndex={0}>\n                    {dynamicTemplateSelect ? (\n                        <>\n                            {loading && <CircularProgress />}\n                            <List>\n                                {models.map((model, index) => (\n                                    <HeadlessPageTemplateItem\n                                        key={index}\n                                        icon={<ModelIcon model={model} />}\n                                        name={model.name}\n                                        description={model.description}\n                                        highlight={\n                                            existingDynamicTemplateModelIds.some(\n                                                id => id === model.modelId\n                                            )\n                                                ? \"Template already exists, click to edit.\"\n                                                : undefined\n                                        }\n                                        onClick={() => onDynamicTemplateSelect(model)}\n                                    />\n                                ))}\n                            </List>\n                        </>\n                    ) : (\n                        <>\n                            <HeadlessPageTemplateItem\n                                icon={<ArticleIcon width={36} height={36} />}\n                                name={\"Static template\"}\n                                description={\"Used for creating new Page Builder pages.\"}\n                                onClick={onStaticTemplateSelect}\n                            />\n                            <HeadlessPageTemplateItem\n                                icon={<DatabaseIcon width={36} height={36} />}\n                                name={\"Dynamic template\"}\n                                description={\n                                    \"Used for auto-generating pages  from Headless CMS entries.\"\n                                }\n                                onClick={() => setDynamicTemplateSelect(true)}\n                                hasNestedFields\n                            />\n                            <Info>\n                                <InfoIcon />\n                                Click here to learn about different template types.\n                            </Info>\n                        </>\n                    )}\n                </div>\n            </DialogContent>\n            <DialogActions>\n                {dynamicTemplateSelect && (\n                    <ButtonDefault\n                        onClick={() => {\n                            setDynamicTemplateSelect(false);\n                        }}\n                        className={leftButton}\n                    >\n                        &lt; Go back\n                    </ButtonDefault>\n                )}\n                <DialogCancel onClick={onClose}>Cancel</DialogCancel>\n            </DialogActions>\n        </Dialog>\n    );\n};\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const leftButton = css`
+    margin-right: auto;
+`;
+const ModelIcon = ({
+  model
+}) => {
+  return /*#__PURE__*/React.createElement(FontAwesomeIcon, {
+    style: {
+      color: "var(--mdc-theme-text-secondary-on-background)"
+    },
+    icon: (model.icon || "fas/star").split("/"),
+    width: 32,
+    size: "2x"
+  });
+};
+const HeadlessPageTemplateItem = ({
+  icon,
+  name,
+  description,
+  highlight,
+  onClick,
+  hasNestedFields
+}) => {
+  return /*#__PURE__*/React.createElement(ListItemStyled, {
+    onClick: onClick
+  }, /*#__PURE__*/React.createElement(Icon, {
+    icon: icon
+  }), /*#__PURE__*/React.createElement(ListItemContent, null, /*#__PURE__*/React.createElement(Title, null, name), description, /*#__PURE__*/React.createElement(Highlight, null, highlight)), hasNestedFields && /*#__PURE__*/React.createElement(ArrowRightIcon, {
+    className: "arrow-right"
+  }));
+};
+export const CreateTemplateDialog = ({
+  open,
+  onClose,
+  onDynamicTemplateSelect,
+  onStaticTemplateSelect,
+  existingDynamicTemplateModelIds
+}) => {
+  const [dynamicTemplateSelect, setDynamicTemplateSelect] = useState(false);
+  const {
+    models,
+    loading
+  } = useModels();
+  return /*#__PURE__*/React.createElement(Dialog, {
+    open: open,
+    className: dialogStyles,
+    onClose: onClose
+  }, /*#__PURE__*/React.createElement(DialogTitle, null, "What type of a template you wish to create?"), /*#__PURE__*/React.createElement(DynamicTemplatesInfo, null, "Select a Headless Page Template for which you want to create a dynamic page template:"), /*#__PURE__*/React.createElement(DialogContent, null, /*#__PURE__*/React.createElement("div", {
+    className: "content-wrapper",
+    tabIndex: 0
+  }, dynamicTemplateSelect ? /*#__PURE__*/React.createElement(React.Fragment, null, loading && /*#__PURE__*/React.createElement(CircularProgress, null), /*#__PURE__*/React.createElement(List, null, models.map((model, index) => /*#__PURE__*/React.createElement(HeadlessPageTemplateItem, {
+    key: index,
+    icon: /*#__PURE__*/React.createElement(ModelIcon, {
+      model: model
+    }),
+    name: model.name,
+    description: model.description,
+    highlight: existingDynamicTemplateModelIds.some(id => id === model.modelId) ? "Template already exists, click to edit." : undefined,
+    onClick: () => onDynamicTemplateSelect(model)
+  })))) : /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(HeadlessPageTemplateItem, {
+    icon: /*#__PURE__*/React.createElement(ArticleIcon, {
+      width: 36,
+      height: 36
+    }),
+    name: "Static template",
+    description: "Used for creating new Page Builder pages.",
+    onClick: onStaticTemplateSelect
+  }), /*#__PURE__*/React.createElement(HeadlessPageTemplateItem, {
+    icon: /*#__PURE__*/React.createElement(DatabaseIcon, {
+      width: 36,
+      height: 36
+    }),
+    name: "Dynamic template",
+    description: "Used for auto-generating pages  from Headless CMS entries.",
+    onClick: () => setDynamicTemplateSelect(true),
+    hasNestedFields: true
+  }), /*#__PURE__*/React.createElement(Info, null, /*#__PURE__*/React.createElement(InfoIcon, null), "Click here to learn about different template types.")))), /*#__PURE__*/React.createElement(DialogActions, null, dynamicTemplateSelect && /*#__PURE__*/React.createElement(ButtonDefault, {
+    onClick: () => {
+      setDynamicTemplateSelect(false);
+    },
+    className: leftButton
+  }, "< Go back"), /*#__PURE__*/React.createElement(DialogCancel, {
+    onClick: onClose
+  }, "Cancel")));
+};
+
+//# sourceMappingURL=CreateTemplateDialog.js.map

package/admin/PageTemplateDialog/CreateTemplateDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useState","css","FontAwesomeIcon","Icon","ButtonDefault","List","ListItem","Dialog","DialogTitle","DialogContent","DialogActions","DialogCancel","CircularProgress","useModels","ReactComponent","ArrowRightIcon","InfoIcon","ArticleIcon","DatabaseIcon","dialogStyles","Info","_styled","process","env","NODE_ENV","target","label","name","styles","map","toString","_EMOTION_STRINGIFIED_CSS_ERROR__","ListItemStyled","ListItemContent","Title","Highlight","DynamicTemplatesInfo","leftButton","ModelIcon","model","createElement","style","color","icon","split","width","size","HeadlessPageTemplateItem","description","highlight","onClick","hasNestedFields","className","CreateTemplateDialog","open","onClose","onDynamicTemplateSelect","onStaticTemplateSelect","existingDynamicTemplateModelIds","dynamicTemplateSelect","setDynamicTemplateSelect","models","loading","tabIndex","Fragment","index","key","some","id","modelId","undefined","height"],"sources":["CreateTemplateDialog.tsx"],"sourcesContent":["import React, { useState } from \"react\";\nimport { css } from \"emotion\";\nimport styled from \"@emotion/styled\";\nimport { FontAwesomeIcon } from \"@fortawesome/react-fontawesome\";\nimport type { IconProp } from \"@fortawesome/fontawesome-svg-core\";\n\nimport { Icon } from \"@webiny/ui/Icon\";\nimport { ButtonDefault } from \"@webiny/ui/Button\";\nimport { List, ListItem } from \"@webiny/ui/List\";\nimport { Dialog, DialogTitle, DialogContent, DialogActions, DialogCancel } from \"@webiny/ui/Dialog\";\nimport { CircularProgress } from \"@webiny/ui/Progress\";\nimport { useModels } from \"@webiny/app-headless-cms\";\nimport type { CmsModel } from \"@webiny/app-headless-cms/types\";\n\nimport { ReactComponent as ArrowRightIcon } from \"@webiny/icons/keyboard_arrow_right.svg\";\nimport { ReactComponent as InfoIcon } from \"@webiny/icons/info.svg\";\nimport { ReactComponent as ArticleIcon } from \"@webiny/icons/article.svg\";\nimport { ReactComponent as DatabaseIcon } from \"@webiny/icons/dashboard.svg\";\n\nconst dialogStyles = css`\n    .mdc-dialog__surface {\n        width: 600px;\n        min-width: 600px;\n    }\n\n    .mdc-dialog__content {\n        padding-top: 0 !important;\n    }\n\n    .content-wrapper:focus-visible {\n        outline: none;\n    }\n`;\n\nconst Info = styled.div`\n    display: flex;\n    align-items: center;\n    padding: 12px;\n    margin-top: 12px;\n    background: var(--mdc-theme-background);\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n    cursor: pointer;\n\n    & svg {\n        margin-right: 12px;\n    }\n`;\n\nconst ListItemStyled = styled(ListItem)`\n    padding-top: 8px;\n    padding-bottom: 8px;\n    height: auto;\n    min-height: 64px;\n    color: var(--mdc-theme-text-secondary-on-background);\n    fill: var(--mdc-theme-text-secondary-on-background);\n\n    & svg {\n        flex-shrink: 0;\n    }\n\n    .arrow-right {\n        margin-left: auto;\n    }\n`;\n\nconst ListItemContent = styled.div`\n    display: grid;\n    padding-left: 21px;\n    padding-right: 21px;\n`;\n\nconst Title = styled.div`\n    font-size: 20px;\n`;\n\nconst Highlight = styled.div`\n    color: var(--mdc-theme-primary);\n`;\n\nconst DynamicTemplatesInfo = styled.div`\n    padding: 24px;\n    font-size: 20px;\n    line-height: 24px;\n    color: var(--mdc-theme-text-secondary-on-background);\n`;\n\nconst leftButton = css`\n    margin-right: auto;\n`;\n\ninterface ModelIconProps {\n    model: CmsModel;\n}\nconst ModelIcon: React.FC<ModelIconProps> = ({ model }) => {\n    return (\n        <FontAwesomeIcon\n            style={{ color: \"var(--mdc-theme-text-secondary-on-background)\" }}\n            icon={(model.icon || \"fas/star\").split(\"/\") as IconProp}\n            width={32}\n            size={\"2x\"}\n        />\n    );\n};\n\ntype HeadlessPageTemplateItemProps = {\n    icon: React.ReactElement<any>;\n    name: string;\n    description?: string;\n    highlight?: string;\n    onClick: () => void;\n    hasNestedFields?: boolean;\n};\n\nconst HeadlessPageTemplateItem: React.FC<HeadlessPageTemplateItemProps> = ({\n    icon,\n    name,\n    description,\n    highlight,\n    onClick,\n    hasNestedFields\n}) => {\n    return (\n        <ListItemStyled onClick={onClick}>\n            <Icon icon={icon} />\n            <ListItemContent>\n                <Title>{name}</Title>\n                {description}\n                <Highlight>{highlight}</Highlight>\n            </ListItemContent>\n            {hasNestedFields && <ArrowRightIcon className=\"arrow-right\" />}\n        </ListItemStyled>\n    );\n};\n\ntype CreateTemplateDialogProps = {\n    open: boolean;\n    onClose: () => void;\n    onDynamicTemplateSelect: (model: CmsModel) => void;\n    onStaticTemplateSelect: () => void;\n    existingDynamicTemplateModelIds: string[];\n};\n\nexport const CreateTemplateDialog: React.FC<CreateTemplateDialogProps> = ({\n    open,\n    onClose,\n    onDynamicTemplateSelect,\n    onStaticTemplateSelect,\n    existingDynamicTemplateModelIds\n}) => {\n    const [dynamicTemplateSelect, setDynamicTemplateSelect] = useState(false);\n    const { models, loading } = useModels();\n\n    return (\n        <Dialog open={open} className={dialogStyles} onClose={onClose}>\n            <DialogTitle>What type of a template you wish to create?</DialogTitle>\n            <DynamicTemplatesInfo>\n                Select a Headless Page Template for which you want to create a dynamic page\n                template:\n            </DynamicTemplatesInfo>\n            <DialogContent>\n                <div className=\"content-wrapper\" tabIndex={0}>\n                    {dynamicTemplateSelect ? (\n                        <>\n                            {loading && <CircularProgress />}\n                            <List>\n                                {models.map((model, index) => (\n                                    <HeadlessPageTemplateItem\n                                        key={index}\n                                        icon={<ModelIcon model={model} />}\n                                        name={model.name}\n                                        description={model.description}\n                                        highlight={\n                                            existingDynamicTemplateModelIds.some(\n                                                id => id === model.modelId\n                                            )\n                                                ? \"Template already exists, click to edit.\"\n                                                : undefined\n                                        }\n                                        onClick={() => onDynamicTemplateSelect(model)}\n                                    />\n                                ))}\n                            </List>\n                        </>\n                    ) : (\n                        <>\n                            <HeadlessPageTemplateItem\n                                icon={<ArticleIcon width={36} height={36} />}\n                                name={\"Static template\"}\n                                description={\"Used for creating new Page Builder pages.\"}\n                                onClick={onStaticTemplateSelect}\n                            />\n                            <HeadlessPageTemplateItem\n                                icon={<DatabaseIcon width={36} height={36} />}\n                                name={\"Dynamic template\"}\n                                description={\n                                    \"Used for auto-generating pages  from Headless CMS entries.\"\n                                }\n                                onClick={() => setDynamicTemplateSelect(true)}\n                                hasNestedFields\n                            />\n                            <Info>\n                                <InfoIcon />\n                                Click here to learn about different template types.\n                            </Info>\n                        </>\n                    )}\n                </div>\n            </DialogContent>\n            <DialogActions>\n                {dynamicTemplateSelect && (\n                    <ButtonDefault\n                        onClick={() => {\n                            setDynamicTemplateSelect(false);\n                        }}\n                        className={leftButton}\n                    >\n                        &lt; Go back\n                    </ButtonDefault>\n                )}\n                <DialogCancel onClick={onClose}>Cancel</DialogCancel>\n            </DialogActions>\n        </Dialog>\n    );\n};\n"],"mappings":"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","ignoreList":[]}

package/admin/PageTemplateDialog/PageTemplateDialog.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const PageTemplateDialog: (props: unknown) => React.JSX.Element;

package/admin/PageTemplateDialog/PageTemplateDialog.js

@@ -0,0 +1,44 @@
+import React, { useState, useCallback } from "react";
+import { useSnackbar } from "@webiny/app-admin";
+import { useRouter } from "@webiny/react-router";
+import { CreatePageTemplateDialog } from "@webiny/app-page-builder/admin/views/PageTemplates/CreatePageTemplateDialog";
+import { CreateTemplateDialog } from "./CreateTemplateDialog";
+import { useCreateDynamicPageTemplate } from "../../features/pageTemplate/createDynamicTemplate/useCreateDynamicTemplate";
+export const PageTemplateDialog = CreatePageTemplateDialog.createDecorator(Original => {
+  return function CreatePageTemplateDialog(props) {
+    const {
+      history
+    } = useRouter();
+    const {
+      showSnackbar
+    } = useSnackbar();
+    const {
+      createDynamicPageTemplate
+    } = useCreateDynamicPageTemplate();
+    const [showStaticTemplateDialog, setShowStaticTemplateDialog] = useState(false);
+    const createTemplate = useCallback(async model => {
+      try {
+        const template = await createDynamicPageTemplate(model);
+        history.push(`/page-builder/template-editor/${template.id}`);
+      } catch (error) {
+        showSnackbar(error.message);
+      }
+    }, []);
+    const onClose = useCallback(() => {
+      setShowStaticTemplateDialog(false);
+      props.onClose();
+    }, [props.onClose]);
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Original, Object.assign({}, props, {
+      open: showStaticTemplateDialog,
+      onClose: onClose
+    })), /*#__PURE__*/React.createElement(CreateTemplateDialog, {
+      open: props.open && !showStaticTemplateDialog,
+      onClose: props.onClose,
+      onDynamicTemplateSelect: createTemplate,
+      onStaticTemplateSelect: () => setShowStaticTemplateDialog(true),
+      existingDynamicTemplateModelIds: []
+    }));
+  };
+});
+
+//# sourceMappingURL=PageTemplateDialog.js.map

package/admin/PageTemplateDialog/PageTemplateDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useState","useCallback","useSnackbar","useRouter","CreatePageTemplateDialog","CreateTemplateDialog","useCreateDynamicPageTemplate","PageTemplateDialog","createDecorator","Original","props","history","showSnackbar","createDynamicPageTemplate","showStaticTemplateDialog","setShowStaticTemplateDialog","createTemplate","model","template","push","id","error","message","onClose","createElement","Fragment","Object","assign","open","onDynamicTemplateSelect","onStaticTemplateSelect","existingDynamicTemplateModelIds"],"sources":["PageTemplateDialog.tsx"],"sourcesContent":["import React, { useState, useCallback } from \"react\";\nimport { useSnackbar } from \"@webiny/app-admin\";\nimport { useRouter } from \"@webiny/react-router\";\nimport type { CmsModel } from \"@webiny/app-headless-cms/types\";\nimport { CreatePageTemplateDialog } from \"@webiny/app-page-builder/admin/views/PageTemplates/CreatePageTemplateDialog\";\nimport { CreateTemplateDialog } from \"~/admin/PageTemplateDialog/CreateTemplateDialog\";\nimport { useCreateDynamicPageTemplate } from \"~/features/pageTemplate/createDynamicTemplate/useCreateDynamicTemplate\";\n\nexport const PageTemplateDialog = CreatePageTemplateDialog.createDecorator(Original => {\n    return function CreatePageTemplateDialog(props) {\n        const { history } = useRouter();\n        const { showSnackbar } = useSnackbar();\n        const { createDynamicPageTemplate } = useCreateDynamicPageTemplate();\n        const [showStaticTemplateDialog, setShowStaticTemplateDialog] = useState(false);\n\n        const createTemplate = useCallback(async (model: CmsModel) => {\n            try {\n                const template = await createDynamicPageTemplate(model);\n                history.push(`/page-builder/template-editor/${template.id}`);\n            } catch (error) {\n                showSnackbar(error.message);\n            }\n        }, []);\n\n        const onClose = useCallback(() => {\n            setShowStaticTemplateDialog(false);\n            props.onClose();\n        }, [props.onClose]);\n\n        return (\n            <>\n                <Original {...props} open={showStaticTemplateDialog} onClose={onClose} />\n                <CreateTemplateDialog\n                    open={props.open && !showStaticTemplateDialog}\n                    onClose={props.onClose}\n                    onDynamicTemplateSelect={createTemplate}\n                    onStaticTemplateSelect={() => setShowStaticTemplateDialog(true)}\n                    existingDynamicTemplateModelIds={[]}\n                />\n            </>\n        );\n    };\n});\n"],"mappings":"AAAA,OAAOA,KAAK,IAAIC,QAAQ,EAAEC,WAAW,QAAQ,OAAO;AACpD,SAASC,WAAW,QAAQ,mBAAmB;AAC/C,SAASC,SAAS,QAAQ,sBAAsB;AAEhD,SAASC,wBAAwB,QAAQ,6EAA6E;AACtH,SAASC,oBAAoB;AAC7B,SAASC,4BAA4B;AAErC,OAAO,MAAMC,kBAAkB,GAAGH,wBAAwB,CAACI,eAAe,CAACC,QAAQ,IAAI;EACnF,OAAO,SAASL,wBAAwBA,CAACM,KAAK,EAAE;IAC5C,MAAM;MAAEC;IAAQ,CAAC,GAAGR,SAAS,CAAC,CAAC;IAC/B,MAAM;MAAES;IAAa,CAAC,GAAGV,WAAW,CAAC,CAAC;IACtC,MAAM;MAAEW;IAA0B,CAAC,GAAGP,4BAA4B,CAAC,CAAC;IACpE,MAAM,CAACQ,wBAAwB,EAAEC,2BAA2B,CAAC,GAAGf,QAAQ,CAAC,KAAK,CAAC;IAE/E,MAAMgB,cAAc,GAAGf,WAAW,CAAC,MAAOgB,KAAe,IAAK;MAC1D,IAAI;QACA,MAAMC,QAAQ,GAAG,MAAML,yBAAyB,CAACI,KAAK,CAAC;QACvDN,OAAO,CAACQ,IAAI,CAAC,iCAAiCD,QAAQ,CAACE,EAAE,EAAE,CAAC;MAChE,CAAC,CAAC,OAAOC,KAAK,EAAE;QACZT,YAAY,CAACS,KAAK,CAACC,OAAO,CAAC;MAC/B;IACJ,CAAC,EAAE,EAAE,CAAC;IAEN,MAAMC,OAAO,GAAGtB,WAAW,CAAC,MAAM;MAC9Bc,2BAA2B,CAAC,KAAK,CAAC;MAClCL,KAAK,CAACa,OAAO,CAAC,CAAC;IACnB,CAAC,EAAE,CAACb,KAAK,CAACa,OAAO,CAAC,CAAC;IAEnB,oBACIxB,KAAA,CAAAyB,aAAA,CAAAzB,KAAA,CAAA0B,QAAA,qBACI1B,KAAA,CAAAyB,aAAA,CAACf,QAAQ,EAAAiB,MAAA,CAAAC,MAAA,KAAKjB,KAAK;MAAEkB,IAAI,EAAEd,wBAAyB;MAACS,OAAO,EAAEA;IAAQ,EAAE,CAAC,eACzExB,KAAA,CAAAyB,aAAA,CAACnB,oBAAoB;MACjBuB,IAAI,EAAElB,KAAK,CAACkB,IAAI,IAAI,CAACd,wBAAyB;MAC9CS,OAAO,EAAEb,KAAK,CAACa,OAAQ;MACvBM,uBAAuB,EAAEb,cAAe;MACxCc,sBAAsB,EAAEA,CAAA,KAAMf,2BAA2B,CAAC,IAAI,CAAE;MAChEgB,+BAA+B,EAAE;IAAG,CACvC,CACH,CAAC;EAEX,CAAC;AACL,CAAC,CAAC","ignoreList":[]}

package/admin/SetupDynamicPages.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const SetupDynamicPages: () => React.JSX.Element;

package/admin/SetupDynamicPages.js

@@ -0,0 +1,16 @@
+import React from "react";
+import { PageTemplateDialog } from "./PageTemplateDialog/PageTemplateDialog";
+import { DynamicTemplateEditorConfig } from "./templateEditor/DynamicTemplateEditorConfig";
+import { AddPreviewPane } from "./ContentEntryForm/AddPreviewPane";
+import { PassEntryToDataSource } from "./ContentEntryForm/PassEntryToDataSource";
+import { Elements } from "./elements/Elements";
+import { DynamicPageEditorConfig } from "./pageEditor/DynamicPageEditorConfig";
+import { DynamicElementRenderers } from "../dataInjection/renderers/DynamicElementRenderers";
+import { ContentEntryEditorConfig } from "@webiny/app-headless-cms";
+import { WebsiteDataInjection } from "@webiny/app-page-builder/dataInjection/presets/WebsiteDataInjection";
+import { AddEntriesListDataSourceContext } from "../dataInjection/AddEntriesListDataSourceContext";
+export const SetupDynamicPages = () => {
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Elements, null), /*#__PURE__*/React.createElement(PageTemplateDialog, null), /*#__PURE__*/React.createElement(DynamicTemplateEditorConfig, null), /*#__PURE__*/React.createElement(DynamicPageEditorConfig, null), /*#__PURE__*/React.createElement(AddPreviewPane, null), /*#__PURE__*/React.createElement(PassEntryToDataSource, null), /*#__PURE__*/React.createElement(DynamicElementRenderers, null), /*#__PURE__*/React.createElement(ContentEntryEditorConfig, null, /*#__PURE__*/React.createElement(WebsiteDataInjection, null), /*#__PURE__*/React.createElement(AddEntriesListDataSourceContext, null)));
+};
+
+//# sourceMappingURL=SetupDynamicPages.js.map

package/admin/SetupDynamicPages.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","PageTemplateDialog","DynamicTemplateEditorConfig","AddPreviewPane","PassEntryToDataSource","Elements","DynamicPageEditorConfig","DynamicElementRenderers","ContentEntryEditorConfig","WebsiteDataInjection","AddEntriesListDataSourceContext","SetupDynamicPages","createElement","Fragment"],"sources":["SetupDynamicPages.tsx"],"sourcesContent":["import React from \"react\";\nimport { PageTemplateDialog } from \"~/admin/PageTemplateDialog/PageTemplateDialog\";\nimport { DynamicTemplateEditorConfig } from \"~/admin/templateEditor/DynamicTemplateEditorConfig\";\nimport { AddPreviewPane } from \"~/admin/ContentEntryForm/AddPreviewPane\";\nimport { PassEntryToDataSource } from \"~/admin/ContentEntryForm/PassEntryToDataSource\";\nimport { Elements } from \"~/admin/elements/Elements\";\nimport { DynamicPageEditorConfig } from \"~/admin/pageEditor/DynamicPageEditorConfig\";\nimport { DynamicElementRenderers } from \"~/dataInjection/renderers/DynamicElementRenderers\";\nimport { ContentEntryEditorConfig } from \"@webiny/app-headless-cms\";\nimport { WebsiteDataInjection } from \"@webiny/app-page-builder/dataInjection/presets/WebsiteDataInjection\";\nimport { AddEntriesListDataSourceContext } from \"~/dataInjection/AddEntriesListDataSourceContext\";\n\nexport const SetupDynamicPages = () => {\n    return (\n        <>\n            {/* Register editor elements plugins. */}\n            <Elements />\n\n            {/* Decorate page template dialog. */}\n            <PageTemplateDialog />\n\n            {/* Configure Template editor. */}\n            <DynamicTemplateEditorConfig />\n\n            {/* Configure Page editor. */}\n            <DynamicPageEditorConfig />\n\n            {/* Enable live preview in the CMS entry form. */}\n            <AddPreviewPane />\n\n            <PassEntryToDataSource />\n\n            {/* Register element renderers and decorators. */}\n            <DynamicElementRenderers />\n\n            {/* Add website-style data binding to page preview. */}\n            <ContentEntryEditorConfig>\n                <WebsiteDataInjection />\n                <AddEntriesListDataSourceContext />\n            </ContentEntryEditorConfig>\n        </>\n    );\n};\n"],"mappings":"AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,SAASC,kBAAkB;AAC3B,SAASC,2BAA2B;AACpC,SAASC,cAAc;AACvB,SAASC,qBAAqB;AAC9B,SAASC,QAAQ;AACjB,SAASC,uBAAuB;AAChC,SAASC,uBAAuB;AAChC,SAASC,wBAAwB,QAAQ,0BAA0B;AACnE,SAASC,oBAAoB,QAAQ,qEAAqE;AAC1G,SAASC,+BAA+B;AAExC,OAAO,MAAMC,iBAAiB,GAAGA,CAAA,KAAM;EACnC,oBACIX,KAAA,CAAAY,aAAA,CAAAZ,KAAA,CAAAa,QAAA,qBAEIb,KAAA,CAAAY,aAAA,CAACP,QAAQ,MAAE,CAAC,eAGZL,KAAA,CAAAY,aAAA,CAACX,kBAAkB,MAAE,CAAC,eAGtBD,KAAA,CAAAY,aAAA,CAACV,2BAA2B,MAAE,CAAC,eAG/BF,KAAA,CAAAY,aAAA,CAACN,uBAAuB,MAAE,CAAC,eAG3BN,KAAA,CAAAY,aAAA,CAACT,cAAc,MAAE,CAAC,eAElBH,KAAA,CAAAY,aAAA,CAACR,qBAAqB,MAAE,CAAC,eAGzBJ,KAAA,CAAAY,aAAA,CAACL,uBAAuB,MAAE,CAAC,eAG3BP,KAAA,CAAAY,aAAA,CAACJ,wBAAwB,qBACrBR,KAAA,CAAAY,aAAA,CAACH,oBAAoB,MAAE,CAAC,eACxBT,KAAA,CAAAY,aAAA,CAACF,+BAA+B,MAAE,CACZ,CAC5B,CAAC;AAEX,CAAC","ignoreList":[]}

package/admin/elements/Elements.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const Elements: React.NamedExoticComponent<object>;

package/admin/elements/Elements.js

@@ -0,0 +1,12 @@
+import React from "react";
+import { plugins } from "@webiny/plugins";
+import { createRepeaterElement } from "./repeater";
+import { createEntriesListElement } from "./entriesList";
+import { DynamicGrid } from "./renderers/DynamicGrid";
+import { createEntriesSearchElement } from "./entriesSearch";
+export const Elements = /*#__PURE__*/React.memo(function Elements() {
+  plugins.register(createRepeaterElement(), createEntriesListElement(), createEntriesSearchElement());
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(DynamicGrid, null));
+});
+
+//# sourceMappingURL=Elements.js.map

package/admin/elements/Elements.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","plugins","createRepeaterElement","createEntriesListElement","DynamicGrid","createEntriesSearchElement","Elements","memo","register","createElement","Fragment"],"sources":["Elements.tsx"],"sourcesContent":["import React from \"react\";\nimport { plugins } from \"@webiny/plugins\";\nimport { createRepeaterElement } from \"~/admin/elements/repeater\";\nimport { createEntriesListElement } from \"~/admin/elements/entriesList\";\nimport { DynamicGrid } from \"./renderers/DynamicGrid\";\nimport { createEntriesSearchElement } from \"~/admin/elements/entriesSearch\";\n\nexport const Elements = React.memo(function Elements() {\n    plugins.register(\n        createRepeaterElement(),\n        createEntriesListElement(),\n        createEntriesSearchElement()\n    );\n\n    return (\n        <>\n            <DynamicGrid />\n        </>\n    );\n});\n"],"mappings":"AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,SAASC,OAAO,QAAQ,iBAAiB;AACzC,SAASC,qBAAqB;AAC9B,SAASC,wBAAwB;AACjC,SAASC,WAAW;AACpB,SAASC,0BAA0B;AAEnC,OAAO,MAAMC,QAAQ,gBAAGN,KAAK,CAACO,IAAI,CAAC,SAASD,QAAQA,CAAA,EAAG;EACnDL,OAAO,CAACO,QAAQ,CACZN,qBAAqB,CAAC,CAAC,EACvBC,wBAAwB,CAAC,CAAC,EAC1BE,0BAA0B,CAAC,CAC/B,CAAC;EAED,oBACIL,KAAA,CAAAS,aAAA,CAAAT,KAAA,CAAAU,QAAA,qBACIV,KAAA,CAAAS,aAAA,CAACL,WAAW,MAAE,CAChB,CAAC;AAEX,CAAC,CAAC","ignoreList":[]}

package/admin/elements/entriesList.d.ts

@@ -0,0 +1,2 @@
+import type { PbEditorPageElementPlugin } from "@webiny/app-page-builder/types";
+export declare const createEntriesListElement: () => PbEditorPageElementPlugin;

package/admin/elements/entriesList.js

@@ -0,0 +1,35 @@
+import React from "react";
+import { ReactComponent as RepeatIcon } from "@webiny/icons/repeat.svg";
+import { AdminEntriesListRenderer } from "./renderers/EntriesList";
+import { createElement } from "@webiny/app-page-builder/editor/helpers";
+export const createEntriesListElement = () => {
+  return {
+    name: `pb-editor-page-element-entries-list`,
+    type: "pb-editor-page-element",
+    elementType: "entries-list",
+    canReceiveChildren: true,
+    toolbar: {
+      title: "Entries List",
+      group: "pb-editor-element-group-basic",
+      preview() {
+        return /*#__PURE__*/React.createElement(RepeatIcon, null);
+      }
+    },
+    settings: ["pb-editor-page-element-settings-clone", "pb-editor-page-element-settings-delete"],
+    target: ["cell", "block"],
+    create() {
+      return {
+        type: this.elementType,
+        elements: [createElement("grid")],
+        data: {}
+      };
+    },
+    render(props) {
+      return /*#__PURE__*/React.createElement(AdminEntriesListRenderer, Object.assign({}, props, {
+        element: props.element
+      }));
+    }
+  };
+};
+
+//# sourceMappingURL=entriesList.js.map

package/admin/elements/entriesList.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","ReactComponent","RepeatIcon","AdminEntriesListRenderer","createElement","createEntriesListElement","name","type","elementType","canReceiveChildren","toolbar","title","group","preview","settings","target","create","elements","data","render","props","Object","assign","element"],"sources":["entriesList.tsx"],"sourcesContent":["import React from \"react\";\nimport { ReactComponent as RepeatIcon } from \"@webiny/icons/repeat.svg\";\nimport type { PbEditorPageElementPlugin, PbElement } from \"@webiny/app-page-builder/types\";\nimport { AdminEntriesListRenderer } from \"./renderers/EntriesList\";\nimport { createElement } from \"@webiny/app-page-builder/editor/helpers\";\n\nexport const createEntriesListElement = (): PbEditorPageElementPlugin => {\n    return {\n        name: `pb-editor-page-element-entries-list`,\n        type: \"pb-editor-page-element\",\n        elementType: \"entries-list\",\n        canReceiveChildren: true,\n        toolbar: {\n            title: \"Entries List\",\n            group: \"pb-editor-element-group-basic\",\n            preview() {\n                return <RepeatIcon />;\n            }\n        },\n        settings: [\n            \"pb-editor-page-element-settings-clone\",\n            \"pb-editor-page-element-settings-delete\"\n        ],\n        target: [\"cell\", \"block\"],\n        create() {\n            return {\n                type: this.elementType,\n                elements: [createElement(\"grid\")],\n                data: {}\n            };\n        },\n\n        render(props) {\n            return <AdminEntriesListRenderer {...props} element={props.element as PbElement} />;\n        }\n    };\n};\n"],"mappings":"AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,SAASC,cAAc,IAAIC,UAAU,QAAQ,0BAA0B;AAEvE,SAASC,wBAAwB;AACjC,SAASC,aAAa,QAAQ,yCAAyC;AAEvE,OAAO,MAAMC,wBAAwB,GAAGA,CAAA,KAAiC;EACrE,OAAO;IACHC,IAAI,EAAE,qCAAqC;IAC3CC,IAAI,EAAE,wBAAwB;IAC9BC,WAAW,EAAE,cAAc;IAC3BC,kBAAkB,EAAE,IAAI;IACxBC,OAAO,EAAE;MACLC,KAAK,EAAE,cAAc;MACrBC,KAAK,EAAE,+BAA+B;MACtCC,OAAOA,CAAA,EAAG;QACN,oBAAOb,KAAA,CAAAI,aAAA,CAACF,UAAU,MAAE,CAAC;MACzB;IACJ,CAAC;IACDY,QAAQ,EAAE,CACN,uCAAuC,EACvC,wCAAwC,CAC3C;IACDC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;IACzBC,MAAMA,CAAA,EAAG;MACL,OAAO;QACHT,IAAI,EAAE,IAAI,CAACC,WAAW;QACtBS,QAAQ,EAAE,CAACb,aAAa,CAAC,MAAM,CAAC,CAAC;QACjCc,IAAI,EAAE,CAAC;MACX,CAAC;IACL,CAAC;IAEDC,MAAMA,CAACC,KAAK,EAAE;MACV,oBAAOpB,KAAA,CAAAI,aAAA,CAACD,wBAAwB,EAAAkB,MAAA,CAAAC,MAAA,KAAKF,KAAK;QAAEG,OAAO,EAAEH,KAAK,CAACG;MAAqB,EAAE,CAAC;IACvF;EACJ,CAAC;AACL,CAAC","ignoreList":[]}

package/admin/elements/entriesSearch.d.ts

@@ -0,0 +1,2 @@
+import type { PbEditorPageElementPlugin } from "@webiny/app-page-builder/types";
+export declare const createEntriesSearchElement: () => PbEditorPageElementPlugin;

package/admin/elements/entriesSearch.js

@@ -0,0 +1,34 @@
+import React from "react";
+import { ReactComponent as RepeatIcon } from "@webiny/icons/repeat.svg";
+import { EntriesSearchRenderer } from "../../dataInjection/renderers/EntriesSearch";
+export const createEntriesSearchElement = () => {
+  return {
+    name: `pb-editor-page-element-entries-search`,
+    type: "pb-editor-page-element",
+    elementType: "entries-search",
+    canReceiveChildren: false,
+    toolbar: {
+      title: "Entries Search",
+      group: "pb-editor-element-group-basic",
+      preview() {
+        return /*#__PURE__*/React.createElement(RepeatIcon, null);
+      }
+    },
+    settings: ["pb-editor-page-element-settings-delete"],
+    target: ["cell"],
+    create() {
+      return {
+        type: this.elementType,
+        elements: [],
+        data: {}
+      };
+    },
+    render(props) {
+      return /*#__PURE__*/React.createElement(EntriesSearchRenderer, Object.assign({}, props, {
+        element: props.element
+      }));
+    }
+  };
+};
+
+//# sourceMappingURL=entriesSearch.js.map

package/admin/elements/entriesSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","ReactComponent","RepeatIcon","EntriesSearchRenderer","createEntriesSearchElement","name","type","elementType","canReceiveChildren","toolbar","title","group","preview","createElement","settings","target","create","elements","data","render","props","Object","assign","element"],"sources":["entriesSearch.tsx"],"sourcesContent":["import React from \"react\";\nimport { ReactComponent as RepeatIcon } from \"@webiny/icons/repeat.svg\";\nimport type { PbEditorPageElementPlugin, PbElement } from \"@webiny/app-page-builder/types\";\nimport { EntriesSearchRenderer } from \"~/dataInjection/renderers/EntriesSearch\";\n\nexport const createEntriesSearchElement = (): PbEditorPageElementPlugin => {\n    return {\n        name: `pb-editor-page-element-entries-search`,\n        type: \"pb-editor-page-element\",\n        elementType: \"entries-search\",\n        canReceiveChildren: false,\n        toolbar: {\n            title: \"Entries Search\",\n            group: \"pb-editor-element-group-basic\",\n            preview() {\n                return <RepeatIcon />;\n            }\n        },\n        settings: [\"pb-editor-page-element-settings-delete\"],\n        target: [\"cell\"],\n        create() {\n            return {\n                type: this.elementType,\n                elements: [],\n                data: {}\n            };\n        },\n\n        render(props) {\n            return <EntriesSearchRenderer {...props} element={props.element as PbElement} />;\n        }\n    };\n};\n"],"mappings":"AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,SAASC,cAAc,IAAIC,UAAU,QAAQ,0BAA0B;AAEvE,SAASC,qBAAqB;AAE9B,OAAO,MAAMC,0BAA0B,GAAGA,CAAA,KAAiC;EACvE,OAAO;IACHC,IAAI,EAAE,uCAAuC;IAC7CC,IAAI,EAAE,wBAAwB;IAC9BC,WAAW,EAAE,gBAAgB;IAC7BC,kBAAkB,EAAE,KAAK;IACzBC,OAAO,EAAE;MACLC,KAAK,EAAE,gBAAgB;MACvBC,KAAK,EAAE,+BAA+B;MACtCC,OAAOA,CAAA,EAAG;QACN,oBAAOZ,KAAA,CAAAa,aAAA,CAACX,UAAU,MAAE,CAAC;MACzB;IACJ,CAAC;IACDY,QAAQ,EAAE,CAAC,wCAAwC,CAAC;IACpDC,MAAM,EAAE,CAAC,MAAM,CAAC;IAChBC,MAAMA,CAAA,EAAG;MACL,OAAO;QACHV,IAAI,EAAE,IAAI,CAACC,WAAW;QACtBU,QAAQ,EAAE,EAAE;QACZC,IAAI,EAAE,CAAC;MACX,CAAC;IACL,CAAC;IAEDC,MAAMA,CAACC,KAAK,EAAE;MACV,oBAAOpB,KAAA,CAAAa,aAAA,CAACV,qBAAqB,EAAAkB,MAAA,CAAAC,MAAA,KAAKF,KAAK;QAAEG,OAAO,EAAEH,KAAK,CAACG;MAAqB,EAAE,CAAC;IACpF;EACJ,CAAC;AACL,CAAC","ignoreList":[]}

package/admin/elements/eventHandlers/ContentTraverser.d.ts

@@ -0,0 +1,11 @@
+import type { PbEditorElement } from "@webiny/app-page-builder/types";
+type ElementNode = Omit<PbEditorElement, "elements"> & {
+    elements: ElementNode[];
+};
+interface ElementNodeVisitor {
+    (node: ElementNode): void;
+}
+export declare class ContentTraverser {
+    traverse(element: ElementNode, visitor: ElementNodeVisitor): void;
+}
+export {};

package/admin/elements/eventHandlers/ContentTraverser.js

@@ -0,0 +1,10 @@
+export class ContentTraverser {
+  traverse(element, visitor) {
+    visitor(element);
+    for (const node of element.elements) {
+      this.traverse(node, visitor);
+    }
+  }
+}
+
+//# sourceMappingURL=ContentTraverser.js.map

package/admin/elements/eventHandlers/ContentTraverser.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ContentTraverser","traverse","element","visitor","node","elements"],"sources":["ContentTraverser.ts"],"sourcesContent":["import type { PbEditorElement } from \"@webiny/app-page-builder/types\";\n\ntype ElementNode = Omit<PbEditorElement, \"elements\"> & {\n    elements: ElementNode[];\n};\n\ninterface ElementNodeVisitor {\n    (node: ElementNode): void;\n}\n\nexport class ContentTraverser {\n    traverse(element: ElementNode, visitor: ElementNodeVisitor): void {\n        visitor(element);\n        for (const node of element.elements) {\n            this.traverse(node, visitor);\n        }\n    }\n}\n"],"mappings":"AAUA,OAAO,MAAMA,gBAAgB,CAAC;EAC1BC,QAAQA,CAACC,OAAoB,EAAEC,OAA2B,EAAQ;IAC9DA,OAAO,CAACD,OAAO,CAAC;IAChB,KAAK,MAAME,IAAI,IAAIF,OAAO,CAACG,QAAQ,EAAE;MACjC,IAAI,CAACJ,QAAQ,CAACG,IAAI,EAAED,OAAO,CAAC;IAChC;EACJ;AACJ","ignoreList":[]}