@wordpress/block-library 7.4.0 → 7.7.0

package/build/cover/edit.js

@@ -1,665 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _element = require("@wordpress/element");
-
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-
-var _classnames = _interopRequireDefault(require("classnames"));
-
-var _fastAverageColor = _interopRequireDefault(require("fast-average-color"));
-
-var _colord = require("colord");
-
-var _names = _interopRequireDefault(require("colord/plugins/names"));
-
-var _coreData = require("@wordpress/core-data");
-
-var _components = require("@wordpress/components");
-
-var _compose = require("@wordpress/compose");
-
-var _blockEditor = require("@wordpress/block-editor");
-
-var _i18n = require("@wordpress/i18n");
-
-var _data = require("@wordpress/data");
-
-var _icons = require("@wordpress/icons");
-
-var _blob = require("@wordpress/blob");
-
-var _notices = require("@wordpress/notices");
-
-var _shared = require("./shared");
-
-/**
- * External dependencies
- */
-
-/**
- * WordPress dependencies
- */
-
-/**
- * Internal dependencies
- */
-(0, _colord.extend)([_names.default]);
-const {
-  __Visualizer: BoxControlVisualizer
-} = _components.__experimentalBoxControl;
-
-function getInnerBlocksTemplate(attributes) {
-  return [['core/paragraph', {
-    align: 'center',
-    placeholder: (0, _i18n.__)('Write title…'),
-    ...attributes
-  }]];
-}
-
-function retrieveFastAverageColor() {
-  if (!retrieveFastAverageColor.fastAverageColor) {
-    retrieveFastAverageColor.fastAverageColor = new _fastAverageColor.default();
-  }
-
-  return retrieveFastAverageColor.fastAverageColor;
-}
-
-function CoverHeightInput(_ref) {
-  let {
-    onChange,
-    onUnitChange,
-    unit = 'px',
-    value = ''
-  } = _ref;
-  const instanceId = (0, _compose.useInstanceId)(_components.__experimentalUnitControl);
-  const inputId = `block-cover-height-input-${instanceId}`;
-  const isPx = unit === 'px';
-  const units = (0, _components.__experimentalUseCustomUnits)({
-    availableUnits: (0, _blockEditor.useSetting)('spacing.units') || ['px', 'em', 'rem', 'vw', 'vh'],
-    defaultValues: {
-      px: 430,
-      '%': 20,
-      em: 20,
-      rem: 20,
-      vw: 20,
-      vh: 50
-    }
-  });
-
-  const handleOnChange = unprocessedValue => {
-    const inputValue = unprocessedValue !== '' ? parseFloat(unprocessedValue) : undefined;
-
-    if (isNaN(inputValue) && inputValue !== undefined) {
-      return;
-    }
-
-    onChange(inputValue);
-  };
-
-  const computedValue = (0, _element.useMemo)(() => {
-    const [parsedQuantity] = (0, _components.__experimentalParseQuantityAndUnitFromRawValue)(value);
-    return [parsedQuantity, unit].join('');
-  }, [unit, value]);
-  const min = isPx ? _shared.COVER_MIN_HEIGHT : 0;
-  return (0, _element.createElement)(_components.BaseControl, {
-    label: (0, _i18n.__)('Minimum height of cover'),
-    id: inputId
-  }, (0, _element.createElement)(_components.__experimentalUnitControl, {
-    id: inputId,
-    isResetValueOnUnitChange: true,
-    min: min,
-    onChange: handleOnChange,
-    onUnitChange: onUnitChange,
-    style: {
-      maxWidth: 80
-    },
-    units: units,
-    value: computedValue
-  }));
-}
-
-const RESIZABLE_BOX_ENABLE_OPTION = {
-  top: false,
-  right: false,
-  bottom: true,
-  left: false,
-  topRight: false,
-  bottomRight: false,
-  bottomLeft: false,
-  topLeft: false
-};
-
-function ResizableCover(_ref2) {
-  let {
-    className,
-    onResizeStart,
-    onResize,
-    onResizeStop,
-    ...props
-  } = _ref2;
-  const [isResizing, setIsResizing] = (0, _element.useState)(false);
-  return (0, _element.createElement)(_components.ResizableBox, (0, _extends2.default)({
-    className: (0, _classnames.default)(className, {
-      'is-resizing': isResizing
-    }),
-    enable: RESIZABLE_BOX_ENABLE_OPTION,
-    onResizeStart: (_event, _direction, elt) => {
-      onResizeStart(elt.clientHeight);
-      onResize(elt.clientHeight);
-    },
-    onResize: (_event, _direction, elt) => {
-      onResize(elt.clientHeight);
-
-      if (!isResizing) {
-        setIsResizing(true);
-      }
-    },
-    onResizeStop: (_event, _direction, elt) => {
-      onResizeStop(elt.clientHeight);
-      setIsResizing(false);
-    }
-  }, props));
-}
-/**
- * useCoverIsDark is a hook that returns a boolean variable specifying if the cover
- * background is dark or not.
- *
- * @param {?string} url          Url of the media background.
- * @param {?number} dimRatio     Transparency of the overlay color. If an image and
- *                               color are set, dimRatio is used to decide what is used
- *                               for background darkness checking purposes.
- * @param {?string} overlayColor String containing the overlay color value if one exists.
- * @param {?Object} elementRef   If a media background is set, elementRef should contain a reference to a
- *                               dom element that renders that media.
- *
- * @return {boolean} True if the cover background is considered "dark" and false otherwise.
- */
-
-
-function useCoverIsDark(url) {
-  let dimRatio = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 50;
-  let overlayColor = arguments.length > 2 ? arguments[2] : undefined;
-  let elementRef = arguments.length > 3 ? arguments[3] : undefined;
-  const [isDark, setIsDark] = (0, _element.useState)(false);
-  (0, _element.useEffect)(() => {
-    // If opacity is lower than 50 the dominant color is the image or video color,
-    // so use that color for the dark mode computation.
-    if (url && dimRatio <= 50 && elementRef.current) {
-      retrieveFastAverageColor().getColorAsync(elementRef.current, color => {
-        setIsDark(color.isDark);
-      });
-    }
-  }, [url, url && dimRatio <= 50 && elementRef.current, setIsDark]);
-  (0, _element.useEffect)(() => {
-    // If opacity is greater than 50 the dominant color is the overlay color,
-    // so use that color for the dark mode computation.
-    if (dimRatio > 50 || !url) {
-      if (!overlayColor) {
-        // If no overlay color exists the overlay color is black (isDark )
-        setIsDark(true);
-        return;
-      }
-
-      setIsDark((0, _colord.colord)(overlayColor).isDark());
-    }
-  }, [overlayColor, dimRatio > 50 || !url, setIsDark]);
-  (0, _element.useEffect)(() => {
-    if (!url && !overlayColor) {
-      // Reset isDark.
-      setIsDark(false);
-    }
-  }, [!url && !overlayColor, setIsDark]);
-  return isDark;
-}
-
-function mediaPosition(_ref3) {
-  let {
-    x,
-    y
-  } = _ref3;
-  return `${Math.round(x * 100)}% ${Math.round(y * 100)}%`;
-}
-/**
- * Is the URL a temporary blob URL? A blob URL is one that is used temporarily while
- * the media (image or video) is being uploaded and will not have an id allocated yet.
- *
- * @param {number} id  The id of the media.
- * @param {string} url The url of the media.
- *
- * @return {boolean} Is the URL a Blob URL.
- */
-
-
-const isTemporaryMedia = (id, url) => !id && (0, _blob.isBlobURL)(url);
-
-function CoverPlaceholder(_ref4) {
-  let {
-    disableMediaButtons = false,
-    children,
-    onSelectMedia,
-    onError,
-    style
-  } = _ref4;
-  return (0, _element.createElement)(_blockEditor.MediaPlaceholder, {
-    icon: (0, _element.createElement)(_blockEditor.BlockIcon, {
-      icon: _icons.cover
-    }),
-    labels: {
-      title: (0, _i18n.__)('Cover'),
-      instructions: (0, _i18n.__)('Drag and drop onto this block, upload, or select existing media from your library.')
-    },
-    onSelect: onSelectMedia,
-    accept: "image/*,video/*",
-    allowedTypes: _shared.ALLOWED_MEDIA_TYPES,
-    disableMediaButtons: disableMediaButtons,
-    onError: onError,
-    style: style
-  }, children);
-}
-
-function CoverEdit(_ref5) {
-  var _useSetting, _styleAttribute$spaci, _styleAttribute$visua;
-
-  let {
-    attributes,
-    clientId,
-    isSelected,
-    overlayColor,
-    setAttributes,
-    setOverlayColor,
-    toggleSelection,
-    context: {
-      postId,
-      postType
-    }
-  } = _ref5;
-  const {
-    contentPosition,
-    id,
-    useFeaturedImage,
-    dimRatio,
-    focalPoint,
-    hasParallax,
-    isDark,
-    isRepeated,
-    minHeight,
-    minHeightUnit,
-    style: styleAttribute,
-    alt,
-    allowedBlocks,
-    templateLock
-  } = attributes;
-  const [featuredImage] = (0, _coreData.useEntityProp)('postType', postType, 'featured_media', postId);
-  const media = (0, _data.useSelect)(select => featuredImage && select(_coreData.store).getMedia(featuredImage, {
-    context: 'view'
-  }), [featuredImage]);
-  const mediaUrl = media === null || media === void 0 ? void 0 : media.source_url; // instead of destructuring the attributes
-  // we define the url and background type
-  // depending on the value of the useFeaturedImage flag
-  // to preview in edit the dynamic featured image
-
-  const url = useFeaturedImage ? mediaUrl : attributes.url;
-  const backgroundType = useFeaturedImage ? _shared.IMAGE_BACKGROUND_TYPE : attributes.backgroundType;
-  const {
-    __unstableMarkNextChangeAsNotPersistent
-  } = (0, _data.useDispatch)(_blockEditor.store);
-  const {
-    createErrorNotice
-  } = (0, _data.useDispatch)(_notices.store);
-  const {
-    gradientClass,
-    gradientValue,
-    setGradient
-  } = (0, _blockEditor.__experimentalUseGradient)();
-  const onSelectMedia = (0, _shared.attributesFromMedia)(setAttributes, dimRatio);
-  const isUploadingMedia = isTemporaryMedia(id, url);
-  const [prevMinHeightValue, setPrevMinHeightValue] = (0, _element.useState)(minHeight);
-  const [prevMinHeightUnit, setPrevMinHeightUnit] = (0, _element.useState)(minHeightUnit);
-  const isMinFullHeight = minHeightUnit === 'vh' && minHeight === 100;
-
-  const toggleMinFullHeight = () => {
-    if (isMinFullHeight) {
-      // If there aren't previous values, take the default ones.
-      if (prevMinHeightUnit === 'vh' && prevMinHeightValue === 100) {
-        return setAttributes({
-          minHeight: undefined,
-          minHeightUnit: undefined
-        });
-      } // Set the previous values of height.
-
-
-      return setAttributes({
-        minHeight: prevMinHeightValue,
-        minHeightUnit: prevMinHeightUnit
-      });
-    }
-
-    setPrevMinHeightValue(minHeight);
-    setPrevMinHeightUnit(minHeightUnit); // Set full height.
-
-    return setAttributes({
-      minHeight: 100,
-      minHeightUnit: 'vh'
-    });
-  };
-
-  const toggleParallax = () => {
-    setAttributes({
-      hasParallax: !hasParallax,
-      ...(!hasParallax ? {
-        focalPoint: undefined
-      } : {})
-    });
-  };
-
-  const toggleIsRepeated = () => {
-    setAttributes({
-      isRepeated: !isRepeated
-    });
-  };
-
-  const toggleUseFeaturedImage = () => {
-    setAttributes({
-      useFeaturedImage: !useFeaturedImage,
-      dimRatio: dimRatio === 100 ? 50 : dimRatio
-    });
-  };
-
-  const onUploadError = message => {
-    createErrorNotice(Array.isArray(message) ? message[2] : message, {
-      type: 'snackbar'
-    });
-  };
-
-  const isDarkElement = (0, _element.useRef)();
-  const isCoverDark = useCoverIsDark(url, dimRatio, overlayColor.color, isDarkElement);
-  (0, _element.useEffect)(() => {
-    // This side-effect should not create an undo level.
-    __unstableMarkNextChangeAsNotPersistent();
-
-    setAttributes({
-      isDark: isCoverDark
-    });
-  }, [isCoverDark]);
-  const isImageBackground = _shared.IMAGE_BACKGROUND_TYPE === backgroundType;
-  const isVideoBackground = _shared.VIDEO_BACKGROUND_TYPE === backgroundType;
-  const minHeightWithUnit = minHeight && minHeightUnit ? `${minHeight}${minHeightUnit}` : minHeight;
-  const isImgElement = !(hasParallax || isRepeated);
-  const style = { ...(isImageBackground && !isImgElement ? (0, _shared.backgroundImageStyles)(url) : undefined),
-    minHeight: minHeightWithUnit || undefined
-  };
-  const bgStyle = {
-    backgroundColor: overlayColor.color
-  };
-  const mediaStyle = {
-    objectPosition: focalPoint && isImgElement ? mediaPosition(focalPoint) : undefined
-  };
-  const hasBackground = !!(url || overlayColor.color || gradientValue);
-  const showFocalPointPicker = isVideoBackground || isImageBackground && (!hasParallax || isRepeated);
-
-  const imperativeFocalPointPreview = value => {
-    const [styleOfRef, property] = isDarkElement.current ? [isDarkElement.current.style, 'objectPosition'] : [ref.current.style, 'backgroundPosition'];
-    styleOfRef[property] = mediaPosition(value);
-  };
-
-  const hasInnerBlocks = (0, _data.useSelect)(select => select(_blockEditor.store).getBlock(clientId).innerBlocks.length > 0, [clientId]);
-  const controls = (0, _element.createElement)(_element.Fragment, null, (0, _element.createElement)(_blockEditor.BlockControls, {
-    group: "block"
-  }, (0, _element.createElement)(_blockEditor.__experimentalBlockAlignmentMatrixControl, {
-    label: (0, _i18n.__)('Change content position'),
-    value: contentPosition,
-    onChange: nextPosition => setAttributes({
-      contentPosition: nextPosition
-    }),
-    isDisabled: !hasInnerBlocks
-  }), (0, _element.createElement)(_blockEditor.__experimentalBlockFullHeightAligmentControl, {
-    isActive: isMinFullHeight,
-    onToggle: toggleMinFullHeight,
-    isDisabled: !hasInnerBlocks
-  })), (0, _element.createElement)(_blockEditor.BlockControls, {
-    group: "other"
-  }, (0, _element.createElement)(_components.ToolbarButton, {
-    icon: _icons.postFeaturedImage,
-    label: (0, _i18n.__)('Use featured image'),
-    isPressed: useFeaturedImage,
-    onClick: toggleUseFeaturedImage
-  }), !useFeaturedImage && (0, _element.createElement)(_blockEditor.MediaReplaceFlow, {
-    mediaId: id,
-    mediaURL: url,
-    allowedTypes: _shared.ALLOWED_MEDIA_TYPES,
-    accept: "image/*,video/*",
-    onSelect: onSelectMedia,
-    name: !url ? (0, _i18n.__)('Add Media') : (0, _i18n.__)('Replace')
-  })), (0, _element.createElement)(_blockEditor.InspectorControls, null, !!url && (0, _element.createElement)(_components.PanelBody, {
-    title: (0, _i18n.__)('Media settings')
-  }, isImageBackground && (0, _element.createElement)(_element.Fragment, null, (0, _element.createElement)(_components.ToggleControl, {
-    label: (0, _i18n.__)('Fixed background'),
-    checked: hasParallax,
-    onChange: toggleParallax
-  }), (0, _element.createElement)(_components.ToggleControl, {
-    label: (0, _i18n.__)('Repeated background'),
-    checked: isRepeated,
-    onChange: toggleIsRepeated
-  })), showFocalPointPicker && (0, _element.createElement)(_components.FocalPointPicker, {
-    label: (0, _i18n.__)('Focal point picker'),
-    url: url,
-    value: focalPoint,
-    onDragStart: imperativeFocalPointPreview,
-    onDrag: imperativeFocalPointPreview,
-    onChange: newFocalPoint => setAttributes({
-      focalPoint: newFocalPoint
-    })
-  }), !useFeaturedImage && url && isImageBackground && isImgElement && (0, _element.createElement)(_components.TextareaControl, {
-    label: (0, _i18n.__)('Alt text (alternative text)'),
-    value: alt,
-    onChange: newAlt => setAttributes({
-      alt: newAlt
-    }),
-    help: (0, _element.createElement)(_element.Fragment, null, (0, _element.createElement)(_components.ExternalLink, {
-      href: "https://www.w3.org/WAI/tutorials/images/decision-tree"
-    }, (0, _i18n.__)('Describe the purpose of the image')), (0, _i18n.__)('Leave empty if the image is purely decorative.'))
-  }), (0, _element.createElement)(_components.PanelRow, null, (0, _element.createElement)(_components.Button, {
-    variant: "secondary",
-    isSmall: true,
-    className: "block-library-cover__reset-button",
-    onClick: () => setAttributes({
-      url: undefined,
-      id: undefined,
-      backgroundType: undefined,
-      focalPoint: undefined,
-      hasParallax: undefined,
-      isRepeated: undefined,
-      useFeaturedImage: false
-    })
-  }, (0, _i18n.__)('Clear Media')))), (0, _element.createElement)(_blockEditor.__experimentalPanelColorGradientSettings, {
-    __experimentalHasMultipleOrigins: true,
-    __experimentalIsRenderedInSidebar: true,
-    title: (0, _i18n.__)('Overlay'),
-    initialOpen: true,
-    settings: [{
-      colorValue: overlayColor.color,
-      gradientValue,
-      onColorChange: setOverlayColor,
-      onGradientChange: setGradient,
-      label: (0, _i18n.__)('Color')
-    }]
-  }, (0, _element.createElement)(_components.RangeControl, {
-    label: (0, _i18n.__)('Opacity'),
-    value: dimRatio,
-    onChange: newDimRation => setAttributes({
-      dimRatio: newDimRation
-    }),
-    min: 0,
-    max: 100,
-    step: 10,
-    required: true
-  }))), (0, _element.createElement)(_blockEditor.InspectorControls, {
-    __experimentalGroup: "dimensions"
-  }, (0, _element.createElement)(_components.__experimentalToolsPanelItem, {
-    hasValue: () => !!minHeight,
-    label: (0, _i18n.__)('Minimum height'),
-    onDeselect: () => setAttributes({
-      minHeight: undefined,
-      minHeightUnit: undefined
-    }),
-    resetAllFilter: () => ({
-      minHeight: undefined,
-      minHeightUnit: undefined
-    }),
-    isShownByDefault: true,
-    panelId: clientId
-  }, (0, _element.createElement)(CoverHeightInput, {
-    value: minHeight,
-    unit: minHeightUnit,
-    onChange: newMinHeight => setAttributes({
-      minHeight: newMinHeight
-    }),
-    onUnitChange: nextUnit => setAttributes({
-      minHeightUnit: nextUnit
-    })
-  }))));
-  const ref = (0, _element.useRef)();
-  const blockProps = (0, _blockEditor.useBlockProps)({
-    ref
-  }); // Check for fontSize support before we pass a fontSize attribute to the innerBlocks.
-
-  const hasFontSizes = !!((_useSetting = (0, _blockEditor.useSetting)('typography.fontSizes')) !== null && _useSetting !== void 0 && _useSetting.length);
-  const innerBlocksTemplate = getInnerBlocksTemplate({
-    fontSize: hasFontSizes ? 'large' : undefined
-  });
-  const innerBlocksProps = (0, _blockEditor.useInnerBlocksProps)({
-    className: 'wp-block-cover__inner-container'
-  }, {
-    template: innerBlocksTemplate,
-    templateInsertUpdatesSelection: true,
-    allowedBlocks,
-    templateLock
-  });
-
-  if (!hasInnerBlocks && !hasBackground) {
-    return (0, _element.createElement)(_element.Fragment, null, controls, (0, _element.createElement)("div", (0, _extends2.default)({}, blockProps, {
-      className: (0, _classnames.default)('is-placeholder', blockProps.className)
-    }), (0, _element.createElement)(CoverPlaceholder, {
-      onSelectMedia: onSelectMedia,
-      onError: onUploadError,
-      style: {
-        minHeight: minHeightWithUnit || undefined
-      }
-    }, (0, _element.createElement)("div", {
-      className: "wp-block-cover__placeholder-background-options"
-    }, (0, _element.createElement)(_blockEditor.ColorPalette, {
-      disableCustomColors: true,
-      value: overlayColor.color,
-      onChange: setOverlayColor,
-      clearable: false
-    }))), (0, _element.createElement)(ResizableCover, {
-      className: "block-library-cover__resize-container",
-      onResizeStart: () => {
-        setAttributes({
-          minHeightUnit: 'px'
-        });
-        toggleSelection(false);
-      },
-      onResize: value => {
-        setAttributes({
-          minHeight: value
-        });
-      },
-      onResizeStop: newMinHeight => {
-        toggleSelection(true);
-        setAttributes({
-          minHeight: newMinHeight
-        });
-      },
-      showHandle: isSelected
-    })));
-  }
-
-  const classes = (0, _classnames.default)({
-    'is-dark-theme': isDark,
-    'is-light': !isDark,
-    'is-transient': isUploadingMedia,
-    'has-parallax': hasParallax,
-    'is-repeated': isRepeated,
-    'has-custom-content-position': !(0, _shared.isContentPositionCenter)(contentPosition)
-  }, (0, _shared.getPositionClassName)(contentPosition));
-  return (0, _element.createElement)(_element.Fragment, null, controls, (0, _element.createElement)("div", (0, _extends2.default)({}, blockProps, {
-    className: (0, _classnames.default)(classes, blockProps.className),
-    style: { ...style,
-      ...blockProps.style
-    },
-    "data-url": url
-  }), (0, _element.createElement)(BoxControlVisualizer, {
-    values: styleAttribute === null || styleAttribute === void 0 ? void 0 : (_styleAttribute$spaci = styleAttribute.spacing) === null || _styleAttribute$spaci === void 0 ? void 0 : _styleAttribute$spaci.padding,
-    showValues: styleAttribute === null || styleAttribute === void 0 ? void 0 : (_styleAttribute$visua = styleAttribute.visualizers) === null || _styleAttribute$visua === void 0 ? void 0 : _styleAttribute$visua.padding,
-    className: "block-library-cover__padding-visualizer"
-  }), (0, _element.createElement)(ResizableCover, {
-    className: "block-library-cover__resize-container",
-    onResizeStart: () => {
-      setAttributes({
-        minHeightUnit: 'px'
-      });
-      toggleSelection(false);
-    },
-    onResize: value => {
-      setAttributes({
-        minHeight: value
-      });
-    },
-    onResizeStop: newMinHeight => {
-      toggleSelection(true);
-      setAttributes({
-        minHeight: newMinHeight
-      });
-    },
-    showHandle: isSelected
-  }), (0, _element.createElement)("span", {
-    "aria-hidden": "true",
-    className: (0, _classnames.default)('wp-block-cover__background', (0, _shared.dimRatioToClass)(dimRatio), {
-      [overlayColor.class]: overlayColor.class,
-      'has-background-dim': dimRatio !== undefined,
-      // For backwards compatibility. Former versions of the Cover Block applied
-      // `.wp-block-cover__gradient-background` in the presence of
-      // media, a gradient and a dim.
-      'wp-block-cover__gradient-background': url && gradientValue && dimRatio !== 0,
-      'has-background-gradient': gradientValue,
-      [gradientClass]: gradientClass
-    }),
-    style: {
-      backgroundImage: gradientValue,
-      ...bgStyle
-    }
-  }), url && isImageBackground && isImgElement && (0, _element.createElement)("img", {
-    ref: isDarkElement,
-    className: "wp-block-cover__image-background",
-    alt: alt,
-    src: url,
-    style: mediaStyle
-  }), url && isVideoBackground && (0, _element.createElement)("video", {
-    ref: isDarkElement,
-    className: "wp-block-cover__video-background",
-    autoPlay: true,
-    muted: true,
-    loop: true,
-    src: url,
-    style: mediaStyle
-  }), isUploadingMedia && (0, _element.createElement)(_components.Spinner, null), (0, _element.createElement)(CoverPlaceholder, {
-    disableMediaButtons: true,
-    onSelectMedia: onSelectMedia,
-    onError: onUploadError
-  }), (0, _element.createElement)("div", innerBlocksProps)));
-}
-
-var _default = (0, _compose.compose)([(0, _blockEditor.withColors)({
-  overlayColor: 'background-color'
-})])(CoverEdit);
-
-exports.default = _default;
-//# sourceMappingURL=edit.js.map