// packages/block-library/src/cover/edit/inspector-controls.js
import { useMemo } from "@wordpress/element";
import {
  FocalPointPicker,
  RangeControl,
  TextareaControl,
  ToggleControl,
  __experimentalUseCustomUnits as useCustomUnits,
  __experimentalToolsPanel as ToolsPanel,
  __experimentalToolsPanelItem as ToolsPanelItem,
  __experimentalUnitControl as UnitControl,
  __experimentalParseQuantityAndUnitFromRawValue as parseQuantityAndUnitFromRawValue
} from "@wordpress/components";
import { useInstanceId } from "@wordpress/compose";
import {
  InspectorControls,
  useSettings,
  store as blockEditorStore,
  __experimentalColorGradientSettingsDropdown as ColorGradientSettingsDropdown,
  __experimentalUseGradient,
  __experimentalUseMultipleOriginColorsAndGradients as useMultipleOriginColorsAndGradients,
  privateApis as blockEditorPrivateApis
} from "@wordpress/block-editor";
import { __ } from "@wordpress/i18n";
import { useSelect } from "@wordpress/data";
import { store as coreStore } from "@wordpress/core-data";
import { Link } from "@wordpress/ui";
import { COVER_MIN_HEIGHT, mediaPosition } from "../shared.mjs";
import { unlock } from "../../lock-unlock.mjs";
import { useToolsPanelDropdownMenuProps } from "../../utils/hooks.mjs";
import {
  getActiveDimensionValue,
  getDimensionResetAttributes,
  getDimensionUpdateAttributes,
  getStyleStateKey
} from "../../utils/style-state.mjs";
import { DEFAULT_MEDIA_SIZE_SLUG } from "../constants.mjs";
import PosterImage from "../../utils/poster-image.mjs";
import { Fragment, jsx, jsxs } from "react/jsx-runtime";
var {
  cleanEmptyObject,
  isDefaultBlockStyleState,
  ResolutionTool,
  HTMLElementControl
} = unlock(blockEditorPrivateApis);
function CoverHeightInput({
  onChange,
  onUnitChange,
  unit = "px",
  value = ""
}) {
  const instanceId = useInstanceId(UnitControl);
  const inputId = `block-cover-height-input-${instanceId}`;
  const isPx = unit === "px";
  const [availableUnits] = useSettings("spacing.units");
  const units = useCustomUnits({
    availableUnits: availableUnits || ["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) : void 0;
    if (isNaN(inputValue) && inputValue !== void 0) {
      return;
    }
    onChange(inputValue);
  };
  const computedValue = useMemo(() => {
    const [parsedQuantity] = parseQuantityAndUnitFromRawValue(value);
    return [parsedQuantity, unit].join("");
  }, [unit, value]);
  const min = isPx ? COVER_MIN_HEIGHT : 0;
  return /* @__PURE__ */ jsx(
    UnitControl,
    {
      __next40pxDefaultSize: true,
      label: __("Minimum height"),
      id: inputId,
      isResetValueOnUnitChange: true,
      min,
      onChange: handleOnChange,
      onUnitChange,
      units,
      value: computedValue
    }
  );
}
function CoverInspectorControls({
  attributes,
  setAttributes,
  clientId,
  setOverlayColor,
  coverRef,
  currentSettings,
  updateDimRatio,
  featuredImage
}) {
  const {
    useFeaturedImage,
    id,
    dimRatio,
    focalPoint,
    hasParallax,
    isRepeated,
    minHeight,
    minHeightUnit,
    alt,
    tagName,
    poster
  } = attributes;
  const {
    isVideoBackground,
    isImageBackground,
    mediaElement,
    url,
    overlayColor
  } = currentSettings;
  const sizeSlug = attributes.sizeSlug || DEFAULT_MEDIA_SIZE_SLUG;
  const { gradientValue, setGradient } = __experimentalUseGradient();
  const { imageSizes, selectedStyleState } = useSelect(
    (select) => {
      const { getSettings, getSelectedBlockStyleState } = unlock(
        select(blockEditorStore)
      );
      return {
        imageSizes: getSettings()?.imageSizes,
        selectedStyleState: getSelectedBlockStyleState(clientId)
      };
    },
    [clientId]
  );
  const hasSelectedStyleState = !isDefaultBlockStyleState(selectedStyleState);
  const selectedStyleStateKey = getStyleStateKey(selectedStyleState);
  const stateMinHeight = getActiveDimensionValue({
    attributes,
    selectedState: selectedStyleState,
    hasSelectedStyleState,
    attributeKey: "minHeight",
    styleKey: "minHeight",
    rootValue: void 0
  });
  const [stateMinHeightValue, stateMinHeightUnit] = parseQuantityAndUnitFromRawValue(stateMinHeight || "");
  const activeMinHeight = hasSelectedStyleState ? stateMinHeightValue : minHeight;
  const activeMinHeightUnit = hasSelectedStyleState ? stateMinHeightUnit || minHeightUnit : minHeightUnit;
  const activeAspectRatio = getActiveDimensionValue({
    attributes,
    selectedState: selectedStyleState,
    hasSelectedStyleState,
    attributeKey: "aspectRatio",
    rootValue: attributes?.style?.dimensions?.aspectRatio
  });
  const image = useSelect(
    (select) => id && isImageBackground ? select(coreStore).getEntityRecord(
      "postType",
      "attachment",
      id,
      { context: "view" }
    ) : null,
    [id, isImageBackground]
  );
  const currentBackgroundImage = useFeaturedImage ? featuredImage : image;
  function updateImage(newSizeSlug) {
    const newUrl = currentBackgroundImage?.media_details?.sizes?.[newSizeSlug]?.source_url;
    if (!newUrl) {
      return null;
    }
    setAttributes({
      url: newUrl,
      sizeSlug: newSizeSlug
    });
  }
  const imageSizeOptions = imageSizes?.filter(
    ({ slug }) => currentBackgroundImage?.media_details?.sizes?.[slug]?.source_url
  )?.map(({ name, slug }) => ({ value: slug, label: name }));
  const toggleParallax = () => {
    setAttributes({
      hasParallax: !hasParallax,
      ...!hasParallax ? { focalPoint: void 0 } : {}
    });
  };
  const toggleIsRepeated = () => {
    setAttributes({
      isRepeated: !isRepeated
    });
  };
  const showFocalPointPicker = isVideoBackground || isImageBackground;
  const imperativeFocalPointPreview = (value) => {
    const [styleOfRef, property] = mediaElement.current ? [mediaElement.current.style, "objectPosition"] : [coverRef.current.style, "backgroundPosition"];
    styleOfRef[property] = mediaPosition(value);
  };
  const colorGradientSettings = useMultipleOriginColorsAndGradients();
  const showOverlayControls = colorGradientSettings.hasColorsOrGradients && !hasSelectedStyleState;
  const setMinHeightAttributes = (nextMinHeight, nextUnit) => {
    if (hasSelectedStyleState) {
      setAttributes(
        getDimensionUpdateAttributes({
          style: attributes.style,
          selectedState: selectedStyleState,
          hasSelectedStyleState,
          nextDimensions: {
            minHeight: nextMinHeight === void 0 ? void 0 : `${nextMinHeight}${nextUnit || activeMinHeightUnit || "px"}`,
            aspectRatio: void 0
          }
        })
      );
      return;
    }
    setAttributes({
      minHeight: nextMinHeight,
      style: cleanEmptyObject({
        ...attributes?.style,
        dimensions: {
          ...attributes?.style?.dimensions,
          aspectRatio: void 0
          // Reset aspect ratio when minHeight is set.
        }
      })
    });
  };
  const getResetMinHeightAttributes = (attrs = attributes) => {
    return getDimensionResetAttributes({
      style: attrs.style,
      selectedState: selectedStyleState,
      hasSelectedStyleState,
      keys: ["minHeight"],
      defaultAttributes: {
        minHeight: void 0,
        minHeightUnit: void 0
      }
    });
  };
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  return /* @__PURE__ */ jsxs(Fragment, { children: [
    (!!url || useFeaturedImage) && /* @__PURE__ */ jsx(InspectorControls, { children: /* @__PURE__ */ jsxs(
      ToolsPanel,
      {
        label: __("Settings"),
        resetAll: () => {
          setAttributes({
            hasParallax: false,
            focalPoint: void 0,
            isRepeated: false,
            alt: "",
            poster: void 0
          });
          updateImage(DEFAULT_MEDIA_SIZE_SLUG);
        },
        dropdownMenuProps,
        children: [
          isImageBackground && /* @__PURE__ */ jsxs(Fragment, { children: [
            /* @__PURE__ */ jsx(
              ToolsPanelItem,
              {
                label: __("Fixed background"),
                isShownByDefault: true,
                hasValue: () => !!hasParallax,
                onDeselect: () => setAttributes({
                  hasParallax: false,
                  focalPoint: void 0
                }),
                children: /* @__PURE__ */ jsx(
                  ToggleControl,
                  {
                    label: __("Fixed background"),
                    checked: !!hasParallax,
                    onChange: toggleParallax
                  }
                )
              }
            ),
            /* @__PURE__ */ jsx(
              ToolsPanelItem,
              {
                label: __("Repeated background"),
                isShownByDefault: true,
                hasValue: () => isRepeated,
                onDeselect: () => setAttributes({
                  isRepeated: false
                }),
                children: /* @__PURE__ */ jsx(
                  ToggleControl,
                  {
                    label: __("Repeated background"),
                    checked: isRepeated,
                    onChange: toggleIsRepeated
                  }
                )
              }
            )
          ] }),
          showFocalPointPicker && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              label: __("Focal point"),
              isShownByDefault: true,
              hasValue: () => !!focalPoint,
              onDeselect: () => setAttributes({
                focalPoint: void 0
              }),
              children: /* @__PURE__ */ jsx(
                FocalPointPicker,
                {
                  label: __("Focal point"),
                  url,
                  value: focalPoint,
                  onDragStart: imperativeFocalPointPreview,
                  onDrag: imperativeFocalPointPreview,
                  onChange: (newFocalPoint) => setAttributes({
                    focalPoint: newFocalPoint
                  })
                }
              )
            }
          ),
          isVideoBackground && /* @__PURE__ */ jsx(
            PosterImage,
            {
              poster,
              onChange: (posterImage) => setAttributes({
                poster: posterImage?.url
              })
            }
          ),
          !useFeaturedImage && url && !isVideoBackground && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              label: __("Alternative text"),
              isShownByDefault: true,
              hasValue: () => !!alt,
              onDeselect: () => setAttributes({ alt: "" }),
              children: /* @__PURE__ */ jsx(
                TextareaControl,
                {
                  label: __("Alternative text"),
                  value: alt,
                  onChange: (newAlt) => setAttributes({ alt: newAlt }),
                  help: /* @__PURE__ */ jsxs(Fragment, { children: [
                    /* @__PURE__ */ jsx(
                      Link,
                      {
                        openInNewTab: true,
                        href: (
                          // translators: Localized tutorial, if one exists. W3C Web Accessibility Initiative link has list of existing translations.
                          __(
                            "https://www.w3.org/WAI/tutorials/images/decision-tree/"
                          )
                        ),
                        children: __(
                          "Describe the purpose of the image."
                        )
                      }
                    ),
                    /* @__PURE__ */ jsx("br", {}),
                    __(
                      "Leave empty if decorative."
                    )
                  ] })
                }
              )
            }
          ),
          !!imageSizeOptions?.length && /* @__PURE__ */ jsx(
            ResolutionTool,
            {
              value: sizeSlug,
              onChange: updateImage,
              options: imageSizeOptions,
              defaultValue: DEFAULT_MEDIA_SIZE_SLUG
            }
          )
        ]
      }
    ) }),
    showOverlayControls && /* @__PURE__ */ jsxs(InspectorControls, { group: "color", children: [
      /* @__PURE__ */ jsx(
        ColorGradientSettingsDropdown,
        {
          __experimentalIsRenderedInSidebar: true,
          settings: [
            {
              colorValue: overlayColor.color,
              gradientValue,
              label: __("Overlay"),
              onColorChange: setOverlayColor,
              onGradientChange: setGradient,
              isShownByDefault: true,
              resetAllFilter: () => ({
                overlayColor: void 0,
                customOverlayColor: void 0,
                gradient: void 0,
                customGradient: void 0
              }),
              clearable: true
            }
          ],
          panelId: clientId,
          ...colorGradientSettings
        }
      ),
      /* @__PURE__ */ jsx(
        ToolsPanelItem,
        {
          hasValue: () => {
            return dimRatio === void 0 ? false : dimRatio !== (url ? 50 : 100);
          },
          label: __("Overlay opacity"),
          onDeselect: () => updateDimRatio(url ? 50 : 100),
          resetAllFilter: () => ({
            dimRatio: url ? 50 : 100
          }),
          isShownByDefault: true,
          panelId: clientId,
          children: /* @__PURE__ */ jsx(
            RangeControl,
            {
              label: __("Overlay opacity"),
              value: dimRatio,
              onChange: (newDimRatio) => updateDimRatio(newDimRatio),
              min: 0,
              max: 100,
              step: 10,
              required: true,
              __next40pxDefaultSize: true
            }
          )
        }
      )
    ] }),
    /* @__PURE__ */ jsx(InspectorControls, { group: "dimensions", children: /* @__PURE__ */ jsx(
      ToolsPanelItem,
      {
        className: "single-column",
        hasValue: () => !!activeMinHeight,
        label: __("Minimum height"),
        onDeselect: () => setAttributes(getResetMinHeightAttributes()),
        resetAllFilter: getResetMinHeightAttributes,
        isShownByDefault: true,
        panelId: clientId,
        children: /* @__PURE__ */ jsx(
          CoverHeightInput,
          {
            value: activeAspectRatio ? "" : activeMinHeight,
            unit: activeMinHeightUnit,
            onChange: (newMinHeight) => setMinHeightAttributes(newMinHeight),
            onUnitChange: (nextUnit) => {
              if (hasSelectedStyleState) {
                if (activeMinHeight !== void 0) {
                  setMinHeightAttributes(
                    activeMinHeight,
                    nextUnit
                  );
                }
                return;
              }
              setAttributes({
                minHeightUnit: nextUnit
              });
            }
          }
        )
      },
      selectedStyleStateKey
    ) }),
    /* @__PURE__ */ jsx(InspectorControls, { group: "advanced", children: /* @__PURE__ */ jsx(
      HTMLElementControl,
      {
        tagName,
        onChange: (value) => setAttributes({ tagName: value }),
        clientId,
        options: [
          { label: __("Default (<div>)"), value: "div" },
          { label: "<header>", value: "header" },
          { label: "<main>", value: "main" },
          { label: "<section>", value: "section" },
          { label: "<article>", value: "article" },
          { label: "<aside>", value: "aside" },
          { label: "<footer>", value: "footer" }
        ]
      }
    ) })
  ] });
}
export {
  CoverInspectorControls as default
};
//# sourceMappingURL=inspector-controls.mjs.map
