// packages/block-library/src/query/edit/inspector-controls/index.js
import {
  TextControl,
  SelectControl,
  Notice,
  __experimentalVStack as VStack,
  __experimentalToolsPanel as ToolsPanel,
  __experimentalToolsPanelItem as ToolsPanelItem,
  __experimentalToggleGroupControl as ToggleGroupControl,
  __experimentalToggleGroupControlOption as ToggleGroupControlOption
} from "@wordpress/components";
import { useSelect } from "@wordpress/data";
import { store as coreStore } from "@wordpress/core-data";
import { __ } from "@wordpress/i18n";
import { debounce } from "@wordpress/compose";
import { useState, useMemo } from "@wordpress/element";
import OrderControl from "./order-control.mjs";
import AuthorControl from "./author-control.mjs";
import ParentControl from "./parent-control.mjs";
import { TaxonomyControls } from "./taxonomy-controls.mjs";
import FormatControls from "./format-controls.mjs";
import StickyControl from "./sticky-control.mjs";
import PerPageControl from "./per-page-control.mjs";
import OffsetControl from "./offset-controls.mjs";
import PagesControl from "./pages-control.mjs";
import {
  usePostTypes,
  useIsPostTypeHierarchical,
  useAllowedControls,
  isControlAllowed,
  useTaxonomies,
  useOrderByOptions
} from "../../utils.mjs";
import { useToolsPanelDropdownMenuProps } from "../../../utils/hooks.mjs";
import { Fragment, jsx, jsxs } from "react/jsx-runtime";
function QueryInspectorControls(props) {
  const { attributes, setQuery, isSingular } = props;
  const { query } = attributes;
  const {
    order,
    orderBy,
    author: authorIds,
    pages,
    postType,
    perPage,
    offset,
    sticky,
    inherit,
    taxQuery,
    parents,
    format
  } = query;
  const allowedControls = useAllowedControls(attributes);
  const showSticky = postType === "post";
  const {
    postTypesTaxonomiesMap,
    postTypesSelectOptions,
    postTypeFormatSupportMap
  } = usePostTypes();
  const taxonomies = useTaxonomies(postType);
  const isPostTypeHierarchical = useIsPostTypeHierarchical(postType);
  const onPostTypeChange = (newValue) => {
    const updateQuery = { postType: newValue };
    const supportedTaxonomies = postTypesTaxonomiesMap[newValue];
    if (!!supportedTaxonomies?.length && !!taxQuery) {
      const buildTaxQuery = (_taxQuery) => {
        return Object.entries(_taxQuery || {}).reduce(
          (accumulator, [taxonomy, terms]) => {
            if (supportedTaxonomies.includes(taxonomy)) {
              accumulator[taxonomy] = terms;
            }
            return accumulator;
          },
          {}
        );
      };
      const updatedTaxQuery = {};
      const builtIncludeTaxQuery = buildTaxQuery(taxQuery.include);
      if (!!Object.keys(builtIncludeTaxQuery).length) {
        updatedTaxQuery.include = builtIncludeTaxQuery;
      }
      const builtExcludeTaxQuery = buildTaxQuery(taxQuery.exclude);
      if (!!Object.keys(builtExcludeTaxQuery).length) {
        updatedTaxQuery.exclude = builtExcludeTaxQuery;
      }
      updateQuery.taxQuery = !!Object.keys(updatedTaxQuery).length ? updatedTaxQuery : void 0;
    }
    if (newValue !== "post") {
      updateQuery.sticky = "";
    }
    updateQuery.parents = [];
    const hasFormatSupport = postTypeFormatSupportMap[newValue];
    if (!hasFormatSupport) {
      updateQuery.format = [];
    }
    setQuery(updateQuery);
  };
  const [querySearch, setQuerySearch] = useState(query.search);
  const debouncedQuerySearch = useMemo(() => {
    return debounce((newQuerySearch) => {
      setQuery({ search: newQuerySearch });
    }, 250);
  }, [setQuery]);
  const orderByOptions = useOrderByOptions(postType);
  const showInheritControl = isControlAllowed(allowedControls, "inherit");
  const showPostTypeControl = !inherit && isControlAllowed(allowedControls, "postType");
  const postTypeControlLabel = __("Post type");
  const postTypeControlHelp = __(
    "Select the type of content to display: posts, pages, or custom post types."
  );
  const showOrderControl = !inherit && isControlAllowed(allowedControls, "order");
  const showStickyControl = !inherit && showSticky && isControlAllowed(allowedControls, "sticky");
  const showSettingsPanel = showInheritControl || showPostTypeControl || showOrderControl || showStickyControl;
  const showTaxControl = !!taxonomies?.length && isControlAllowed(allowedControls, "taxQuery");
  const showAuthorControl = isControlAllowed(allowedControls, "author");
  const showSearchControl = isControlAllowed(allowedControls, "search");
  const showParentControl = isControlAllowed(allowedControls, "parents") && isPostTypeHierarchical;
  const postTypeHasFormatSupport = postTypeFormatSupportMap[postType];
  const showFormatControl = useSelect(
    (select) => {
      if (!postTypeHasFormatSupport || !isControlAllowed(allowedControls, "format")) {
        return false;
      }
      const themeSupports = select(coreStore).getThemeSupports();
      return themeSupports.formats && themeSupports.formats.length > 0 && themeSupports.formats.some((type) => type !== "standard");
    },
    [allowedControls, postTypeHasFormatSupport]
  );
  const showFiltersPanel = showTaxControl || showAuthorControl || showSearchControl || showParentControl || showFormatControl;
  const dropdownMenuProps = useToolsPanelDropdownMenuProps();
  const showPostCountControl = isControlAllowed(
    allowedControls,
    "postCount"
  );
  const showOffSetControl = isControlAllowed(allowedControls, "offset");
  const showPagesControl = isControlAllowed(allowedControls, "pages");
  const showDisplayPanel = showPostCountControl || showOffSetControl || showPagesControl;
  const hasInheritanceWarning = isSingular && inherit;
  return /* @__PURE__ */ jsxs(Fragment, { children: [
    showSettingsPanel && /* @__PURE__ */ jsxs(
      ToolsPanel,
      {
        label: __("Settings"),
        resetAll: () => {
          setQuery({
            postType: "post",
            order: "desc",
            orderBy: "date",
            sticky: "",
            inherit: true
          });
        },
        dropdownMenuProps,
        children: [
          showInheritControl && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              hasValue: () => !inherit,
              label: __("Query type"),
              onDeselect: () => setQuery({ inherit: true }),
              isShownByDefault: true,
              children: /* @__PURE__ */ jsxs(VStack, { spacing: 4, children: [
                /* @__PURE__ */ jsxs(
                  ToggleGroupControl,
                  {
                    __next40pxDefaultSize: true,
                    label: __("Query type"),
                    isBlock: true,
                    onChange: (value) => {
                      setQuery({
                        inherit: value === "default"
                      });
                    },
                    help: inherit ? __(
                      "Display a list of posts or custom post types based on the current template."
                    ) : __(
                      "Display a list of posts or custom post types based on specific criteria."
                    ),
                    value: !!inherit ? "default" : "custom",
                    children: [
                      /* @__PURE__ */ jsx(
                        ToggleGroupControlOption,
                        {
                          value: "default",
                          label: __("Default")
                        }
                      ),
                      /* @__PURE__ */ jsx(
                        ToggleGroupControlOption,
                        {
                          value: "custom",
                          label: __("Custom")
                        }
                      )
                    ]
                  }
                ),
                hasInheritanceWarning && /* @__PURE__ */ jsx(
                  Notice,
                  {
                    status: "warning",
                    isDismissible: false,
                    children: __(
                      "Cannot inherit the current template query when placed inside the singular content (e.g., post, page, 404, blank)."
                    )
                  }
                )
              ] })
            }
          ),
          showPostTypeControl && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              hasValue: () => postType !== "post",
              label: postTypeControlLabel,
              onDeselect: () => onPostTypeChange("post"),
              isShownByDefault: true,
              children: postTypesSelectOptions.length > 2 ? /* @__PURE__ */ jsx(
                SelectControl,
                {
                  __next40pxDefaultSize: true,
                  options: postTypesSelectOptions,
                  value: postType,
                  label: postTypeControlLabel,
                  onChange: onPostTypeChange,
                  help: postTypeControlHelp
                }
              ) : /* @__PURE__ */ jsx(
                ToggleGroupControl,
                {
                  __next40pxDefaultSize: true,
                  isBlock: true,
                  value: postType,
                  label: postTypeControlLabel,
                  onChange: onPostTypeChange,
                  help: postTypeControlHelp,
                  children: postTypesSelectOptions.map(
                    (option) => /* @__PURE__ */ jsx(
                      ToggleGroupControlOption,
                      {
                        value: option.value,
                        label: option.label
                      },
                      option.value
                    )
                  )
                }
              )
            }
          ),
          showOrderControl && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              hasValue: () => order !== "desc" || orderBy !== "date",
              label: __("Order by"),
              onDeselect: () => setQuery({ order: "desc", orderBy: "date" }),
              isShownByDefault: true,
              children: /* @__PURE__ */ jsx(
                OrderControl,
                {
                  ...{ order, orderBy, orderByOptions },
                  onChange: setQuery
                }
              )
            }
          ),
          showStickyControl && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              hasValue: () => !!sticky,
              label: __("Sticky posts"),
              onDeselect: () => setQuery({ sticky: "" }),
              isShownByDefault: true,
              children: /* @__PURE__ */ jsx(
                StickyControl,
                {
                  value: sticky,
                  onChange: (value) => setQuery({ sticky: value })
                }
              )
            }
          )
        ]
      }
    ),
    !inherit && showDisplayPanel && /* @__PURE__ */ jsxs(
      ToolsPanel,
      {
        className: "block-library-query-toolspanel__display",
        label: __("Display"),
        resetAll: () => {
          setQuery({
            offset: 0,
            pages: 0
          });
        },
        dropdownMenuProps,
        children: [
          /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              label: __("Items per page"),
              hasValue: () => perPage > 0,
              children: /* @__PURE__ */ jsx(
                PerPageControl,
                {
                  perPage,
                  offset,
                  onChange: setQuery
                }
              )
            }
          ),
          /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              label: __("Offset"),
              hasValue: () => offset > 0,
              onDeselect: () => setQuery({ offset: 0 }),
              children: /* @__PURE__ */ jsx(
                OffsetControl,
                {
                  offset,
                  onChange: setQuery
                }
              )
            }
          ),
          /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              label: __("Max pages to show"),
              hasValue: () => pages > 0,
              onDeselect: () => setQuery({ pages: 0 }),
              children: /* @__PURE__ */ jsx(PagesControl, { pages, onChange: setQuery })
            }
          )
        ]
      }
    ),
    !inherit && showFiltersPanel && /* @__PURE__ */ jsxs(
      ToolsPanel,
      {
        className: "block-library-query-toolspanel__filters",
        label: __("Filters"),
        resetAll: () => {
          setQuery({
            author: "",
            parents: [],
            search: "",
            taxQuery: null,
            format: []
          });
          setQuerySearch("");
        },
        dropdownMenuProps,
        children: [
          showTaxControl && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              label: __("Taxonomies"),
              hasValue: () => Object.values(taxQuery || {}).some(
                (value) => Object.values(value || {}).some(
                  (termIds) => !!termIds?.length
                )
              ),
              onDeselect: () => setQuery({ taxQuery: null }),
              children: /* @__PURE__ */ jsx(
                TaxonomyControls,
                {
                  onChange: setQuery,
                  query
                }
              )
            }
          ),
          showAuthorControl && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              hasValue: () => !!authorIds,
              label: __("Authors"),
              onDeselect: () => setQuery({ author: "" }),
              children: /* @__PURE__ */ jsx(
                AuthorControl,
                {
                  value: authorIds,
                  onChange: setQuery
                }
              )
            }
          ),
          showSearchControl && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              hasValue: () => !!querySearch,
              label: __("Keyword"),
              onDeselect: () => {
                setQuery({ search: "" });
                setQuerySearch("");
              },
              children: /* @__PURE__ */ jsx(
                TextControl,
                {
                  label: __("Keyword"),
                  value: querySearch,
                  onChange: (newQuerySearch) => {
                    debouncedQuerySearch(newQuerySearch);
                    setQuerySearch(newQuerySearch);
                  }
                }
              )
            }
          ),
          showParentControl && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              hasValue: () => !!parents?.length,
              label: __("Parents"),
              onDeselect: () => setQuery({ parents: [] }),
              children: /* @__PURE__ */ jsx(
                ParentControl,
                {
                  parents,
                  postType,
                  onChange: setQuery
                }
              )
            }
          ),
          showFormatControl && /* @__PURE__ */ jsx(
            ToolsPanelItem,
            {
              hasValue: () => !!format?.length,
              label: __("Formats"),
              onDeselect: () => setQuery({ format: [] }),
              children: /* @__PURE__ */ jsx(
                FormatControls,
                {
                  onChange: setQuery,
                  query
                }
              )
            }
          )
        ]
      }
    )
  ] });
}
export {
  QueryInspectorControls as default
};
//# sourceMappingURL=index.mjs.map
