// packages/block-library/src/post-template/edit.js
import clsx from "clsx";
import { memo, useMemo, useState } from "@wordpress/element";
import { useSelect } from "@wordpress/data";
import { __, _x } from "@wordpress/i18n";
import {
  BlockControls,
  BlockContextProvider,
  __experimentalUseBlockPreview as useBlockPreview,
  useBlockProps,
  useInnerBlocksProps,
  store as blockEditorStore
} from "@wordpress/block-editor";
import { Spinner, ToolbarGroup } from "@wordpress/components";
import { store as coreStore } from "@wordpress/core-data";
import { list, grid } from "@wordpress/icons";
import { Fragment, jsx, jsxs } from "react/jsx-runtime";
var TEMPLATE = [
  ["core/post-title"],
  [
    "core/post-date",
    {
      metadata: {
        bindings: {
          datetime: {
            source: "core/post-data",
            args: { field: "date" }
          }
        }
      }
    }
  ],
  ["core/post-excerpt"]
];
function PostTemplateInnerBlocks({ classList }) {
  const innerBlocksProps = useInnerBlocksProps(
    { className: clsx("wp-block-post", classList) },
    { template: TEMPLATE, __unstableDisableLayoutClassNames: true }
  );
  return /* @__PURE__ */ jsx("li", { ...innerBlocksProps });
}
function PostTemplateBlockPreview({
  blocks,
  blockContextId,
  classList,
  isHidden,
  setActiveBlockContextId
}) {
  const blockPreviewProps = useBlockPreview({
    blocks,
    props: {
      className: clsx("wp-block-post", classList)
    }
  });
  const handleOnClick = () => {
    setActiveBlockContextId(blockContextId);
  };
  const style = {
    display: isHidden ? "none" : void 0
  };
  return /* @__PURE__ */ jsx(
    "li",
    {
      ...blockPreviewProps,
      tabIndex: 0,
      role: "button",
      onClick: handleOnClick,
      onKeyPress: handleOnClick,
      style
    }
  );
}
var MemoizedPostTemplateBlockPreview = memo(PostTemplateBlockPreview);
function PostTemplateEdit({
  setAttributes,
  clientId,
  context: {
    query: {
      perPage,
      offset = 0,
      postType,
      order,
      orderBy,
      author,
      search,
      exclude,
      sticky,
      inherit,
      taxQuery,
      parents,
      pages,
      format,
      // We gather extra query args to pass to the REST API call.
      // This way extenders of Query Loop can add their own query args,
      // and have accurate previews in the editor.
      // Noting though that these args should either be supported by the
      // REST API or be handled by custom REST filters like `rest_{$this->post_type}_query`.
      ...restQueryArgs
    } = {},
    templateSlug,
    previewPostType
  },
  attributes: { layout },
  __unstableLayoutClassNames
}) {
  const {
    type: layoutType,
    columnCount = 3,
    minimumColumnWidth
  } = layout || {};
  const [activeBlockContextId, setActiveBlockContextId] = useState();
  const { posts, blocks } = useSelect(
    (select) => {
      const { getEntityRecords, getTaxonomies } = select(coreStore);
      const { getBlocks } = select(blockEditorStore);
      const templateCategory = inherit && templateSlug?.startsWith("category-") && getEntityRecords("taxonomy", "category", {
        context: "view",
        per_page: 1,
        _fields: ["id"],
        slug: templateSlug.replace("category-", "")
      });
      const templateTag = inherit && templateSlug?.startsWith("tag-") && getEntityRecords("taxonomy", "post_tag", {
        context: "view",
        per_page: 1,
        _fields: ["id"],
        slug: templateSlug.replace("tag-", "")
      });
      const query = {
        offset: offset || 0,
        order,
        orderby: orderBy
      };
      if (taxQuery && !inherit) {
        const taxonomies = getTaxonomies({
          type: postType,
          per_page: -1,
          context: "view"
        });
        const buildTaxQuery = (terms, suffix = "") => {
          return Object.entries(terms || {}).reduce(
            (accumulator, [taxonomySlug, termIds]) => {
              const taxonomy = taxonomies?.find(
                ({ slug }) => slug === taxonomySlug
              );
              if (taxonomy?.rest_base && termIds?.length) {
                accumulator[taxonomy.rest_base + suffix] = termIds;
              }
              return accumulator;
            },
            {}
          );
        };
        const builtTaxQuery = buildTaxQuery(taxQuery.include);
        if (taxQuery.exclude) {
          Object.assign(
            builtTaxQuery,
            buildTaxQuery(taxQuery.exclude, "_exclude")
          );
        }
        if (!!Object.keys(builtTaxQuery).length) {
          Object.assign(query, builtTaxQuery);
        }
      }
      if (perPage) {
        query.per_page = perPage;
      }
      if (author) {
        query.author = author;
      }
      if (search) {
        query.search = search;
      }
      if (exclude?.length) {
        query.exclude = exclude;
      }
      if (parents?.length) {
        query.parent = parents;
      }
      if (format?.length) {
        query.format = format;
      }
      if (["exclude", "only"].includes(sticky)) {
        query.sticky = sticky === "only";
      }
      if (["", "ignore"].includes(sticky)) {
        delete query.sticky;
        query.ignore_sticky = sticky === "ignore";
      }
      let currentPostType = postType;
      if (inherit) {
        if (templateSlug?.startsWith("archive-")) {
          query.postType = templateSlug.replace("archive-", "");
          currentPostType = query.postType;
        } else if (templateCategory) {
          query.categories = templateCategory[0]?.id;
        } else if (templateTag) {
          query.tags = templateTag[0]?.id;
        } else if (templateSlug?.startsWith("taxonomy-post_format")) {
          query.format = templateSlug.replace(
            "taxonomy-post_format-post-format-",
            ""
          );
        }
      }
      const usedPostType = previewPostType || currentPostType;
      return {
        posts: getEntityRecords("postType", usedPostType, {
          ...query,
          ...restQueryArgs
        }),
        blocks: getBlocks(clientId)
      };
    },
    [
      perPage,
      offset,
      order,
      orderBy,
      clientId,
      author,
      search,
      postType,
      exclude,
      sticky,
      inherit,
      templateSlug,
      taxQuery,
      parents,
      format,
      restQueryArgs,
      previewPostType
    ]
  );
  const blockContexts = useMemo(
    () => posts?.map((post) => ({
      postType: post.type,
      postId: post.id,
      classList: post.class_list ?? ""
    })),
    [posts]
  );
  const blockProps = useBlockProps({
    className: clsx(__unstableLayoutClassNames, {
      [`columns-${columnCount}`]: layoutType === "grid" && columnCount,
      // Ensure column count is flagged via classname for backwards compatibility.
      "has-native-responsive-grid": layoutType === "grid" && columnCount && minimumColumnWidth
      // Flag native responsive grid when minimum column width is provided.
    })
  });
  if (!posts) {
    return /* @__PURE__ */ jsx("p", { ...blockProps, children: /* @__PURE__ */ jsx(Spinner, {}) });
  }
  if (!posts.length) {
    return /* @__PURE__ */ jsxs("p", { ...blockProps, children: [
      " ",
      __("No results found.")
    ] });
  }
  const setDisplayLayout = (newDisplayLayout) => setAttributes({
    layout: { ...layout, ...newDisplayLayout }
  });
  const displayLayoutControls = [
    {
      icon: list,
      title: _x("List view", "Post template block display setting"),
      onClick: () => setDisplayLayout({ type: "default" }),
      isActive: layoutType === "default" || layoutType === "constrained"
    },
    {
      icon: grid,
      title: _x("Grid view", "Post template block display setting"),
      onClick: () => setDisplayLayout({
        type: "grid",
        columnCount
      }),
      isActive: layoutType === "grid"
    }
  ];
  return /* @__PURE__ */ jsxs(Fragment, { children: [
    /* @__PURE__ */ jsx(BlockControls, { children: /* @__PURE__ */ jsx(ToolbarGroup, { controls: displayLayoutControls }) }),
    /* @__PURE__ */ jsx("ul", { ...blockProps, children: blockContexts && blockContexts.map((blockContext) => /* @__PURE__ */ jsxs(
      BlockContextProvider,
      {
        value: blockContext,
        children: [
          blockContext.postId === (activeBlockContextId || blockContexts[0]?.postId) ? /* @__PURE__ */ jsx(
            PostTemplateInnerBlocks,
            {
              classList: blockContext.classList
            }
          ) : null,
          /* @__PURE__ */ jsx(
            MemoizedPostTemplateBlockPreview,
            {
              blocks,
              blockContextId: blockContext.postId,
              classList: blockContext.classList,
              setActiveBlockContextId,
              isHidden: blockContext.postId === (activeBlockContextId || blockContexts[0]?.postId)
            }
          )
        ]
      },
      blockContext.postId
    )) })
  ] });
}
export {
  PostTemplateEdit as default
};
//# sourceMappingURL=edit.mjs.map
