@szymonpiatek/nextwordpress 0.0.3 → 0.0.5

package/dist/hooks/index.js

@@ -0,0 +1,855 @@
+import useSWR2 from 'swr';
+
+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/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/shared/url.ts
+function resolveBaseUrl(config) {
+  return typeof window === "undefined" ? config.serverURL : config.clientURL;
+}
+
+// src/integrations/restApi/core/client/url.ts
+function buildUrl(config, path, query) {
+  const base = resolveBaseUrl(config);
+  if (!query) return `${base}${path}`;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0 && value !== null) {
+      params.set(key, String(value));
+    }
+  }
+  const qs = params.toString();
+  return qs ? `${base}${path}?${qs}` : `${base}${path}`;
+}
+
+// src/integrations/restApi/core/client/fetcher.ts
+var USER_AGENT = "NextWordpress Client";
+async function doFetch(url, init = {}) {
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    throw new WordPressAPIError(
+      `WordPress API request failed: ${response.statusText}`,
+      response.status,
+      url
+    );
+  }
+  return response;
+}
+function createFetcher(config) {
+  const cacheTtl = 300;
+  async function wpFetch(path, query, tags = ["wordpress"]) {
+    const url = buildUrl(config, path, query);
+    const res = await doFetch(url, {
+      headers: { "User-Agent": USER_AGENT },
+      next: { tags, revalidate: cacheTtl }
+    });
+    return await res.json();
+  }
+  async function wpFetchGraceful(path, fallback, query, tags = ["wordpress"]) {
+    try {
+      return await wpFetch(path, query, tags);
+    } catch {
+      console.warn(`WordPress fetch failed for ${path}`);
+      return fallback;
+    }
+  }
+  async function wpFetchPaginated(path, query, tags = ["wordpress"]) {
+    const url = buildUrl(config, path, query);
+    const res = await doFetch(url, {
+      headers: { "User-Agent": USER_AGENT },
+      next: { tags, revalidate: cacheTtl }
+    });
+    return {
+      data: await res.json(),
+      headers: {
+        total: parseInt(res.headers.get("X-WP-Total") ?? "0", 10),
+        totalPages: parseInt(res.headers.get("X-WP-TotalPages") ?? "0", 10)
+      }
+    };
+  }
+  async function wpFetchPaginatedGraceful(path, query, tags = ["wordpress"]) {
+    const empty = { data: [], headers: { total: 0, totalPages: 0 } };
+    try {
+      return await wpFetchPaginated(path, query, tags);
+    } catch {
+      console.warn(`WordPress paginated fetch failed for ${path}`);
+      return empty;
+    }
+  }
+  async function wpMutate(path, body, method = "POST", authToken) {
+    const url = buildUrl(config, path);
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT
+    };
+    if (authToken) {
+      headers["Authorization"] = authToken;
+    }
+    const res = await doFetch(url, {
+      method,
+      headers,
+      body: JSON.stringify(body),
+      cache: "no-store"
+    });
+    return await res.json();
+  }
+  async function wpUpload(path, file, filename, mimeType, authToken) {
+    const url = buildUrl(config, path);
+    const res = await doFetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Disposition": `attachment; filename="${filename}"`,
+        "Content-Type": mimeType,
+        "User-Agent": USER_AGENT,
+        "Authorization": authToken
+      },
+      body: file,
+      cache: "no-store"
+    });
+    return await res.json();
+  }
+  return { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful, wpMutate, wpUpload };
+}
+
+// src/integrations/restApi/core/posts/queries.ts
+function createPostsQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful } = fetcher;
+  async function getPostsPaginated(page = 1, perPage = 9, filterParams) {
+    const query = { _embed: true, per_page: perPage, page };
+    const cacheTags = ["wordpress", "posts", `posts-page-${page}`];
+    if (filterParams?.search) {
+      query.search = filterParams.search;
+      cacheTags.push("posts-search");
+    }
+    if (filterParams?.author) {
+      query.author = filterParams.author;
+      cacheTags.push(`posts-author-${filterParams.author}`);
+    }
+    if (filterParams?.tag) {
+      query.tags = filterParams.tag;
+      cacheTags.push(`posts-tag-${filterParams.tag}`);
+    }
+    if (filterParams?.category) {
+      query.categories = filterParams.category;
+      cacheTags.push(`posts-category-${filterParams.category}`);
+    }
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", query, cacheTags);
+  }
+  async function getRecentPosts(filterParams) {
+    const query = { _embed: true, per_page: 100 };
+    if (filterParams?.search) query.search = filterParams.search;
+    if (filterParams?.author) query.author = filterParams.author;
+    if (filterParams?.tag) query.tags = filterParams.tag;
+    if (filterParams?.category) query.categories = filterParams.category;
+    return wpFetchGraceful("/wp-json/wp/v2/posts", [], query, ["wordpress", "posts"]);
+  }
+  async function getPostById(id) {
+    return wpFetch(`/wp-json/wp/v2/posts/${id}`);
+  }
+  async function getPostBySlug(slug) {
+    const posts = await wpFetchGraceful("/wp-json/wp/v2/posts", [], { slug, _embed: true });
+    return posts[0];
+  }
+  async function getPostsByCategory(categoryId) {
+    return wpFetch("/wp-json/wp/v2/posts", { categories: categoryId });
+  }
+  async function getPostsByTag(tagId) {
+    return wpFetch("/wp-json/wp/v2/posts", { tags: tagId });
+  }
+  async function getPostsByAuthor(authorId) {
+    return wpFetch("/wp-json/wp/v2/posts", { author: authorId });
+  }
+  async function getPostsByCategoryPaginated(categoryId, page = 1, perPage = 9) {
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", {
+      _embed: true,
+      per_page: perPage,
+      page,
+      categories: categoryId
+    });
+  }
+  async function getPostsByTagPaginated(tagId, page = 1, perPage = 9) {
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", {
+      _embed: true,
+      per_page: perPage,
+      page,
+      tags: tagId
+    });
+  }
+  async function getPostsByAuthorPaginated(authorId, page = 1, perPage = 9) {
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", {
+      _embed: true,
+      per_page: perPage,
+      page,
+      author: authorId
+    });
+  }
+  async function getAllPostSlugs() {
+    try {
+      const allSlugs = [];
+      let page = 1;
+      let hasMore = true;
+      while (hasMore) {
+        const response = await wpFetchPaginated(
+          "/wp-json/wp/v2/posts",
+          { per_page: 100, page, _fields: "slug" }
+        );
+        allSlugs.push(...response.data.map((post) => ({ slug: post.slug })));
+        hasMore = page < response.headers.totalPages;
+        page++;
+      }
+      return allSlugs;
+    } catch {
+      console.warn("WordPress unavailable, skipping static generation for posts");
+      return [];
+    }
+  }
+  async function getAllPostsForSitemap() {
+    try {
+      const allPosts = [];
+      let page = 1;
+      let hasMore = true;
+      while (hasMore) {
+        const response = await wpFetchPaginated(
+          "/wp-json/wp/v2/posts",
+          { per_page: 100, page, _fields: "slug,modified" }
+        );
+        allPosts.push(...response.data.map((post) => ({ slug: post.slug, modified: post.modified })));
+        hasMore = page < response.headers.totalPages;
+        page++;
+      }
+      return allPosts;
+    } catch {
+      console.warn("WordPress unavailable, skipping sitemap generation");
+      return [];
+    }
+  }
+  return {
+    getPostsPaginated,
+    getRecentPosts,
+    getPostById,
+    getPostBySlug,
+    getPostsByCategory,
+    getPostsByTag,
+    getPostsByAuthor,
+    getPostsByCategoryPaginated,
+    getPostsByTagPaginated,
+    getPostsByAuthorPaginated,
+    getAllPostSlugs,
+    getAllPostsForSitemap
+  };
+}
+
+// src/hooks/usePosts.ts
+function usePosts(config, filter, swrOptions) {
+  const key = ["wp-posts", config.clientURL, JSON.stringify(filter ?? null)];
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createFetcher(config);
+      return createPostsQueries(fetcher).getRecentPosts(filter);
+    },
+    swrOptions
+  );
+}
+function usePost(config, id, swrOptions) {
+  const key = id != null ? ["wp-post", config.clientURL, id] : null;
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createFetcher(config);
+      return createPostsQueries(fetcher).getPostById(id);
+    },
+    swrOptions
+  );
+}
+function usePostBySlug(config, slug, swrOptions) {
+  const key = slug ? ["wp-post-slug", config.clientURL, slug] : null;
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createFetcher(config);
+      return createPostsQueries(fetcher).getPostBySlug(slug);
+    },
+    swrOptions
+  );
+}
+function usePostsPaginated(config, page = 1, perPage = 9, filter, swrOptions) {
+  const key = ["wp-posts-paginated", config.clientURL, page, perPage, JSON.stringify(filter ?? null)];
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createFetcher(config);
+      return createPostsQueries(fetcher).getPostsPaginated(page, perPage, filter);
+    },
+    swrOptions
+  );
+}
+
+// src/integrations/restApi/woocommerce/client/fetcher.ts
+var USER_AGENT2 = "NextWordpress WooCommerce Client";
+var DEFAULT_CACHE_TTL = 3600;
+function toQueryString(params) {
+  const pairs = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }
+  return pairs.join("&");
+}
+function createWooCommerceFetcher(config) {
+  const cacheTTL = config.cacheTTL ?? DEFAULT_CACHE_TTL;
+  function withAuth(query) {
+    return { ...query, consumer_key: config.consumerKey, consumer_secret: config.consumerSecret };
+  }
+  function buildUrl2(path, query) {
+    return `${config.serverURL}${path}?${toQueryString(withAuth(query))}`;
+  }
+  async function wcFetch(path, query, tags = ["woocommerce"], options) {
+    const url = buildUrl2(path, query);
+    const isMutation = options?.method && options.method !== "GET";
+    const noStore = options?.cache === "no-store";
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "User-Agent": USER_AGENT2,
+        "Content-Type": "application/json",
+        ...options?.headers
+      },
+      next: isMutation || noStore ? void 0 : { tags, revalidate: cacheTTL }
+    });
+    if (!response.ok) {
+      const body = await response.json().catch(() => ({}));
+      const detail = body.message ? ` \u2013 ${body.message}` : "";
+      throw new Error(`WooCommerce API ${response.status}: ${response.statusText}${detail} [${url}]`);
+    }
+    return response.json();
+  }
+  async function wcFetchGraceful(path, fallback, query, tags = ["woocommerce"]) {
+    try {
+      return await wcFetch(path, query, tags);
+    } catch (err) {
+      console.warn(`WooCommerce fetch failed for ${path}`, err);
+      return fallback;
+    }
+  }
+  async function wcFetchPaginated(path, query, tags = ["woocommerce"]) {
+    const url = buildUrl2(path, query);
+    const response = await fetch(url, {
+      headers: { "User-Agent": USER_AGENT2 },
+      next: { tags, revalidate: cacheTTL }
+    });
+    if (!response.ok) {
+      throw new Error(`WooCommerce API ${response.status}: ${response.statusText} [${url}]`);
+    }
+    return {
+      data: await response.json(),
+      headers: {
+        total: parseInt(response.headers.get("X-WP-Total") ?? "0", 10),
+        totalPages: parseInt(response.headers.get("X-WP-TotalPages") ?? "0", 10)
+      }
+    };
+  }
+  async function wcFetchPaginatedGraceful(path, query, tags = ["woocommerce"]) {
+    const empty = { data: [], headers: { total: 0, totalPages: 0 } };
+    try {
+      return await wcFetchPaginated(path, query, tags);
+    } catch (err) {
+      console.warn(`WooCommerce paginated fetch failed for ${path}`, err);
+      return empty;
+    }
+  }
+  async function wcMutate(path, body, method = "POST") {
+    return wcFetch(path, void 0, ["woocommerce"], {
+      method,
+      body: JSON.stringify(body)
+    });
+  }
+  return { wcFetch, wcFetchGraceful, wcFetchPaginated, wcFetchPaginatedGraceful, wcMutate };
+}
+
+// src/integrations/restApi/woocommerce/products/queries.ts
+function buildProductQuery(base, filterParams) {
+  const query = { ...base };
+  if (!filterParams) return query;
+  if (filterParams.category !== void 0) query.category = filterParams.category;
+  if (filterParams.tag !== void 0) query.tag = filterParams.tag;
+  if (filterParams.featured !== void 0) query.featured = filterParams.featured;
+  if (filterParams.on_sale !== void 0) query.on_sale = filterParams.on_sale;
+  if (filterParams.min_price !== void 0) query.min_price = filterParams.min_price;
+  if (filterParams.max_price !== void 0) query.max_price = filterParams.max_price;
+  if (filterParams.search !== void 0) query.search = filterParams.search;
+  if (filterParams.orderby !== void 0) query.orderby = filterParams.orderby;
+  if (filterParams.order !== void 0) query.order = filterParams.order;
+  if (filterParams.stock_status !== void 0) query.stock_status = filterParams.stock_status;
+  if (filterParams.type !== void 0) query.type = filterParams.type;
+  return query;
+}
+function createProductsQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcFetchPaginated, wcFetchPaginatedGraceful } = fetcher;
+  async function getProducts(filterParams) {
+    const query = buildProductQuery({ per_page: 100, status: "publish" }, filterParams);
+    return wcFetchGraceful("/wp-json/wc/v3/products", [], query, [
+      "woocommerce",
+      "products"
+    ]);
+  }
+  async function getProductsPaginated(page = 1, perPage = 12, filterParams) {
+    const query = buildProductQuery({ per_page: perPage, page, status: "publish" }, filterParams);
+    const cacheTags = ["woocommerce", "products", `products-page-${page}`];
+    if (filterParams?.category) cacheTags.push(`products-category-${filterParams.category}`);
+    if (filterParams?.tag) cacheTags.push(`products-tag-${filterParams.tag}`);
+    if (filterParams?.search) cacheTags.push("products-search");
+    return wcFetchPaginatedGraceful("/wp-json/wc/v3/products", query, cacheTags);
+  }
+  async function getProductById(id) {
+    return wcFetch(`/wp-json/wc/v3/products/${id}`, void 0, [
+      "woocommerce",
+      "products",
+      `product-${id}`
+    ]);
+  }
+  async function getProductBySlug(slug) {
+    const products = await wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { slug },
+      ["woocommerce", "products", `product-slug-${slug}`]
+    );
+    return products[0];
+  }
+  async function getFeaturedProducts(limit = 10) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { featured: true, per_page: limit, status: "publish" },
+      ["woocommerce", "products", "featured"]
+    );
+  }
+  async function getOnSaleProducts(limit = 10) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { on_sale: true, per_page: limit, status: "publish" },
+      ["woocommerce", "products", "on-sale"]
+    );
+  }
+  async function getRelatedProducts(productId) {
+    const product = await getProductById(productId);
+    if (!product.related_ids.length) return [];
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { include: product.related_ids.join(","), per_page: 10, status: "publish" },
+      ["woocommerce", "products", `related-${productId}`]
+    );
+  }
+  async function getAllProductSlugs() {
+    try {
+      const allSlugs = [];
+      let page = 1;
+      let hasMore = true;
+      while (hasMore) {
+        const response = await wcFetchPaginated("/wp-json/wc/v3/products", {
+          per_page: 100,
+          page,
+          status: "publish",
+          _fields: "slug"
+        });
+        allSlugs.push(...response.data.map((p) => ({ slug: p.slug })));
+        hasMore = page < response.headers.totalPages;
+        page++;
+      }
+      return allSlugs;
+    } catch {
+      console.warn("WooCommerce unavailable, skipping static generation for products");
+      return [];
+    }
+  }
+  async function getProductVariations(productId) {
+    return wcFetchGraceful(
+      `/wp-json/wc/v3/products/${productId}/variations`,
+      [],
+      { per_page: 100 },
+      ["woocommerce", "products", `product-${productId}`, "variations"]
+    );
+  }
+  async function getProductVariationById(productId, variationId) {
+    return wcFetch(
+      `/wp-json/wc/v3/products/${productId}/variations/${variationId}`,
+      void 0,
+      ["woocommerce", "products", `product-${productId}`, `variation-${variationId}`]
+    );
+  }
+  return {
+    getProducts,
+    getProductsPaginated,
+    getProductById,
+    getProductBySlug,
+    getFeaturedProducts,
+    getOnSaleProducts,
+    getRelatedProducts,
+    getAllProductSlugs,
+    getProductVariations,
+    getProductVariationById
+  };
+}
+
+// src/hooks/useProducts.ts
+function useProducts(config, filter, swrOptions) {
+  const key = ["wc-products", config.serverURL, JSON.stringify(filter ?? null)];
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createWooCommerceFetcher(config);
+      return createProductsQueries(fetcher).getProducts(filter);
+    },
+    swrOptions
+  );
+}
+function useProduct(config, id, swrOptions) {
+  const key = id != null ? ["wc-product", config.serverURL, id] : null;
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createWooCommerceFetcher(config);
+      return createProductsQueries(fetcher).getProductById(id);
+    },
+    swrOptions
+  );
+}
+function useProductBySlug(config, slug, swrOptions) {
+  const key = slug ? ["wc-product-slug", config.serverURL, slug] : null;
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createWooCommerceFetcher(config);
+      return createProductsQueries(fetcher).getProductBySlug(slug);
+    },
+    swrOptions
+  );
+}
+function useProductsPaginated(config, page = 1, perPage = 12, filter, swrOptions) {
+  const key = ["wc-products-paginated", config.serverURL, page, perPage, JSON.stringify(filter ?? null)];
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createWooCommerceFetcher(config);
+      return createProductsQueries(fetcher).getProductsPaginated(page, perPage, filter);
+    },
+    swrOptions
+  );
+}
+function useFeaturedProducts(config, limit = 10, swrOptions) {
+  const key = ["wc-products-featured", config.serverURL, limit];
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createWooCommerceFetcher(config);
+      return createProductsQueries(fetcher).getFeaturedProducts(limit);
+    },
+    swrOptions
+  );
+}
+
+// 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;
+    }
+  }
+  async function gqlMutate(document, variables, authToken) {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT3
+    };
+    if (authToken) {
+      headers["Authorization"] = authToken;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query: document, variables }),
+      cache: "no-store"
+    });
+    if (!response.ok) {
+      throw new WPGraphQLError(
+        `WPGraphQL mutation 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 mutation", 200, url);
+    }
+    return parsed.data;
+  }
+  return { gqlFetch, gqlFetchGraceful, gqlMutate };
+}
+
+// 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/hooks/useWPGraphQL.ts
+function useWPGraphQL(config, query, variables, tags, swrOptions) {
+  const key = ["wpgraphql", config.clientURL, query, JSON.stringify(variables ?? null)];
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createWPGraphQLFetcher(config);
+      return fetcher.gqlFetch(query, variables, tags);
+    },
+    swrOptions
+  );
+}
+function useGQLPosts(config, first, after, filter, swrOptions) {
+  const key = ["wpgraphql-posts", config.clientURL, first, after, JSON.stringify(filter ?? null)];
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createWPGraphQLFetcher(config);
+      return createPostsQueries2(fetcher).getPosts(first, after, filter);
+    },
+    swrOptions
+  );
+}
+function useGQLPostBySlug(config, slug, swrOptions) {
+  const key = slug ? ["wpgraphql-post-slug", config.clientURL, slug] : null;
+  return useSWR2(
+    key,
+    () => {
+      const fetcher = createWPGraphQLFetcher(config);
+      return createPostsQueries2(fetcher).getPostBySlug(slug);
+    },
+    swrOptions
+  );
+}
+
+export { useFeaturedProducts, useGQLPostBySlug, useGQLPosts, usePost, usePostBySlug, usePosts, usePostsPaginated, useProduct, useProductBySlug, useProducts, useProductsPaginated, useWPGraphQL };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map