@szymonpiatek/nextwordpress 0.0.1 → 0.0.3

package/dist/index.js

@@ -2,10 +2,22 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/client/url/url.ts
+// src/shared/url.ts
 function resolveBaseUrl(config) {
   return typeof window === "undefined" ? config.serverURL : config.clientURL;
 }
+
+// src/integrations/restApi/core/client/types.ts
+var WordPressAPIError = class extends Error {
+  constructor(message, status, endpoint) {
+    super(message);
+    __publicField(this, "status", status);
+    __publicField(this, "endpoint", endpoint);
+    this.name = "WordPressAPIError";
+  }
+};
+
+// src/integrations/restApi/core/client/url.ts
 function buildUrl(config, path, query) {
   const base = resolveBaseUrl(config);
   if (!query) return `${base}${path}`;
@@ -19,17 +31,7 @@ function buildUrl(config, path, query) {
   return qs ? `${base}${path}?${qs}` : `${base}${path}`;
 }
 
-// src/client/types/types.ts
-var WordPressAPIError = class extends Error {
-  constructor(message, status, endpoint) {
-    super(message);
-    __publicField(this, "status", status);
-    __publicField(this, "endpoint", endpoint);
-    this.name = "WordPressAPIError";
-  }
-};
-
-// src/client/fetcher/fetcher.ts
+// src/integrations/restApi/core/client/fetcher.ts
 var USER_AGENT = "NextWordpress Client";
 async function doFetch(url, init = {}) {
   const response = await fetch(url, init);
@@ -99,7 +101,7 @@ function createFetcher(config) {
   return { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful, wpMutate };
 }
 
-// src/integrations/base/posts/queries.ts
+// src/integrations/restApi/core/posts/queries.ts
 function createPostsQueries(fetcher) {
   const { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful } = fetcher;
   async function getPostsPaginated(page = 1, perPage = 9, filterParams) {
@@ -227,7 +229,7 @@ function createPostsQueries(fetcher) {
   };
 }
 
-// src/integrations/base/categories/queries.ts
+// src/integrations/restApi/core/categories/queries.ts
 function createCategoriesQueries(fetcher) {
   const { wpFetch, wpFetchGraceful } = fetcher;
   async function getAllCategories() {
@@ -252,7 +254,7 @@ function createCategoriesQueries(fetcher) {
   return { getAllCategories, getCategoryById, getCategoryBySlug, searchCategories };
 }
 
-// src/integrations/base/tags/queries.ts
+// src/integrations/restApi/core/tags/queries.ts
 function createTagsQueries(fetcher) {
   const { wpFetch, wpFetchGraceful } = fetcher;
   async function getAllTags() {
@@ -277,7 +279,7 @@ function createTagsQueries(fetcher) {
   return { getAllTags, getTagById, getTagBySlug, getTagsByPost, searchTags };
 }
 
-// src/integrations/base/authors/queries.ts
+// src/integrations/restApi/core/authors/queries.ts
 function createAuthorsQueries(fetcher) {
   const { wpFetch, wpFetchGraceful } = fetcher;
   async function getAllAuthors() {
@@ -299,7 +301,7 @@ function createAuthorsQueries(fetcher) {
   return { getAllAuthors, getAuthorById, getAuthorBySlug, searchAuthors };
 }
 
-// src/integrations/base/media/queries.ts
+// src/integrations/restApi/core/media/queries.ts
 function createMediaQueries(fetcher) {
   const { wpFetch } = fetcher;
   async function getFeaturedMediaById(id) {
@@ -308,7 +310,7 @@ function createMediaQueries(fetcher) {
   return { getFeaturedMediaById };
 }
 
-// src/integrations/base/pages/queries.ts
+// src/integrations/restApi/core/pages/queries.ts
 function createPagesQueries(fetcher) {
   const { wpFetch, wpFetchGraceful } = fetcher;
   async function getAllPages() {
@@ -327,7 +329,101 @@ function createPagesQueries(fetcher) {
   return { getAllPages, getPageById, getPageBySlug };
 }
 
-// src/integrations/base/index.ts
+// src/integrations/restApi/core/menus/queries.ts
+function createMenusQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getMenus() {
+    return wpFetchGraceful("/wp-json/wp/v2/menus", [], void 0, ["wordpress", "menus"]);
+  }
+  async function getMenuById(id) {
+    return wpFetch(`/wp-json/wp/v2/menus/${id}`, void 0, ["wordpress", "menus", `menu-${id}`]);
+  }
+  async function getMenuBySlug(slug) {
+    const menus = await wpFetchGraceful("/wp-json/wp/v2/menus", [], { slug }, ["wordpress", "menus"]);
+    return menus[0];
+  }
+  async function getMenuItemsByMenuId(menuId) {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/menu-items",
+      [],
+      { menus: menuId, per_page: 100, orderby: "menu_order", order: "asc" },
+      ["wordpress", "menus", `menu-items-${menuId}`]
+    );
+  }
+  async function getMenuLocations() {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/menu-locations",
+      {},
+      void 0,
+      ["wordpress", "menus", "menu-locations"]
+    );
+  }
+  async function getMenuByLocation(location) {
+    const locations = await getMenuLocations();
+    const loc = locations[location];
+    if (!loc || !loc.menu) return void 0;
+    const [menu, items] = await Promise.all([
+      getMenuById(loc.menu),
+      getMenuItemsByMenuId(loc.menu)
+    ]);
+    return { menu, items };
+  }
+  return {
+    getMenus,
+    getMenuById,
+    getMenuBySlug,
+    getMenuItemsByMenuId,
+    getMenuLocations,
+    getMenuByLocation
+  };
+}
+
+// src/integrations/restApi/core/comments/queries.ts
+function createCommentsQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful, wpFetchPaginatedGraceful, wpMutate } = fetcher;
+  async function getCommentsByPostId(postId, page = 1, perPage = 10) {
+    return wpFetchPaginatedGraceful(
+      "/wp-json/wp/v2/comments",
+      { post: postId, per_page: perPage, page, status: "approve" },
+      ["wordpress", "comments", `comments-post-${postId}`]
+    );
+  }
+  async function getAllCommentsByPostId(postId) {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/comments",
+      [],
+      { post: postId, per_page: 100, status: "approve" },
+      ["wordpress", "comments", `comments-post-${postId}`]
+    );
+  }
+  async function getCommentById(id) {
+    return wpFetch(`/wp-json/wp/v2/comments/${id}`, void 0, [
+      "wordpress",
+      "comments",
+      `comment-${id}`
+    ]);
+  }
+  async function getCommentReplies(parentId) {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/comments",
+      [],
+      { parent: parentId, per_page: 100, status: "approve" },
+      ["wordpress", "comments", `comments-parent-${parentId}`]
+    );
+  }
+  async function createComment(input) {
+    return wpMutate("/wp-json/wp/v2/comments", input, "POST");
+  }
+  return {
+    getCommentsByPostId,
+    getAllCommentsByPostId,
+    getCommentById,
+    getCommentReplies,
+    createComment
+  };
+}
+
+// src/integrations/restApi/core/index.ts
 function createWordPressClient(config) {
   const fetcher = createFetcher(config);
   return {
@@ -336,11 +432,13 @@ function createWordPressClient(config) {
     ...createTagsQueries(fetcher),
     ...createAuthorsQueries(fetcher),
     ...createMediaQueries(fetcher),
-    ...createPagesQueries(fetcher)
+    ...createPagesQueries(fetcher),
+    ...createMenusQueries(fetcher),
+    ...createCommentsQueries(fetcher)
   };
 }
 
-// src/integrations/woocommerce/omnibus/queries.ts
+// src/integrations/restApi/woocommerce/omnibus/queries.ts
 var META_KEY_LOWEST_PRICE = "wpo_lowest_price";
 var META_KEY_PRICE_HISTORY = "_alg_wc_price_history";
 function extractMetaValue(meta_data, key) {
@@ -369,7 +467,7 @@ function withOmnibusVariation(variation) {
   };
 }
 
-// src/integrations/woocommerce/client/fetcher.ts
+// src/integrations/restApi/woocommerce/client/fetcher.ts
 var USER_AGENT2 = "NextWordpress WooCommerce Client";
 var DEFAULT_CACHE_TTL = 3600;
 function toQueryString(params) {
@@ -451,7 +549,7 @@ function createWooCommerceFetcher(config) {
   return { wcFetch, wcFetchGraceful, wcFetchPaginated, wcFetchPaginatedGraceful, wcMutate };
 }
 
-// src/integrations/woocommerce/products/queries.ts
+// src/integrations/restApi/woocommerce/products/queries.ts
 function buildProductQuery(base, filterParams) {
   const query = { ...base };
   if (!filterParams) return query;
@@ -578,7 +676,7 @@ function createProductsQueries(fetcher) {
   };
 }
 
-// src/integrations/woocommerce/categories/queries.ts
+// src/integrations/restApi/woocommerce/categories/queries.ts
 function createCategoriesQueries2(fetcher) {
   const { wcFetch, wcFetchGraceful } = fetcher;
   async function getAllProductCategories() {
@@ -627,7 +725,7 @@ function createCategoriesQueries2(fetcher) {
   };
 }
 
-// src/integrations/woocommerce/tags/queries.ts
+// src/integrations/restApi/woocommerce/tags/queries.ts
 function createTagsQueries2(fetcher) {
   const { wcFetch, wcFetchGraceful } = fetcher;
   async function getAllProductTags() {
@@ -660,7 +758,7 @@ function createTagsQueries2(fetcher) {
   };
 }
 
-// src/integrations/woocommerce/orders/queries.ts
+// src/integrations/restApi/woocommerce/orders/queries.ts
 function createOrdersQueries(fetcher) {
   const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
   async function createOrder(input) {
@@ -692,7 +790,7 @@ function createOrdersQueries(fetcher) {
   };
 }
 
-// src/integrations/woocommerce/coupons/queries.ts
+// src/integrations/restApi/woocommerce/coupons/queries.ts
 function createCouponsQueries(fetcher) {
   const { wcFetchGraceful } = fetcher;
   async function getCouponByCode(code) {
@@ -722,7 +820,7 @@ function createCouponsQueries(fetcher) {
   };
 }
 
-// src/integrations/woocommerce/customers/queries.ts
+// src/integrations/restApi/woocommerce/customers/queries.ts
 function createCustomersQueries(fetcher) {
   const { wcFetch, wcFetchGraceful } = fetcher;
   async function getCustomerById(id) {
@@ -770,7 +868,7 @@ function createCustomersQueries(fetcher) {
   };
 }
 
-// src/integrations/woocommerce/index.ts
+// src/integrations/restApi/woocommerce/index.ts
 function createWooCommerceClient(config) {
   const fetcher = createWooCommerceFetcher(config);
   return {
@@ -783,6 +881,1190 @@ function createWooCommerceClient(config) {
   };
 }
 
-export { buildUrl, createFetcher, createWooCommerceClient, createWooCommerceFetcher, createWordPressClient, extractOmnibusData, resolveBaseUrl, withOmnibus, withOmnibusVariation };
+// src/integrations/wpGraphQL/client/types.ts
+var WPGraphQLError = class extends Error {
+  constructor(message, status, endpoint, gqlErrors) {
+    super(message);
+    __publicField(this, "status", status);
+    __publicField(this, "endpoint", endpoint);
+    __publicField(this, "gqlErrors", gqlErrors);
+    this.name = "WPGraphQLError";
+  }
+};
+
+// src/integrations/wpGraphQL/client/fetcher.ts
+var USER_AGENT3 = "NextWordpress WPGraphQL Client";
+var CACHE_TTL = 300;
+function createWPGraphQLFetcher(config) {
+  const url = `${resolveBaseUrl(config)}/graphql`;
+  async function gqlFetch(document, variables, tags = ["wpgraphql"]) {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT3
+      },
+      body: JSON.stringify({ query: document, variables }),
+      next: { tags, revalidate: CACHE_TTL }
+    });
+    if (!response.ok) {
+      throw new WPGraphQLError(
+        `WPGraphQL request failed: ${response.statusText}`,
+        response.status,
+        url
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.errors && parsed.errors.length > 0) {
+      throw new WPGraphQLError(
+        parsed.errors[0].message,
+        200,
+        url,
+        parsed.errors
+      );
+    }
+    if (parsed.data === void 0) {
+      throw new WPGraphQLError("No data returned from WPGraphQL", 200, url);
+    }
+    return parsed.data;
+  }
+  async function gqlFetchGraceful(document, fallback, variables, tags = ["wpgraphql"]) {
+    try {
+      return await gqlFetch(document, variables, tags);
+    } catch {
+      console.warn(`WPGraphQL fetch failed for query`);
+      return fallback;
+    }
+  }
+  return { gqlFetch, gqlFetchGraceful };
+}
+
+// src/integrations/wpGraphQL/core/posts/queries.ts
+var DEFAULT_FIRST = 10;
+var BATCH_FIRST = 100;
+var POST_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  excerpt
+  date
+  modified
+  status
+  uri
+  author {
+    node {
+      databaseId
+      name
+      slug
+      avatar { url }
+    }
+  }
+  featuredImage {
+    node {
+      sourceUrl
+      altText
+      mediaDetails { width height }
+    }
+  }
+  categories {
+    nodes { databaseId name slug }
+  }
+  tags {
+    nodes { databaseId name slug }
+  }
+`;
+var POST_FIELDS_WITH_CONTENT = `
+  ${POST_FIELDS}
+  content
+`;
+var GQL_GET_POSTS = `
+  query GetPosts($first: Int, $after: String, $where: RootQueryToPostConnectionWhereArgs) {
+    posts(first: $first, after: $after, where: $where) {
+      nodes { ${POST_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_POST_BY_SLUG = `
+  query GetPostBySlug($slug: ID!) {
+    post(id: $slug, idType: SLUG) { ${POST_FIELDS_WITH_CONTENT} }
+  }
+`;
+var GQL_GET_POST_BY_DATABASE_ID = `
+  query GetPostByDatabaseId($id: ID!) {
+    post(id: $id, idType: DATABASE_ID) { ${POST_FIELDS_WITH_CONTENT} }
+  }
+`;
+var GQL_GET_ALL_POST_SLUGS = `
+  query GetAllPostSlugs($first: Int, $after: String) {
+    posts(first: $first, after: $after) {
+      nodes { slug }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+var GQL_GET_ALL_POSTS_FOR_SITEMAP = `
+  query GetAllPostsForSitemap($first: Int, $after: String) {
+    posts(first: $first, after: $after) {
+      nodes { slug modified }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+function createPostsQueries2(fetcher) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  async function getPosts(first = DEFAULT_FIRST, after, filter) {
+    const where = {};
+    if (filter?.authorName) where["authorName"] = filter.authorName;
+    if (filter?.categoryName) where["categoryName"] = filter.categoryName;
+    if (filter?.tag) where["tag"] = filter.tag;
+    if (filter?.search) where["search"] = filter.search;
+    if (filter?.status) where["status"] = filter.status;
+    const data = await gqlFetchGraceful(
+      GQL_GET_POSTS,
+      { posts: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after, where: Object.keys(where).length > 0 ? where : void 0 },
+      ["wpgraphql", "gql-posts"]
+    );
+    return data.posts;
+  }
+  async function getPostBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_POST_BY_SLUG,
+      { post: null },
+      { slug },
+      ["wpgraphql", "gql-posts", `gql-post-${slug}`]
+    );
+    return data.post;
+  }
+  async function getPostByDatabaseId(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_POST_BY_DATABASE_ID,
+      { post: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-posts", `gql-post-id-${id}`]
+    );
+    return data.post;
+  }
+  async function getRecentPosts(first = DEFAULT_FIRST) {
+    const connection = await getPosts(first);
+    return connection.nodes;
+  }
+  async function getAllPostSlugs() {
+    try {
+      const all = [];
+      let after = void 0;
+      let hasNextPage = true;
+      while (hasNextPage) {
+        const data = await gqlFetch(GQL_GET_ALL_POST_SLUGS, { first: BATCH_FIRST, after }, ["wpgraphql"]);
+        all.push(...data.posts.nodes);
+        hasNextPage = data.posts.pageInfo.hasNextPage;
+        after = data.posts.pageInfo.endCursor;
+      }
+      return all;
+    } catch {
+      console.warn("WPGraphQL unavailable, skipping static generation for posts");
+      return [];
+    }
+  }
+  async function getAllPostsForSitemap() {
+    try {
+      const all = [];
+      let after = void 0;
+      let hasNextPage = true;
+      while (hasNextPage) {
+        const data = await gqlFetch(
+          GQL_GET_ALL_POSTS_FOR_SITEMAP,
+          { first: BATCH_FIRST, after },
+          ["wpgraphql"]
+        );
+        all.push(...data.posts.nodes);
+        hasNextPage = data.posts.pageInfo.hasNextPage;
+        after = data.posts.pageInfo.endCursor;
+      }
+      return all;
+    } catch {
+      console.warn("WPGraphQL unavailable, skipping sitemap generation");
+      return [];
+    }
+  }
+  return {
+    getPosts,
+    getPostBySlug,
+    getPostByDatabaseId,
+    getRecentPosts,
+    getAllPostSlugs,
+    getAllPostsForSitemap
+  };
+}
+
+// src/integrations/wpGraphQL/core/pages/queries.ts
+var DEFAULT_FIRST2 = 10;
+var BATCH_FIRST2 = 100;
+var PAGE_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  content
+  date
+  modified
+  status
+  uri
+  featuredImage {
+    node {
+      sourceUrl
+      altText
+      mediaDetails { width height }
+    }
+  }
+`;
+var GQL_GET_PAGES = `
+  query GetPages($first: Int, $after: String) {
+    pages(first: $first, after: $after) {
+      nodes { ${PAGE_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_PAGE_BY_SLUG = `
+  query GetPageBySlug($uri: ID!) {
+    page(id: $uri, idType: URI) { ${PAGE_FIELDS} }
+  }
+`;
+var GQL_GET_PAGE_BY_URI = `
+  query GetPageByUri($uri: ID!) {
+    page(id: $uri, idType: URI) { ${PAGE_FIELDS} }
+  }
+`;
+var GQL_GET_ALL_PAGE_URIS = `
+  query GetAllPageUris($first: Int, $after: String) {
+    pages(first: $first, after: $after) {
+      nodes { uri }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+function createPagesQueries2(fetcher) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  async function getPages(first = DEFAULT_FIRST2, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGES,
+      { pages: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-pages"]
+    );
+    return data.pages;
+  }
+  async function getPageBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGE_BY_SLUG,
+      { page: null },
+      { uri: `/${slug}/` },
+      ["wpgraphql", "gql-pages", `gql-page-${slug}`]
+    );
+    return data.page;
+  }
+  async function getPageByUri(uri) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGE_BY_URI,
+      { page: null },
+      { uri },
+      ["wpgraphql", "gql-pages", `gql-page-uri-${uri.replace(/\//g, "-")}`]
+    );
+    return data.page;
+  }
+  async function getAllPageUris() {
+    try {
+      const all = [];
+      let after = void 0;
+      let hasNextPage = true;
+      while (hasNextPage) {
+        const data = await gqlFetch(GQL_GET_ALL_PAGE_URIS, { first: BATCH_FIRST2, after }, ["wpgraphql"]);
+        all.push(...data.pages.nodes);
+        hasNextPage = data.pages.pageInfo.hasNextPage;
+        after = data.pages.pageInfo.endCursor;
+      }
+      return all;
+    } catch {
+      console.warn("WPGraphQL unavailable, skipping static generation for pages");
+      return [];
+    }
+  }
+  return { getPages, getPageBySlug, getPageByUri, getAllPageUris };
+}
+
+// src/integrations/wpGraphQL/core/categories/queries.ts
+var DEFAULT_FIRST3 = 100;
+var CATEGORY_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+  description
+  count
+  uri
+  parent {
+    node { databaseId name slug }
+  }
+`;
+var GQL_GET_CATEGORIES = `
+  query GetCategories($first: Int, $after: String) {
+    categories(first: $first, after: $after) {
+      nodes { ${CATEGORY_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_CATEGORY_BY_SLUG = `
+  query GetCategoryBySlug($slug: ID!) {
+    category(id: $slug, idType: SLUG) { ${CATEGORY_FIELDS} }
+  }
+`;
+var GQL_GET_CATEGORY_BY_DATABASE_ID = `
+  query GetCategoryByDatabaseId($id: ID!) {
+    category(id: $id, idType: DATABASE_ID) { ${CATEGORY_FIELDS} }
+  }
+`;
+function createCategoriesQueries3(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getCategories(first = DEFAULT_FIRST3, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_CATEGORIES,
+      { categories: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-categories"]
+    );
+    return data.categories;
+  }
+  async function getCategoryBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_CATEGORY_BY_SLUG,
+      { category: null },
+      { slug },
+      ["wpgraphql", "gql-categories", `gql-category-${slug}`]
+    );
+    return data.category;
+  }
+  async function getCategoryByDatabaseId(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_CATEGORY_BY_DATABASE_ID,
+      { category: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-categories", `gql-category-id-${id}`]
+    );
+    return data.category;
+  }
+  return { getCategories, getCategoryBySlug, getCategoryByDatabaseId };
+}
+
+// src/integrations/wpGraphQL/core/tags/queries.ts
+var DEFAULT_FIRST4 = 100;
+var TAG_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+  description
+  count
+  uri
+`;
+var GQL_GET_TAGS = `
+  query GetTags($first: Int, $after: String) {
+    tags(first: $first, after: $after) {
+      nodes { ${TAG_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_TAG_BY_SLUG = `
+  query GetTagBySlug($slug: ID!) {
+    tag(id: $slug, idType: SLUG) { ${TAG_FIELDS} }
+  }
+`;
+function createTagsQueries3(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getTags(first = DEFAULT_FIRST4, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_TAGS,
+      { tags: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-tags"]
+    );
+    return data.tags;
+  }
+  async function getTagBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_TAG_BY_SLUG,
+      { tag: null },
+      { slug },
+      ["wpgraphql", "gql-tags", `gql-tag-${slug}`]
+    );
+    return data.tag;
+  }
+  return { getTags, getTagBySlug };
+}
+
+// src/integrations/wpGraphQL/core/authors/queries.ts
+var DEFAULT_FIRST5 = 100;
+var AUTHOR_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+  description
+  email
+  uri
+  avatar { url width height }
+`;
+var GQL_GET_AUTHORS = `
+  query GetAuthors($first: Int, $after: String) {
+    users(first: $first, after: $after) {
+      nodes { ${AUTHOR_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_AUTHOR_BY_SLUG = `
+  query GetAuthorBySlug($slug: String!) {
+    users(where: { login: $slug }) {
+      nodes { ${AUTHOR_FIELDS} }
+    }
+  }
+`;
+function createAuthorsQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getAuthors(first = DEFAULT_FIRST5, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_AUTHORS,
+      { users: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-authors"]
+    );
+    return data.users;
+  }
+  async function getAuthorBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_AUTHOR_BY_SLUG,
+      { users: { nodes: [] } },
+      { slug },
+      ["wpgraphql", "gql-authors", `gql-author-${slug}`]
+    );
+    return data.users.nodes[0] ?? null;
+  }
+  return { getAuthors, getAuthorBySlug };
+}
+
+// src/integrations/wpGraphQL/core/menus/queries.ts
+var MENU_ITEM_FIELDS = `
+  id
+  databaseId
+  label
+  url
+  parentId
+  order
+  target
+  cssClasses
+  description
+  connectedNode {
+    node {
+      __typename
+      ... on Page { id databaseId slug }
+      ... on Post { id databaseId slug }
+      ... on Category { id databaseId slug }
+      ... on Tag { id databaseId slug }
+    }
+  }
+`;
+var MENU_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+  locations
+  menuItems(first: 100) {
+    nodes { ${MENU_ITEM_FIELDS} }
+  }
+`;
+var GQL_GET_MENUS = `
+  query GetMenus {
+    menus(first: 100) {
+      nodes { ${MENU_FIELDS} }
+    }
+  }
+`;
+var GQL_GET_MENU_BY_ID = `
+  query GetMenuById($id: ID!) {
+    menu(id: $id, idType: DATABASE_ID) { ${MENU_FIELDS} }
+  }
+`;
+var GQL_GET_MENU_BY_SLUG = `
+  query GetMenuBySlug($id: ID!) {
+    menu(id: $id, idType: SLUG) { ${MENU_FIELDS} }
+  }
+`;
+var GQL_GET_MENUS_BY_LOCATION = `
+  query GetMenusByLocation($location: MenuLocationEnum!) {
+    menus(where: { location: $location }, first: 1) {
+      nodes { ${MENU_FIELDS} }
+    }
+  }
+`;
+function createMenusQueries2(fetcher) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  async function getMenus() {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MENUS,
+      { menus: { nodes: [] } },
+      void 0,
+      ["wpgraphql", "gql-menus"]
+    );
+    return data.menus.nodes;
+  }
+  async function getMenuById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MENU_BY_ID,
+      { menu: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-menus", `gql-menu-${id}`]
+    );
+    return data.menu;
+  }
+  async function getMenuBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MENU_BY_SLUG,
+      { menu: null },
+      { id: slug },
+      ["wpgraphql", "gql-menus", `gql-menu-${slug}`]
+    );
+    return data.menu;
+  }
+  async function getMenuByLocation(location) {
+    const data = await gqlFetch(
+      GQL_GET_MENUS_BY_LOCATION,
+      { location: location.toUpperCase() },
+      ["wpgraphql", "gql-menus", `gql-menu-location-${location}`]
+    );
+    return data.menus.nodes[0] ?? null;
+  }
+  async function getMenuItems(menuSlug) {
+    const menu = await getMenuBySlug(menuSlug);
+    return menu?.menuItems?.nodes ?? [];
+  }
+  return {
+    getMenus,
+    getMenuById,
+    getMenuBySlug,
+    getMenuByLocation,
+    getMenuItems
+  };
+}
+
+// src/integrations/wpGraphQL/core/comments/queries.ts
+var COMMENT_AUTHOR_FIELDS = `
+  name
+  url
+  avatar { url width height }
+`;
+var COMMENT_FIELDS = `
+  id
+  databaseId
+  content(format: RENDERED)
+  date
+  parentId
+  status
+  author { node { ${COMMENT_AUTHOR_FIELDS} } }
+`;
+var GQL_GET_COMMENTS_BY_POST = `
+  query GetCommentsByPost($contentId: ID!, $first: Int, $after: String) {
+    comments(
+      first: $first
+      after: $after
+      where: { contentId: $contentId, status: "approve", parent: 0 }
+    ) {
+      nodes {
+        ${COMMENT_FIELDS}
+        replies(first: 100) {
+          nodes { ${COMMENT_FIELDS} }
+        }
+      }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+var GQL_GET_ALL_COMMENTS_BY_POST = `
+  query GetAllCommentsByPost($contentId: ID!) {
+    comments(
+      first: 100
+      where: { contentId: $contentId, status: "approve" }
+    ) {
+      nodes { ${COMMENT_FIELDS} }
+    }
+  }
+`;
+var GQL_GET_COMMENT_BY_ID = `
+  query GetCommentById($id: ID!) {
+    comment(id: $id, idType: DATABASE_ID) { ${COMMENT_FIELDS} }
+  }
+`;
+function createCommentsQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getCommentsByPostId(postId, first = 10, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COMMENTS_BY_POST,
+      { comments: { nodes: [], pageInfo: { hasNextPage: false } } },
+      { contentId: String(postId), first, after },
+      ["wpgraphql", "gql-comments", `gql-comments-post-${postId}`]
+    );
+    return data.comments;
+  }
+  async function getAllCommentsByPostId(postId) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_ALL_COMMENTS_BY_POST,
+      { comments: { nodes: [] } },
+      { contentId: String(postId) },
+      ["wpgraphql", "gql-comments", `gql-comments-post-${postId}`]
+    );
+    return data.comments.nodes;
+  }
+  async function getCommentById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COMMENT_BY_ID,
+      { comment: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-comments", `gql-comment-${id}`]
+    );
+    return data.comment;
+  }
+  return {
+    getCommentsByPostId,
+    getAllCommentsByPostId,
+    getCommentById
+  };
+}
+
+// src/integrations/wpGraphQL/core/index.ts
+function createWPGraphQLCoreClient(config) {
+  const fetcher = createWPGraphQLFetcher(config);
+  return {
+    ...createPostsQueries2(fetcher),
+    ...createPagesQueries2(fetcher),
+    ...createCategoriesQueries3(fetcher),
+    ...createTagsQueries3(fetcher),
+    ...createAuthorsQueries2(fetcher),
+    ...createMenusQueries2(fetcher),
+    ...createCommentsQueries2(fetcher)
+  };
+}
+
+// src/integrations/wpGraphQL/yoast/queries.ts
+var SEO_FIELDS = `
+  seo {
+    title
+    metaDesc
+    canonical
+    opengraphTitle
+    opengraphDescription
+    opengraphImage { sourceUrl altText }
+    twitterTitle
+    twitterDescription
+    twitterImage { sourceUrl }
+    schema { raw }
+  }
+`;
+var POST_FIELDS_WITH_SEO = `
+  id
+  databaseId
+  slug
+  title
+  content
+  excerpt
+  date
+  modified
+  status
+  uri
+  author {
+    node {
+      databaseId
+      name
+      slug
+      avatar { url }
+    }
+  }
+  featuredImage {
+    node {
+      sourceUrl
+      altText
+      mediaDetails { width height }
+    }
+  }
+  categories {
+    nodes { databaseId name slug }
+  }
+  tags {
+    nodes { databaseId name slug }
+  }
+  ${SEO_FIELDS}
+`;
+var PAGE_FIELDS_WITH_SEO = `
+  id
+  databaseId
+  slug
+  title
+  content
+  date
+  modified
+  status
+  uri
+  featuredImage {
+    node {
+      sourceUrl
+      altText
+      mediaDetails { width height }
+    }
+  }
+  ${SEO_FIELDS}
+`;
+var GQL_GET_POST_WITH_SEO = `
+  query GetPostWithSEO($slug: ID!) {
+    post(id: $slug, idType: SLUG) { ${POST_FIELDS_WITH_SEO} }
+  }
+`;
+var GQL_GET_PAGE_WITH_SEO = `
+  query GetPageWithSEO($slug: ID!) {
+    page(id: $slug, idType: SLUG) { ${PAGE_FIELDS_WITH_SEO} }
+  }
+`;
+var GQL_GET_PAGE_WITH_SEO_BY_URI = `
+  query GetPageWithSEOByUri($uri: ID!) {
+    page(id: $uri, idType: URI) { ${PAGE_FIELDS_WITH_SEO} }
+  }
+`;
+function createYoastQueries(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getPostWithSEO(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_POST_WITH_SEO,
+      { post: null },
+      { slug },
+      ["wpgraphql", "gql-posts", "gql-yoast", `gql-post-${slug}`]
+    );
+    return data.post;
+  }
+  async function getPageWithSEO(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGE_WITH_SEO,
+      { page: null },
+      { slug },
+      ["wpgraphql", "gql-pages", "gql-yoast", `gql-page-${slug}`]
+    );
+    return data.page;
+  }
+  async function getPageWithSEOByUri(uri) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGE_WITH_SEO_BY_URI,
+      { page: null },
+      { uri },
+      ["wpgraphql", "gql-pages", "gql-yoast", `gql-page-uri-${uri.replace(/\//g, "-")}`]
+    );
+    return data.page;
+  }
+  return { getPostWithSEO, getPageWithSEO, getPageWithSEOByUri };
+}
+
+// src/integrations/wpGraphQL/acf/helpers.ts
+var BASE_POST_FIELDS = `
+  id databaseId slug title content excerpt date modified status uri
+  author { node { databaseId name slug avatar { url } } }
+  featuredImage { node { sourceUrl altText mediaDetails { width height } } }
+  categories { nodes { databaseId name slug } }
+  tags { nodes { databaseId name slug } }
+`;
+var BASE_PAGE_FIELDS = `
+  id databaseId slug title content date modified status uri
+  featuredImage { node { sourceUrl altText mediaDetails { width height } } }
+`;
+function buildACFFragment(fieldGroupName, fields) {
+  return `${fieldGroupName} { ${fields.join(" ")} }`;
+}
+function buildPostWithACFQuery(fieldGroupName, fields) {
+  return `
+    query GetPostWithACF($slug: ID!) {
+      post(id: $slug, idType: SLUG) {
+        ${BASE_POST_FIELDS}
+        ${buildACFFragment(fieldGroupName, fields)}
+      }
+    }
+  `;
+}
+function buildPageWithACFQuery(fieldGroupName, fields) {
+  return `
+    query GetPageWithACF($slug: ID!) {
+      page(id: $slug, idType: SLUG) {
+        ${BASE_PAGE_FIELDS}
+        ${buildACFFragment(fieldGroupName, fields)}
+      }
+    }
+  `;
+}
+function buildPostsWithACFQuery(fieldGroupName, fields) {
+  return `
+    query GetPostsWithACF($first: Int, $after: String) {
+      posts(first: $first, after: $after) {
+        nodes {
+          ${BASE_POST_FIELDS}
+          ${buildACFFragment(fieldGroupName, fields)}
+        }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }
+  `;
+}
+
+// src/integrations/wpGraphQL/woocommerce/products/queries.ts
+var DEFAULT_FIRST6 = 10;
+var BATCH_FIRST3 = 100;
+var PRODUCT_FIELDS = `
+  id
+  databaseId
+  slug
+  name
+  status
+  description
+  shortDescription
+  type
+  onSale
+  featuredImage { node { sourceUrl altText } }
+  galleryImages { nodes { sourceUrl altText } }
+  productCategories { nodes { databaseId name slug } }
+  productTags { nodes { databaseId name slug } }
+  ... on SimpleProduct {
+    sku
+    price
+    regularPrice
+    salePrice
+    stockStatus
+    stockQuantity
+    manageStock
+  }
+  ... on VariableProduct {
+    price
+    regularPrice
+    salePrice
+    stockStatus
+    stockQuantity
+    manageStock
+    variations {
+      nodes {
+        id
+        databaseId
+        slug
+        sku
+        price
+        regularPrice
+        salePrice
+        onSale
+        stockStatus
+        stockQuantity
+        image { sourceUrl altText }
+        attributes { nodes { name value } }
+      }
+    }
+  }
+`;
+var GQL_GET_PRODUCTS = `
+  query GetProducts($first: Int, $after: String, $where: RootQueryToProductConnectionWhereArgs) {
+    products(first: $first, after: $after, where: $where) {
+      nodes { ${PRODUCT_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_PRODUCT_BY_SLUG = `
+  query GetProductBySlug($slug: ID!) {
+    product(id: $slug, idType: SLUG) { ${PRODUCT_FIELDS} }
+  }
+`;
+var GQL_GET_PRODUCT_BY_DATABASE_ID = `
+  query GetProductByDatabaseId($id: ID!) {
+    product(id: $id, idType: DATABASE_ID) { ${PRODUCT_FIELDS} }
+  }
+`;
+var GQL_GET_ALL_PRODUCT_SLUGS = `
+  query GetAllProductSlugs($first: Int, $after: String) {
+    products(first: $first, after: $after) {
+      nodes { slug }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+function createProductsQueries2(fetcher) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  async function getProducts(first = DEFAULT_FIRST6, after, filter) {
+    const where = {};
+    if (filter?.search) where["search"] = filter.search;
+    if (filter?.onSale !== void 0) where["onSale"] = filter.onSale;
+    if (filter?.featured !== void 0) where["featured"] = filter.featured;
+    if (filter?.stockStatus) where["stockStatus"] = filter.stockStatus;
+    if (filter?.minPrice) where["minPrice"] = filter.minPrice;
+    if (filter?.maxPrice) where["maxPrice"] = filter.maxPrice;
+    if (filter?.categoryId) where["categoryIdIn"] = [filter.categoryId];
+    if (filter?.tagId) where["tagIdIn"] = [filter.tagId];
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCTS,
+      { products: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after, where: Object.keys(where).length > 0 ? where : void 0 },
+      ["wpgraphql", "gql-products"]
+    );
+    return data.products;
+  }
+  async function getProductBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_BY_SLUG,
+      { product: null },
+      { slug },
+      ["wpgraphql", "gql-products", `gql-product-${slug}`]
+    );
+    return data.product;
+  }
+  async function getProductByDatabaseId(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_BY_DATABASE_ID,
+      { product: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-products", `gql-product-id-${id}`]
+    );
+    return data.product;
+  }
+  async function getFeaturedProducts(first = DEFAULT_FIRST6) {
+    const connection = await getProducts(first, void 0, { featured: true });
+    return connection.nodes;
+  }
+  async function getOnSaleProducts(first = DEFAULT_FIRST6) {
+    const connection = await getProducts(first, void 0, { onSale: true });
+    return connection.nodes;
+  }
+  async function getAllProductSlugs() {
+    try {
+      const all = [];
+      let after = void 0;
+      let hasNextPage = true;
+      while (hasNextPage) {
+        const data = await gqlFetch(GQL_GET_ALL_PRODUCT_SLUGS, { first: BATCH_FIRST3, after }, ["wpgraphql"]);
+        all.push(...data.products.nodes);
+        hasNextPage = data.products.pageInfo.hasNextPage;
+        after = data.products.pageInfo.endCursor;
+      }
+      return all;
+    } catch {
+      console.warn("WPGraphQL unavailable, skipping static generation for products");
+      return [];
+    }
+  }
+  return {
+    getProducts,
+    getProductBySlug,
+    getProductByDatabaseId,
+    getFeaturedProducts,
+    getOnSaleProducts,
+    getAllProductSlugs
+  };
+}
+
+// src/integrations/wpGraphQL/woocommerce/orders/queries.ts
+var DEFAULT_FIRST7 = 10;
+var ADDRESS_FIELDS = `
+  firstName lastName address1 address2 city postcode country email phone
+`;
+var ORDER_FIELDS = `
+  id
+  databaseId
+  orderNumber
+  status
+  date
+  modified
+  total
+  subtotal
+  totalTax
+  shippingTotal
+  currency
+  billing { ${ADDRESS_FIELDS} }
+  shipping { ${ADDRESS_FIELDS} }
+  lineItems {
+    nodes {
+      productId
+      variationId
+      quantity
+      subtotal
+      total
+      product { node { databaseId name slug } }
+    }
+  }
+`;
+var GQL_GET_ORDER = `
+  query GetOrder($id: ID!) {
+    order(id: $id, idType: DATABASE_ID) { ${ORDER_FIELDS} }
+  }
+`;
+var GQL_GET_MY_ORDERS = `
+  query GetMyOrders($first: Int, $after: String) {
+    orders(first: $first, after: $after) {
+      nodes { ${ORDER_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+function createOrdersQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getOrder(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_ORDER,
+      { order: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-orders", `gql-order-${id}`]
+    );
+    return data.order;
+  }
+  async function getMyOrders(first = DEFAULT_FIRST7, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MY_ORDERS,
+      { orders: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-orders"]
+    );
+    return data.orders;
+  }
+  return { getOrder, getMyOrders };
+}
+
+// src/integrations/wpGraphQL/woocommerce/customers/queries.ts
+var ADDRESS_FIELDS2 = `
+  firstName lastName address1 address2 city postcode country
+`;
+var CUSTOMER_FIELDS = `
+  id
+  databaseId
+  email
+  firstName
+  lastName
+  username
+  billing { ${ADDRESS_FIELDS2} phone }
+  shipping { ${ADDRESS_FIELDS2} }
+`;
+var GQL_GET_CUSTOMER = `
+  query GetCustomer {
+    customer { ${CUSTOMER_FIELDS} }
+  }
+`;
+var GQL_GET_CUSTOMER_BY_ID = `
+  query GetCustomerById($id: ID!) {
+    customer(customerId: $id) { ${CUSTOMER_FIELDS} }
+  }
+`;
+function createCustomersQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getCustomer() {
+    const data = await gqlFetchGraceful(
+      GQL_GET_CUSTOMER,
+      { customer: null },
+      void 0,
+      ["wpgraphql", "gql-customer"]
+    );
+    return data.customer;
+  }
+  async function getCustomerById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_CUSTOMER_BY_ID,
+      { customer: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-customer", `gql-customer-${id}`]
+    );
+    return data.customer;
+  }
+  return { getCustomer, getCustomerById };
+}
+
+// src/integrations/wpGraphQL/woocommerce/index.ts
+function createWPGraphQLWooCommerceClient(config) {
+  const fetcher = createWPGraphQLFetcher(config);
+  return {
+    ...createProductsQueries2(fetcher),
+    ...createOrdersQueries2(fetcher),
+    ...createCustomersQueries2(fetcher)
+  };
+}
+
+// src/integrations/wpGraphQL/cpt/queries.ts
+var DEFAULT_FIRST8 = 10;
+var BATCH_FIRST4 = 100;
+var BASE_CPT_FIELDS = `
+  id databaseId slug title date modified status uri
+`;
+function createCPTQueries(fetcher, typeName, singularTypeName, extraFields) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  const fields = extraFields ? `${BASE_CPT_FIELDS} ${extraFields}` : BASE_CPT_FIELDS;
+  const GQL_GET_ITEMS = `
+    query GetCPT_${typeName}($first: Int, $after: String) {
+      ${typeName}(first: $first, after: $after) {
+        nodes { ${fields} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }
+  `;
+  const GQL_GET_ITEM_BY_SLUG = `
+    query GetCPT_${singularTypeName}BySlug($slug: ID!) {
+      ${singularTypeName}(id: $slug, idType: SLUG) { ${fields} }
+    }
+  `;
+  const GQL_GET_ALL_SLUGS = `
+    query GetAllCPT_${typeName}Slugs($first: Int, $after: String) {
+      ${typeName}(first: $first, after: $after) {
+        nodes { slug }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  `;
+  async function getItems(first = DEFAULT_FIRST8, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_ITEMS,
+      { [typeName]: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", `gql-${typeName}`]
+    );
+    return data[typeName] ?? { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } };
+  }
+  async function getItemBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_ITEM_BY_SLUG,
+      { [singularTypeName]: null },
+      { slug },
+      ["wpgraphql", `gql-${typeName}`, `gql-${singularTypeName}-${slug}`]
+    );
+    return data[singularTypeName] ?? null;
+  }
+  async function getAllSlugs() {
+    try {
+      const all = [];
+      let after = void 0;
+      let hasNextPage = true;
+      while (hasNextPage) {
+        const data = await gqlFetch(GQL_GET_ALL_SLUGS, { first: BATCH_FIRST4, after }, ["wpgraphql"]);
+        const connection = data[typeName];
+        if (!connection) break;
+        all.push(...connection.nodes);
+        hasNextPage = connection.pageInfo.hasNextPage;
+        after = connection.pageInfo.endCursor;
+      }
+      return all;
+    } catch {
+      console.warn(`WPGraphQL unavailable, skipping static generation for ${typeName}`);
+      return [];
+    }
+  }
+  return { getItems, getItemBySlug, getAllSlugs };
+}
+
+export { WPGraphQLError, buildACFFragment, buildPageWithACFQuery, buildPostWithACFQuery, buildPostsWithACFQuery, createCPTQueries, createWPGraphQLCoreClient as createWPGraphQLClient, createWPGraphQLCoreClient, createWPGraphQLFetcher, createWPGraphQLWooCommerceClient, createWooCommerceClient, createWooCommerceFetcher, createWordPressClient, createYoastQueries, extractOmnibusData, resolveBaseUrl, withOmnibus, withOmnibusVariation };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map