payload 1.4.2 → 1.5.1

package/dist/admin/components/forms/field-types/Relationship/types.d.ts

@@ -2,33 +2,33 @@ import i18n from 'i18next';
 import { SanitizedCollectionConfig } from '../../../../../collections/config/types';
 import { RelationshipField } from '../../../../../fields/config/types';
 import { Where } from '../../../../../types';
-export declare type Props = Omit<RelationshipField, 'type'> & {
+export type Props = Omit<RelationshipField, 'type'> & {
     path?: string;
 };
-export declare type Option = {
+export type Option = {
     label: string;
     value: string | number;
     relationTo?: string;
     options?: Option[];
 };
-export declare type OptionGroup = {
+export type OptionGroup = {
     label: string;
     options: Option[];
 };
-export declare type Value = {
+export type Value = {
     relationTo: string;
     value: string | number;
 } | string | number;
-declare type CLEAR = {
+type CLEAR = {
     type: 'CLEAR';
 };
-declare type UPDATE = {
+type UPDATE = {
     type: 'UPDATE';
     doc: any;
     collection: SanitizedCollectionConfig;
     i18n: typeof i18n;
 };
-declare type ADD = {
+type ADD = {
     type: 'ADD';
     docs: any[];
     collection: SanitizedCollectionConfig;
@@ -36,12 +36,12 @@ declare type ADD = {
     ids?: unknown[];
     i18n: typeof i18n;
 };
-export declare type Action = CLEAR | ADD | UPDATE;
-export declare type ValueWithRelation = {
+export type Action = CLEAR | ADD | UPDATE;
+export type ValueWithRelation = {
     relationTo: string;
     value: string;
 };
-export declare type GetResults = (args: {
+export type GetResults = (args: {
     lastFullyLoadedRelation?: number;
     lastLoadedPage?: number;
     search?: string;
@@ -49,7 +49,7 @@ export declare type GetResults = (args: {
     sort?: boolean;
     onSuccess?: () => void;
 }) => Promise<void>;
-export declare type FilterOptionsResult = {
+export type FilterOptionsResult = {
     [relation: string]: Where;
 };
 export {};

package/dist/admin/components/forms/field-types/Relationship/types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/admin/components/forms/field-types/RichText/RichText.js

@@ -1,70 +1,98 @@
-import React, { useState, useCallback, useMemo, useEffect, useRef } from 'react';
-import isHotkey from 'is-hotkey';
-import { createEditor, Transforms, Node, Element as SlateElement, Text } from 'slate';
-import { ReactEditor, Editable, withReact, Slate } from 'slate-react';
-import { withHistory } from 'slate-history';
-import { useTranslation } from 'react-i18next';
-import { richText } from '../../../../../fields/validations';
-import useField from '../../useField';
-import withCondition from '../../withCondition';
-import Label from '../../Label';
-import Error from '../../Error';
-import leafTypes from './leaves';
-import elementTypes from './elements';
-import toggleLeaf from './leaves/toggle';
-import hotkeys from './hotkeys';
-import enablePlugins from './enablePlugins';
-import defaultValue from '../../../../../fields/richText/defaultValue';
-import FieldDescription from '../../FieldDescription';
-import withHTML from './plugins/withHTML';
-import listTypes from './elements/listTypes';
-import mergeCustomFunctions from './mergeCustomFunctions';
-import withEnterBreakOut from './plugins/withEnterBreakOut';
-import { getTranslation } from '../../../../../utilities/getTranslation';
-import { useEditDepth } from '../../../utilities/EditDepth';
-import './index.scss';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const is_hotkey_1 = __importDefault(require("is-hotkey"));
+const slate_1 = require("slate");
+const slate_react_1 = require("slate-react");
+const slate_history_1 = require("slate-history");
+const react_i18next_1 = require("react-i18next");
+const validations_1 = require("../../../../../fields/validations");
+const useField_1 = __importDefault(require("../../useField"));
+const withCondition_1 = __importDefault(require("../../withCondition"));
+const Label_1 = __importDefault(require("../../Label"));
+const Error_1 = __importDefault(require("../../Error"));
+const leaves_1 = __importDefault(require("./leaves"));
+const elements_1 = __importDefault(require("./elements"));
+const toggle_1 = __importDefault(require("./leaves/toggle"));
+const hotkeys_1 = __importDefault(require("./hotkeys"));
+const enablePlugins_1 = __importDefault(require("./enablePlugins"));
+const defaultValue_1 = __importDefault(require("../../../../../fields/richText/defaultValue"));
+const FieldDescription_1 = __importDefault(require("../../FieldDescription"));
+const withHTML_1 = __importDefault(require("./plugins/withHTML"));
+const listTypes_1 = __importDefault(require("./elements/listTypes"));
+const mergeCustomFunctions_1 = __importDefault(require("./mergeCustomFunctions"));
+const withEnterBreakOut_1 = __importDefault(require("./plugins/withEnterBreakOut"));
+const getTranslation_1 = require("../../../../../utilities/getTranslation");
+const EditDepth_1 = require("../../../utilities/EditDepth");
+require("./index.scss");
 const defaultElements = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'ul', 'ol', 'indent', 'link', 'relationship', 'upload'];
 const defaultLeaves = ['bold', 'italic', 'underline', 'strikethrough', 'code'];
 const baseClass = 'rich-text';
 const RichText = (props) => {
-    const { path: pathFromProps, name, required, validate = richText, label, admin, admin: { readOnly, style, className, width, placeholder, description, condition, hideGutter, } = {}, } = props;
+    const { path: pathFromProps, name, required, validate = validations_1.richText, label, admin, admin: { readOnly, style, className, width, placeholder, description, condition, hideGutter, } = {}, } = props;
     const elements = (admin === null || admin === void 0 ? void 0 : admin.elements) || defaultElements;
     const leaves = (admin === null || admin === void 0 ? void 0 : admin.leaves) || defaultLeaves;
     const path = pathFromProps || name;
-    const { i18n } = useTranslation();
-    const [loaded, setLoaded] = useState(false);
-    const [enabledElements, setEnabledElements] = useState({});
-    const [enabledLeaves, setEnabledLeaves] = useState({});
-    const editorRef = useRef(null);
-    const toolbarRef = useRef(null);
-    const drawerDepth = useEditDepth();
+    const { i18n } = (0, react_i18next_1.useTranslation)();
+    const [loaded, setLoaded] = (0, react_1.useState)(false);
+    const [enabledElements, setEnabledElements] = (0, react_1.useState)({});
+    const [enabledLeaves, setEnabledLeaves] = (0, react_1.useState)({});
+    const editorRef = (0, react_1.useRef)(null);
+    const toolbarRef = (0, react_1.useRef)(null);
+    const drawerDepth = (0, EditDepth_1.useEditDepth)();
     const drawerIsOpen = drawerDepth > 1;
-    const renderElement = useCallback(({ attributes, children, element }) => {
+    const renderElement = (0, react_1.useCallback)(({ attributes, children, element }) => {
         const matchedElement = enabledElements[element === null || element === void 0 ? void 0 : element.type];
         const Element = matchedElement === null || matchedElement === void 0 ? void 0 : matchedElement.Element;
         if (Element) {
-            return (React.createElement(Element, { attributes: attributes, element: element, path: path, fieldProps: props, editorRef: editorRef }, children));
+            return (react_1.default.createElement(Element, { attributes: attributes, element: element, path: path, fieldProps: props, editorRef: editorRef }, children));
         }
-        return React.createElement("div", { ...attributes }, children);
+        return react_1.default.createElement("div", { ...attributes }, children);
     }, [enabledElements, path, props]);
-    const renderLeaf = useCallback(({ attributes, children, leaf }) => {
+    const renderLeaf = (0, react_1.useCallback)(({ attributes, children, leaf }) => {
         const matchedLeaves = Object.entries(enabledLeaves).filter(([leafName]) => leaf[leafName]);
         if (matchedLeaves.length > 0) {
             return matchedLeaves.reduce((result, [leafName], i) => {
                 var _a, _b;
                 if ((_a = enabledLeaves[leafName]) === null || _a === void 0 ? void 0 : _a.Leaf) {
                     const Leaf = (_b = enabledLeaves[leafName]) === null || _b === void 0 ? void 0 : _b.Leaf;
-                    return (React.createElement(Leaf, { key: i, leaf: leaf, path: path, fieldProps: props, editorRef: editorRef }, result));
+                    return (react_1.default.createElement(Leaf, { key: i, leaf: leaf, path: path, fieldProps: props, editorRef: editorRef }, result));
                 }
                 return result;
-            }, React.createElement("span", { ...attributes }, children));
+            }, react_1.default.createElement("span", { ...attributes }, children));
         }
-        return (React.createElement("span", { ...attributes }, children));
+        return (react_1.default.createElement("span", { ...attributes }, children));
     }, [enabledLeaves, path, props]);
-    const memoizedValidate = useCallback((value, validationOptions) => {
+    const memoizedValidate = (0, react_1.useCallback)((value, validationOptions) => {
         return validate(value, { ...validationOptions, required });
     }, [validate, required]);
-    const fieldType = useField({
+    const fieldType = (0, useField_1.default)({
         path,
         validate: memoizedValidate,
         condition,
@@ -78,18 +106,18 @@ const RichText = (props) => {
         readOnly && `${baseClass}--read-only`,
         !hideGutter && `${baseClass}--gutter`,
     ].filter(Boolean).join(' ');
-    const editor = useMemo(() => {
-        let CreatedEditor = withEnterBreakOut(withHistory(withReact(createEditor())));
-        CreatedEditor = withHTML(CreatedEditor);
-        CreatedEditor = enablePlugins(CreatedEditor, elements);
-        CreatedEditor = enablePlugins(CreatedEditor, leaves);
+    const editor = (0, react_1.useMemo)(() => {
+        let CreatedEditor = (0, withEnterBreakOut_1.default)((0, slate_history_1.withHistory)((0, slate_react_1.withReact)((0, slate_1.createEditor)())));
+        CreatedEditor = (0, withHTML_1.default)(CreatedEditor);
+        CreatedEditor = (0, enablePlugins_1.default)(CreatedEditor, elements);
+        CreatedEditor = (0, enablePlugins_1.default)(CreatedEditor, leaves);
         return CreatedEditor;
     }, [elements, leaves]);
     // All slate changes fire the onChange event
     // including selection changes
     // so we will filter the set_selection operations out
     // and only fire setValue when onChange is because of value
-    const handleChange = useCallback((val) => {
+    const handleChange = (0, react_1.useCallback)((val) => {
         const ops = editor.operations.filter((o) => {
             if (o) {
                 return o.type !== 'set_selection';
@@ -97,21 +125,21 @@ const RichText = (props) => {
             return false;
         });
         if (ops && Array.isArray(ops) && ops.length > 0) {
-            if (!readOnly && val !== defaultValue && val !== value) {
+            if (!readOnly && val !== defaultValue_1.default && val !== value) {
                 setValue(val);
             }
         }
     }, [editor.operations, readOnly, setValue, value]);
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (!loaded) {
-            const mergedElements = mergeCustomFunctions(elements, elementTypes);
-            const mergedLeaves = mergeCustomFunctions(leaves, leafTypes);
+            const mergedElements = (0, mergeCustomFunctions_1.default)(elements, elements_1.default);
+            const mergedLeaves = (0, mergeCustomFunctions_1.default)(leaves, leaves_1.default);
             setEnabledElements(mergedElements);
             setEnabledLeaves(mergedLeaves);
             setLoaded(true);
         }
     }, [loaded, elements, leaves]);
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         function setClickableState(clickState) {
             var _a, _b;
             const selectors = 'button, a, [role="button"]';
@@ -134,13 +162,13 @@ const RichText = (props) => {
             }
         };
     }, [loaded, readOnly]);
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         // If there is a change to the initial value, we need to reset Slate history
         // and clear selection because the old selection may no longer be valid
         // as returned JSON may be modified in hooks and have a different shape
         if (Array.isArray(initialValue) && initialValue.length > 0) {
             if (editor.selection)
-                ReactEditor.deselect(editor);
+                slate_react_1.ReactEditor.deselect(editor);
             editor.history = { redos: [], undos: [] };
         }
     }, [initialValue, editor]);
@@ -158,21 +186,21 @@ const RichText = (props) => {
         }
     }
     if (!valueToRender)
-        valueToRender = defaultValue;
-    return (React.createElement("div", { className: classes, style: {
+        valueToRender = defaultValue_1.default;
+    return (react_1.default.createElement("div", { className: classes, style: {
             ...style,
             width,
         } },
-        React.createElement("div", { className: `${baseClass}__wrap` },
-            React.createElement(Error, { showError: showError, message: errorMessage }),
-            React.createElement(Label, { htmlFor: `field-${path.replace(/\./gi, '__')}`, label: label, required: required }),
-            React.createElement(Slate, { editor: editor, value: valueToRender, onChange: handleChange },
-                React.createElement("div", { className: `${baseClass}__wrapper` },
-                    React.createElement("div", { className: [
+        react_1.default.createElement("div", { className: `${baseClass}__wrap` },
+            react_1.default.createElement(Error_1.default, { showError: showError, message: errorMessage }),
+            react_1.default.createElement(Label_1.default, { htmlFor: `field-${path.replace(/\./gi, '__')}`, label: label, required: required }),
+            react_1.default.createElement(slate_react_1.Slate, { editor: editor, value: valueToRender, onChange: handleChange },
+                react_1.default.createElement("div", { className: `${baseClass}__wrapper` },
+                    react_1.default.createElement("div", { className: [
                             `${baseClass}__toolbar`,
                             drawerIsOpen && `${baseClass}__drawerIsOpen`,
                         ].filter(Boolean).join(' '), ref: toolbarRef },
-                        React.createElement("div", { className: `${baseClass}__toolbar-wrap` },
+                        react_1.default.createElement("div", { className: `${baseClass}__toolbar-wrap` },
                             elements.map((element, i) => {
                                 let elementName;
                                 if (typeof element === 'object' && (element === null || element === void 0 ? void 0 : element.name))
@@ -182,7 +210,7 @@ const RichText = (props) => {
                                 const elementType = enabledElements[elementName];
                                 const Button = elementType === null || elementType === void 0 ? void 0 : elementType.Button;
                                 if (Button) {
-                                    return (React.createElement(Button, { fieldProps: props, key: i, path: path }));
+                                    return (react_1.default.createElement(Button, { fieldProps: props, key: i, path: path }));
                                 }
                                 return null;
                             }),
@@ -195,61 +223,61 @@ const RichText = (props) => {
                                 const leafType = enabledLeaves[leafName];
                                 const Button = leafType === null || leafType === void 0 ? void 0 : leafType.Button;
                                 if (Button) {
-                                    return (React.createElement(Button, { fieldProps: props, key: i, path: path }));
+                                    return (react_1.default.createElement(Button, { fieldProps: props, key: i, path: path }));
                                 }
                                 return null;
                             }))),
-                    React.createElement("div", { className: `${baseClass}__editor`, ref: editorRef },
-                        React.createElement(Editable, { id: `field-${path.replace(/\./gi, '__')}`, className: `${baseClass}__input`, renderElement: renderElement, renderLeaf: renderLeaf, placeholder: getTranslation(placeholder, i18n), spellCheck: true, readOnly: readOnly, onKeyDown: (event) => {
+                    react_1.default.createElement("div", { className: `${baseClass}__editor`, ref: editorRef },
+                        react_1.default.createElement(slate_react_1.Editable, { id: `field-${path.replace(/\./gi, '__')}`, className: `${baseClass}__input`, renderElement: renderElement, renderLeaf: renderLeaf, placeholder: (0, getTranslation_1.getTranslation)(placeholder, i18n), spellCheck: true, readOnly: readOnly, onKeyDown: (event) => {
                                 if (event.key === 'Enter') {
                                     if (event.shiftKey) {
                                         event.preventDefault();
                                         editor.insertText('\n');
                                     }
                                     else {
-                                        const selectedElement = Node.descendant(editor, editor.selection.anchor.path.slice(0, -1));
-                                        if (SlateElement.isElement(selectedElement)) {
+                                        const selectedElement = slate_1.Node.descendant(editor, editor.selection.anchor.path.slice(0, -1));
+                                        if (slate_1.Element.isElement(selectedElement)) {
                                             // Allow hard enter to "break out" of certain elements
                                             if (editor.shouldBreakOutOnEnter(selectedElement)) {
                                                 event.preventDefault();
-                                                const selectedLeaf = Node.descendant(editor, editor.selection.anchor.path);
-                                                if (Text.isText(selectedLeaf) && String(selectedLeaf.text).length === editor.selection.anchor.offset) {
-                                                    Transforms.insertNodes(editor, { children: [{ text: '' }] });
+                                                const selectedLeaf = slate_1.Node.descendant(editor, editor.selection.anchor.path);
+                                                if (slate_1.Text.isText(selectedLeaf) && String(selectedLeaf.text).length === editor.selection.anchor.offset) {
+                                                    slate_1.Transforms.insertNodes(editor, { children: [{ text: '' }] });
                                                 }
                                                 else {
-                                                    Transforms.splitNodes(editor);
-                                                    Transforms.setNodes(editor, {});
+                                                    slate_1.Transforms.splitNodes(editor);
+                                                    slate_1.Transforms.setNodes(editor, {});
                                                 }
                                             }
                                         }
                                     }
                                 }
                                 if (event.key === 'Backspace') {
-                                    const selectedElement = Node.descendant(editor, editor.selection.anchor.path.slice(0, -1));
-                                    if (SlateElement.isElement(selectedElement) && selectedElement.type === 'li') {
-                                        const selectedLeaf = Node.descendant(editor, editor.selection.anchor.path);
-                                        if (Text.isText(selectedLeaf) && String(selectedLeaf.text).length === 0) {
+                                    const selectedElement = slate_1.Node.descendant(editor, editor.selection.anchor.path.slice(0, -1));
+                                    if (slate_1.Element.isElement(selectedElement) && selectedElement.type === 'li') {
+                                        const selectedLeaf = slate_1.Node.descendant(editor, editor.selection.anchor.path);
+                                        if (slate_1.Text.isText(selectedLeaf) && String(selectedLeaf.text).length === 0) {
                                             event.preventDefault();
-                                            Transforms.unwrapNodes(editor, {
-                                                match: (n) => SlateElement.isElement(n) && listTypes.includes(n.type),
+                                            slate_1.Transforms.unwrapNodes(editor, {
+                                                match: (n) => slate_1.Element.isElement(n) && listTypes_1.default.includes(n.type),
                                                 split: true,
                                                 mode: 'lowest',
                                             });
-                                            Transforms.setNodes(editor, { type: undefined });
+                                            slate_1.Transforms.setNodes(editor, { type: undefined });
                                         }
                                     }
                                     else if (editor.isVoid(selectedElement)) {
-                                        Transforms.removeNodes(editor);
+                                        slate_1.Transforms.removeNodes(editor);
                                     }
                                 }
-                                Object.keys(hotkeys).forEach((hotkey) => {
-                                    if (isHotkey(hotkey, event)) {
+                                Object.keys(hotkeys_1.default).forEach((hotkey) => {
+                                    if ((0, is_hotkey_1.default)(hotkey, event)) {
                                         event.preventDefault();
-                                        const mark = hotkeys[hotkey];
-                                        toggleLeaf(editor, mark);
+                                        const mark = hotkeys_1.default[hotkey];
+                                        (0, toggle_1.default)(editor, mark);
                                     }
                                 });
                             } })))),
-            React.createElement(FieldDescription, { value: value, description: description }))));
+            react_1.default.createElement(FieldDescription_1.default, { value: value, description: description }))));
 };
-export default withCondition(RichText);
+exports.default = (0, withCondition_1.default)(RichText);

package/dist/admin/components/forms/field-types/RichText/elements/Button.js

@@ -1,26 +1,55 @@
-import React, { useCallback, useState } from 'react';
-import { useSlate } from 'slate-react';
-import isElementActive from './isActive';
-import toggleElement from './toggle';
-import Tooltip from '../../../../elements/Tooltip';
-import '../buttons.scss';
-export const baseClass = 'rich-text__button';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseClass = void 0;
+const react_1 = __importStar(require("react"));
+const slate_react_1 = require("slate-react");
+const isActive_1 = __importDefault(require("./isActive"));
+const toggle_1 = __importDefault(require("./toggle"));
+const Tooltip_1 = __importDefault(require("../../../../elements/Tooltip"));
+require("../buttons.scss");
+exports.baseClass = 'rich-text__button';
 const ElementButton = (props) => {
     const { format, children, onClick, className, tooltip, el = 'button', } = props;
-    const editor = useSlate();
-    const [showTooltip, setShowTooltip] = useState(false);
-    const defaultOnClick = useCallback((event) => {
+    const editor = (0, slate_react_1.useSlate)();
+    const [showTooltip, setShowTooltip] = (0, react_1.useState)(false);
+    const defaultOnClick = (0, react_1.useCallback)((event) => {
         event.preventDefault();
         setShowTooltip(false);
-        toggleElement(editor, format);
+        (0, toggle_1.default)(editor, format);
     }, [editor, format]);
     const Tag = el;
-    return (React.createElement(Tag, { ...el === 'button' && { type: 'button' }, className: [
-            baseClass,
+    return (react_1.default.createElement(Tag, { ...el === 'button' && { type: 'button' }, className: [
+            exports.baseClass,
             className,
-            isElementActive(editor, format) && `${baseClass}__button--active`,
+            (0, isActive_1.default)(editor, format) && `${exports.baseClass}__button--active`,
         ].filter(Boolean).join(' '), onClick: onClick || defaultOnClick, onMouseEnter: () => setShowTooltip(true), onMouseLeave: () => setShowTooltip(false) },
-        tooltip && (React.createElement(Tooltip, { show: showTooltip }, tooltip)),
+        tooltip && (react_1.default.createElement(Tooltip_1.default, { show: showTooltip }, tooltip)),
         children));
 };
-export default ElementButton;
+exports.default = ElementButton;

package/dist/admin/components/forms/field-types/RichText/elements/ListButton.js

@@ -1,19 +1,48 @@
-import React, { useCallback } from 'react';
-import { useSlate } from 'slate-react';
-import toggleList from './toggleList';
-import isListActive from './isListActive';
-import '../buttons.scss';
-export const baseClass = 'rich-text__button';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseClass = void 0;
+const react_1 = __importStar(require("react"));
+const slate_react_1 = require("slate-react");
+const toggleList_1 = __importDefault(require("./toggleList"));
+const isListActive_1 = __importDefault(require("./isListActive"));
+require("../buttons.scss");
+exports.baseClass = 'rich-text__button';
 const ListButton = ({ format, children, onClick, className }) => {
-    const editor = useSlate();
-    const defaultOnClick = useCallback((event) => {
+    const editor = (0, slate_react_1.useSlate)();
+    const defaultOnClick = (0, react_1.useCallback)((event) => {
         event.preventDefault();
-        toggleList(editor, format);
+        (0, toggleList_1.default)(editor, format);
     }, [editor, format]);
-    return (React.createElement("button", { type: "button", className: [
-            baseClass,
+    return (react_1.default.createElement("button", { type: "button", className: [
+            exports.baseClass,
             className,
-            isListActive(editor, format) && `${baseClass}__button--active`,
+            (0, isListActive_1.default)(editor, format) && `${exports.baseClass}__button--active`,
         ].filter(Boolean).join(' '), onClick: onClick || defaultOnClick }, children));
 };
-export default ListButton;
+exports.default = ListButton;

package/dist/admin/components/forms/field-types/RichText/elements/areAllChildrenElements.js

@@ -1,4 +1,8 @@
-import { Element } from 'slate';
-export const areAllChildrenElements = (node) => {
-    return Array.isArray(node.children) && node.children.every((child) => Element.isElement(child));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areAllChildrenElements = void 0;
+const slate_1 = require("slate");
+const areAllChildrenElements = (node) => {
+    return Array.isArray(node.children) && node.children.every((child) => slate_1.Element.isElement(child));
 };
+exports.areAllChildrenElements = areAllChildrenElements;

package/dist/admin/components/forms/field-types/RichText/elements/getCommonBlock.js

@@ -1,12 +1,16 @@
-import { Editor, Node } from 'slate';
-export const getCommonBlock = (editor, match) => {
-    const range = Editor.unhangRange(editor, editor.selection, { voids: true });
-    const [common, path] = Node.common(editor, range.anchor.path, range.focus.path);
-    if (Editor.isBlock(editor, common) || Editor.isEditor(common)) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommonBlock = void 0;
+const slate_1 = require("slate");
+const getCommonBlock = (editor, match) => {
+    const range = slate_1.Editor.unhangRange(editor, editor.selection, { voids: true });
+    const [common, path] = slate_1.Node.common(editor, range.anchor.path, range.focus.path);
+    if (slate_1.Editor.isBlock(editor, common) || slate_1.Editor.isEditor(common)) {
         return [common, path];
     }
-    return Editor.above(editor, {
+    return slate_1.Editor.above(editor, {
         at: path,
-        match: match || ((n) => Editor.isBlock(editor, n) || Editor.isEditor(n)),
+        match: match || ((n) => slate_1.Editor.isBlock(editor, n) || slate_1.Editor.isEditor(n)),
     });
 };
+exports.getCommonBlock = getCommonBlock;

package/dist/admin/components/forms/field-types/RichText/elements/h1/index.js

@@ -1,10 +1,15 @@
-import React from 'react';
-import ElementButton from '../Button';
-import H1Icon from '../../../../../icons/headings/H1';
-const H1 = ({ attributes, children }) => (React.createElement("h1", { ...attributes }, children));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const Button_1 = __importDefault(require("../Button"));
+const H1_1 = __importDefault(require("../../../../../icons/headings/H1"));
+const H1 = ({ attributes, children }) => (react_1.default.createElement("h1", { ...attributes }, children));
 const h1 = {
-    Button: () => (React.createElement(ElementButton, { format: "h1" },
-        React.createElement(H1Icon, null))),
+    Button: () => (react_1.default.createElement(Button_1.default, { format: "h1" },
+        react_1.default.createElement(H1_1.default, null))),
     Element: H1,
 };
-export default h1;
+exports.default = h1;

package/dist/admin/components/forms/field-types/RichText/elements/h2/index.js

@@ -1,10 +1,15 @@
-import React from 'react';
-import ElementButton from '../Button';
-import H2Icon from '../../../../../icons/headings/H2';
-const H2 = ({ attributes, children }) => (React.createElement("h2", { ...attributes }, children));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const Button_1 = __importDefault(require("../Button"));
+const H2_1 = __importDefault(require("../../../../../icons/headings/H2"));
+const H2 = ({ attributes, children }) => (react_1.default.createElement("h2", { ...attributes }, children));
 const h2 = {
-    Button: () => (React.createElement(ElementButton, { format: "h2" },
-        React.createElement(H2Icon, null))),
+    Button: () => (react_1.default.createElement(Button_1.default, { format: "h2" },
+        react_1.default.createElement(H2_1.default, null))),
     Element: H2,
 };
-export default h2;
+exports.default = h2;