@szymonpiatek/nextwordpress 0.0.10 → 0.0.11

package/dist/client/index.cjs

@@ -0,0 +1,1372 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var useSWR2 = require('swr');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var useSWR2__default = /*#__PURE__*/_interopDefault(useSWR2);
+
+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/shared/url.ts
+function resolveBaseUrl(config) {
+  return typeof window === "undefined" ? config.serverURL : config.clientURL;
+}
+
+// src/shared/errors/codes.ts
+var ErrorCode = {
+  // WordPress REST API
+  WP_REQUEST_FAILED: "WP_REQUEST_FAILED",
+  WP_NOT_FOUND: "WP_NOT_FOUND",
+  WP_UNAUTHORIZED: "WP_UNAUTHORIZED",
+  WP_FORBIDDEN: "WP_FORBIDDEN",
+  // WPGraphQL
+  GQL_REQUEST_FAILED: "GQL_REQUEST_FAILED",
+  GQL_NO_DATA: "GQL_NO_DATA",
+  GQL_ERRORS_IN_RESPONSE: "GQL_ERRORS_IN_RESPONSE",
+  // WooCommerce — generic
+  WOO_REQUEST_FAILED: "WOO_REQUEST_FAILED",
+  WOO_NOT_FOUND: "WOO_NOT_FOUND",
+  WOO_UNAUTHORIZED: "WOO_UNAUTHORIZED",
+  WOO_FORBIDDEN: "WOO_FORBIDDEN",
+  // WooCommerce — resource-specific
+  WOO_COUPON_NOT_FOUND: "WOO_COUPON_NOT_FOUND",
+  WOO_PRODUCT_NOT_FOUND: "WOO_PRODUCT_NOT_FOUND",
+  WOO_ORDER_NOT_FOUND: "WOO_ORDER_NOT_FOUND",
+  WOO_CUSTOMER_NOT_FOUND: "WOO_CUSTOMER_NOT_FOUND",
+  WOO_CATEGORY_NOT_FOUND: "WOO_CATEGORY_NOT_FOUND",
+  WOO_REVIEW_NOT_FOUND: "WOO_REVIEW_NOT_FOUND",
+  WOO_WEBHOOK_NOT_FOUND: "WOO_WEBHOOK_NOT_FOUND",
+  WOO_SHIPPING_ZONE_NOT_FOUND: "WOO_SHIPPING_ZONE_NOT_FOUND",
+  // Auth
+  AUTH_JWT_FAILED: "AUTH_JWT_FAILED",
+  AUTH_CREDENTIALS_INVALID: "AUTH_CREDENTIALS_INVALID",
+  AUTH_TOKEN_INVALID: "AUTH_TOKEN_INVALID"
+};
+var defaultMessages = {
+  WP_REQUEST_FAILED: "WordPress API request failed",
+  WP_NOT_FOUND: "WordPress resource not found",
+  WP_UNAUTHORIZED: "WordPress authentication required",
+  WP_FORBIDDEN: "WordPress access denied",
+  GQL_REQUEST_FAILED: "WPGraphQL request failed",
+  GQL_NO_DATA: "No data returned from WPGraphQL",
+  GQL_ERRORS_IN_RESPONSE: "WPGraphQL returned errors",
+  WOO_REQUEST_FAILED: "WooCommerce API request failed",
+  WOO_NOT_FOUND: "WooCommerce resource not found",
+  WOO_UNAUTHORIZED: "WooCommerce authentication required",
+  WOO_FORBIDDEN: "WooCommerce access denied",
+  WOO_COUPON_NOT_FOUND: "Coupon not found",
+  WOO_PRODUCT_NOT_FOUND: "Product not found",
+  WOO_ORDER_NOT_FOUND: "Order not found",
+  WOO_CUSTOMER_NOT_FOUND: "Customer not found",
+  WOO_CATEGORY_NOT_FOUND: "Category not found",
+  WOO_TAG_NOT_FOUND: "Tag not found",
+  WOO_REVIEW_NOT_FOUND: "Product review not found",
+  WOO_WEBHOOK_NOT_FOUND: "Webhook not found",
+  WOO_SHIPPING_ZONE_NOT_FOUND: "Shipping zone not found",
+  AUTH_JWT_FAILED: "JWT authentication failed",
+  AUTH_CREDENTIALS_INVALID: "Invalid credentials",
+  AUTH_TOKEN_INVALID: "JWT token is invalid or expired"
+};
+function resolveMessage(code, overrides) {
+  return overrides?.[code] ?? defaultMessages[code];
+}
+
+// src/auth/types.ts
+var AuthenticationError = class extends Error {
+  constructor(code, status, message, detail) {
+    super(detail ? `${message}: ${detail}` : message);
+    __publicField(this, "code", code);
+    __publicField(this, "status", status);
+    this.name = "AuthenticationError";
+  }
+};
+
+// src/auth/jwt.ts
+function resolveAuthErrorCode(status) {
+  if (status === 401) return ErrorCode.AUTH_CREDENTIALS_INVALID;
+  if (status === 403) return ErrorCode.AUTH_TOKEN_INVALID;
+  return ErrorCode.AUTH_JWT_FAILED;
+}
+async function authenticateJwt(config, credentials) {
+  const url = `${resolveBaseUrl(config)}/wp-json/jwt-auth/v1/token`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(credentials),
+    cache: "no-store"
+  });
+  if (!response.ok) {
+    const code = resolveAuthErrorCode(response.status);
+    throw new AuthenticationError(
+      code,
+      response.status,
+      resolveMessage(code, config.errorMessages),
+      response.statusText
+    );
+  }
+  return response.json();
+}
+async function validateJwtToken(config, token) {
+  const url = `${resolveBaseUrl(config)}/wp-json/jwt-auth/v1/token/validate`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}` },
+    cache: "no-store"
+  });
+  return response.ok;
+}
+var AuthContext = react.createContext(null);
+var TOKEN_KEY = "nw_auth_token";
+var USER_KEY = "nw_auth_user";
+function AuthProvider({
+  config,
+  children
+}) {
+  const [user, setUser] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const clearStorage = react.useCallback(() => {
+    localStorage.removeItem(TOKEN_KEY);
+    localStorage.removeItem(USER_KEY);
+  }, []);
+  react.useEffect(() => {
+    const token = localStorage.getItem(TOKEN_KEY);
+    const storedUser = localStorage.getItem(USER_KEY);
+    if (!token || !storedUser) {
+      setIsLoading(false);
+      return;
+    }
+    validateJwtToken(config, token).then((valid) => {
+      if (valid) {
+        setUser(JSON.parse(storedUser));
+      } else {
+        clearStorage();
+      }
+    }).catch(() => clearStorage()).finally(() => setIsLoading(false));
+  }, []);
+  const login = async (credentials) => {
+    setError(null);
+    setIsLoading(true);
+    try {
+      const response = await authenticateJwt(config, credentials);
+      const authUser = {
+        token: response.token,
+        email: response.user_email,
+        nicename: response.user_nicename,
+        displayName: response.user_display_name
+      };
+      localStorage.setItem(TOKEN_KEY, response.token);
+      localStorage.setItem(USER_KEY, JSON.stringify(authUser));
+      setUser(authUser);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Authentication failed";
+      setError(message);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const logout = () => {
+    clearStorage();
+    setUser(null);
+    setError(null);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(AuthContext.Provider, { value: { user, isLoggedIn: !!user, isLoading, error, login, logout }, children });
+}
+function useAuth() {
+  const ctx = react.useContext(AuthContext);
+  if (!ctx) throw new Error("useAuth must be used within an AuthProvider");
+  return ctx;
+}
+
+// src/integrations/restApi/core/client/types.ts
+var WordPressAPIError = class extends Error {
+  constructor(code, status, endpoint, message, detail) {
+    super(detail ? `${message}: ${detail}` : message);
+    __publicField(this, "code", code);
+    __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}`;
+  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";
+function resolveWpErrorCode(status) {
+  if (status === 401) return ErrorCode.WP_UNAUTHORIZED;
+  if (status === 403) return ErrorCode.WP_FORBIDDEN;
+  if (status === 404) return ErrorCode.WP_NOT_FOUND;
+  return ErrorCode.WP_REQUEST_FAILED;
+}
+function createFetcher(config) {
+  const cacheTtl = config.cacheTTL ?? 300;
+  async function doFetch(url, init = {}) {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const code = resolveWpErrorCode(response.status);
+      throw new WordPressAPIError(
+        code,
+        response.status,
+        url,
+        resolveMessage(code, config.errorMessages),
+        response.statusText
+      );
+    }
+    return response;
+  }
+  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.startsWith("Basic ") || authToken.startsWith("Bearer ") ? authToken : `Bearer ${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.startsWith("Basic ") || authToken.startsWith("Bearer ") ? authToken : `Bearer ${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/core/usePosts.ts
+function usePosts(config, filter, swrOptions) {
+  const key = ["wp-posts", config.clientURL, JSON.stringify(filter ?? null)];
+  return useSWR2__default.default(
+    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__default.default(
+    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__default.default(
+    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__default.default(
+    key,
+    () => {
+      const fetcher = createFetcher(config);
+      return createPostsQueries(fetcher).getPostsPaginated(page, perPage, filter);
+    },
+    swrOptions
+  );
+}
+
+// src/integrations/restApi/woocommerce/client/types.ts
+var WooCommerceError = class extends Error {
+  constructor(code, status, endpoint, message, upstreamCode, detail) {
+    super(detail ? `${message}: ${detail}` : message);
+    __publicField(this, "code", code);
+    __publicField(this, "status", status);
+    __publicField(this, "endpoint", endpoint);
+    __publicField(this, "upstreamCode", upstreamCode);
+    this.name = "WooCommerceError";
+  }
+};
+
+// src/integrations/restApi/woocommerce/client/errorMap.ts
+var upstreamToErrorCode = {
+  woocommerce_rest_coupon_invalid_id: ErrorCode.WOO_COUPON_NOT_FOUND,
+  woocommerce_rest_product_invalid_id: ErrorCode.WOO_PRODUCT_NOT_FOUND,
+  woocommerce_rest_order_invalid_id: ErrorCode.WOO_ORDER_NOT_FOUND,
+  woocommerce_rest_customer_invalid_id: ErrorCode.WOO_CUSTOMER_NOT_FOUND,
+  woocommerce_rest_term_invalid: ErrorCode.WOO_CATEGORY_NOT_FOUND,
+  woocommerce_rest_review_invalid_id: ErrorCode.WOO_REVIEW_NOT_FOUND,
+  woocommerce_rest_webhook_invalid_id: ErrorCode.WOO_WEBHOOK_NOT_FOUND,
+  woocommerce_rest_shipping_zone_invalid_id: ErrorCode.WOO_SHIPPING_ZONE_NOT_FOUND
+};
+function resolveWooErrorCode(status, upstreamCode) {
+  if (status === 401) return ErrorCode.WOO_UNAUTHORIZED;
+  if (status === 403) return ErrorCode.WOO_FORBIDDEN;
+  if (status === 404) {
+    if (upstreamCode) {
+      const mapped = upstreamToErrorCode[upstreamCode];
+      if (mapped) return mapped;
+    }
+    return ErrorCode.WOO_NOT_FOUND;
+  }
+  return ErrorCode.WOO_REQUEST_FAILED;
+}
+
+// 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) {
+    const base = typeof window !== "undefined" && config.clientURL ? config.clientURL : config.serverURL;
+    return `${base}${path}?${toQueryString(withAuth(query))}`;
+  }
+  async function throwWooError(response, url) {
+    const body = await response.json().catch(() => ({}));
+    const errorCode = resolveWooErrorCode(response.status, body.code);
+    throw new WooCommerceError(
+      errorCode,
+      response.status,
+      url,
+      resolveMessage(errorCode, config.errorMessages),
+      body.code,
+      body.message
+    );
+  }
+  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) {
+      await throwWooError(response, 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) {
+      await throwWooError(response, 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/woocommerce/useProducts.ts
+function useProducts(config, filter, swrOptions) {
+  const key = ["wc-products", config.serverURL, JSON.stringify(filter ?? null)];
+  return useSWR2__default.default(
+    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__default.default(
+    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__default.default(
+    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__default.default(
+    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__default.default(
+    key,
+    () => {
+      const fetcher = createWooCommerceFetcher(config);
+      return createProductsQueries(fetcher).getFeaturedProducts(limit);
+    },
+    swrOptions
+  );
+}
+
+// src/integrations/restApi/woocommerce/orders/queries.ts
+function createOrdersQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function createOrder(input) {
+    return wcMutate("/wp-json/wc/v3/orders", input, "POST");
+  }
+  async function getOrderById(id) {
+    return wcFetch(`/wp-json/wc/v3/orders/${id}`, void 0, [
+      "woocommerce",
+      "orders",
+      `order-${id}`
+    ]);
+  }
+  async function updateOrder(id, data) {
+    return wcMutate(`/wp-json/wc/v3/orders/${id}`, data, "PUT");
+  }
+  async function getOrdersByCustomer(customerId) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/orders",
+      [],
+      { customer: customerId, per_page: 100 },
+      ["woocommerce", "orders", `orders-customer-${customerId}`]
+    );
+  }
+  async function deleteOrder(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/orders/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return {
+    createOrder,
+    getOrderById,
+    updateOrder,
+    getOrdersByCustomer,
+    deleteOrder
+  };
+}
+var STORAGE_KEY = "nw-cart";
+function isSame(a, b) {
+  return a.productId === b.productId && (a.variationId ?? 0) === (b.variationId ?? 0);
+}
+function cartReducer(state, action) {
+  switch (action.type) {
+    case "LOAD":
+      return { items: action.items };
+    case "ADD": {
+      const existing = state.items.find((i) => isSame(i, action.item));
+      if (existing) {
+        return {
+          items: state.items.map(
+            (i) => isSame(i, action.item) ? { ...i, quantity: i.quantity + action.item.quantity } : i
+          )
+        };
+      }
+      return { items: [...state.items, action.item] };
+    }
+    case "REMOVE":
+      return { items: state.items.filter((i) => !isSame(i, action)) };
+    case "UPDATE":
+      if (action.quantity <= 0) {
+        return { items: state.items.filter((i) => !isSame(i, action)) };
+      }
+      return {
+        items: state.items.map(
+          (i) => isSame(i, action) ? { ...i, quantity: action.quantity } : i
+        )
+      };
+    case "CLEAR":
+      return { items: [] };
+  }
+}
+var CartContext = react.createContext(null);
+function CartProvider({ children }) {
+  const [state, dispatch] = react.useReducer(cartReducer, { items: [] });
+  react.useEffect(() => {
+    try {
+      const stored = localStorage.getItem(STORAGE_KEY);
+      if (stored) dispatch({ type: "LOAD", items: JSON.parse(stored) });
+    } catch {
+    }
+  }, []);
+  react.useEffect(() => {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(state.items));
+    } catch {
+    }
+  }, [state.items]);
+  const totalItems = state.items.reduce((sum, i) => sum + i.quantity, 0);
+  const subtotal = state.items.reduce((sum, i) => sum + parseFloat(i.price) * i.quantity, 0).toFixed(2);
+  function addItem(item, quantity = 1) {
+    dispatch({ type: "ADD", item: { ...item, quantity } });
+  }
+  function removeItem(productId, variationId) {
+    dispatch({ type: "REMOVE", productId, variationId });
+  }
+  function updateQuantity(productId, quantity, variationId) {
+    dispatch({ type: "UPDATE", productId, quantity, variationId });
+  }
+  function clearCart() {
+    dispatch({ type: "CLEAR" });
+  }
+  async function checkout(config, options = {}) {
+    if (state.items.length === 0) throw new Error("Cannot checkout with an empty cart");
+    const fetcher = createWooCommerceFetcher(config);
+    const input = {
+      status: "pending",
+      line_items: state.items.map((i) => ({
+        product_id: i.productId,
+        ...i.variationId !== void 0 ? { variation_id: i.variationId } : {},
+        quantity: i.quantity
+      })),
+      ...options.billing ? { billing: options.billing } : {},
+      ...options.shipping ? { shipping: options.shipping } : {},
+      ...options.paymentMethod ? { payment_method: options.paymentMethod } : {},
+      ...options.paymentMethodTitle ? { payment_method_title: options.paymentMethodTitle } : {},
+      ...options.customerNote ? { customer_note: options.customerNote } : {},
+      ...options.couponCodes ? { coupon_lines: options.couponCodes.map((code) => ({ code })) } : {}
+    };
+    const order = await createOrdersQueries(fetcher).createOrder(input);
+    dispatch({ type: "CLEAR" });
+    return order;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    CartContext.Provider,
+    {
+      value: { items: state.items, totalItems, subtotal, isEmpty: state.items.length === 0, addItem, removeItem, updateQuantity, clearCart, checkout },
+      children
+    }
+  );
+}
+function useCart() {
+  const ctx = react.useContext(CartContext);
+  if (!ctx) throw new Error("useCart must be used within a CartProvider");
+  return ctx;
+}
+
+// src/integrations/restApi/woocommerce/customers/queries.ts
+function createCustomersQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getCustomerById(id) {
+    return wcFetch(`/wp-json/wc/v3/customers/${id}`, void 0, [
+      "woocommerce",
+      "customers",
+      `customer-${id}`
+    ]);
+  }
+  async function getCustomerByEmail(email) {
+    const customers = await wcFetchGraceful(
+      "/wp-json/wc/v3/customers",
+      [],
+      { email },
+      ["woocommerce", "customers"]
+    );
+    return customers[0];
+  }
+  async function getCustomerByEmailNoCache(email) {
+    try {
+      const customers = await wcFetch(
+        "/wp-json/wc/v3/customers",
+        { email },
+        ["woocommerce", "customers"],
+        { cache: "no-store" }
+      );
+      return customers[0];
+    } catch {
+      return void 0;
+    }
+  }
+  async function createCustomer(data) {
+    return wcFetch(
+      "/wp-json/wc/v3/customers",
+      void 0,
+      ["woocommerce", "customers"],
+      { method: "POST", body: JSON.stringify(data) }
+    );
+  }
+  async function updateCustomer(id, data) {
+    return wcMutate(`/wp-json/wc/v3/customers/${id}`, data, "PUT");
+  }
+  async function deleteCustomer(id, reassign) {
+    return wcMutate(
+      `/wp-json/wc/v3/customers/${id}`,
+      { force: true, ...reassign !== void 0 && { reassign } },
+      "DELETE"
+    );
+  }
+  return {
+    getCustomerById,
+    getCustomerByEmail,
+    getCustomerByEmailNoCache,
+    createCustomer,
+    updateCustomer,
+    deleteCustomer
+  };
+}
+var CustomerContext = react.createContext(null);
+function WooCommerceCustomerProvider({
+  config,
+  children
+}) {
+  const { user, isLoggedIn } = useAuth();
+  const [customer, setCustomer] = react.useState(null);
+  const [orders, setOrders] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [tick, setTick] = react.useState(0);
+  const fetchData = react.useCallback(async () => {
+    if (!isLoggedIn || !user?.email) {
+      setCustomer(null);
+      setOrders([]);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const fetcher = createWooCommerceFetcher(config);
+      const foundCustomer = await createCustomersQueries(fetcher).getCustomerByEmailNoCache(user.email);
+      if (!foundCustomer) {
+        setCustomer(null);
+        setOrders([]);
+        return;
+      }
+      const customerOrders = await createOrdersQueries(fetcher).getOrdersByCustomer(foundCustomer.id);
+      setCustomer(foundCustomer);
+      setOrders(customerOrders);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load customer data");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [isLoggedIn, user?.email, config, tick]);
+  react.useEffect(() => {
+    void fetchData();
+  }, [fetchData]);
+  const updateCustomer = async (data) => {
+    if (!customer) throw new Error("No customer loaded");
+    const fetcher = createWooCommerceFetcher(config);
+    const updated = await createCustomersQueries(fetcher).updateCustomer(customer.id, data);
+    setCustomer(updated);
+    return updated;
+  };
+  const refetch = () => setTick((t) => t + 1);
+  return /* @__PURE__ */ jsxRuntime.jsx(CustomerContext.Provider, { value: { customer, orders, isLoading, error, updateCustomer, refetch }, children });
+}
+function useCustomer() {
+  const ctx = react.useContext(CustomerContext);
+  if (!ctx) throw new Error("useCustomer must be used within a WooCommerceCustomerProvider");
+  return ctx;
+}
+
+// src/integrations/wpGraphQL/client/types.ts
+var WPGraphQLError = class extends Error {
+  constructor(code, status, endpoint, message, gqlErrors) {
+    super(message);
+    __publicField(this, "code", code);
+    __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";
+function createWPGraphQLFetcher(config) {
+  const url = `${resolveBaseUrl(config)}/graphql`;
+  const cacheTTL = config.cacheTTL ?? 300;
+  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: cacheTTL }
+    });
+    if (!response.ok) {
+      throw new WPGraphQLError(
+        ErrorCode.GQL_REQUEST_FAILED,
+        response.status,
+        url,
+        resolveMessage(ErrorCode.GQL_REQUEST_FAILED, config.errorMessages)
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.errors && parsed.errors.length > 0) {
+      throw new WPGraphQLError(
+        ErrorCode.GQL_ERRORS_IN_RESPONSE,
+        200,
+        url,
+        resolveMessage(ErrorCode.GQL_ERRORS_IN_RESPONSE, config.errorMessages),
+        parsed.errors
+      );
+    }
+    if (parsed.data === void 0) {
+      throw new WPGraphQLError(
+        ErrorCode.GQL_NO_DATA,
+        200,
+        url,
+        resolveMessage(ErrorCode.GQL_NO_DATA, config.errorMessages)
+      );
+    }
+    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(
+        ErrorCode.GQL_REQUEST_FAILED,
+        response.status,
+        url,
+        resolveMessage(ErrorCode.GQL_REQUEST_FAILED, config.errorMessages)
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.errors && parsed.errors.length > 0) {
+      throw new WPGraphQLError(
+        ErrorCode.GQL_ERRORS_IN_RESPONSE,
+        200,
+        url,
+        resolveMessage(ErrorCode.GQL_ERRORS_IN_RESPONSE, config.errorMessages),
+        parsed.errors
+      );
+    }
+    if (parsed.data === void 0) {
+      throw new WPGraphQLError(
+        ErrorCode.GQL_NO_DATA,
+        200,
+        url,
+        resolveMessage(ErrorCode.GQL_NO_DATA, config.errorMessages)
+      );
+    }
+    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/wpgraphql/useWPGraphQL.ts
+function useWPGraphQL(config, query, variables, tags, swrOptions) {
+  const key = ["wpgraphql", config.clientURL, query, JSON.stringify(variables ?? null)];
+  return useSWR2__default.default(
+    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__default.default(
+    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__default.default(
+    key,
+    () => {
+      const fetcher = createWPGraphQLFetcher(config);
+      return createPostsQueries2(fetcher).getPostBySlug(slug);
+    },
+    swrOptions
+  );
+}
+
+exports.AuthProvider = AuthProvider;
+exports.CartProvider = CartProvider;
+exports.WooCommerceCustomerProvider = WooCommerceCustomerProvider;
+exports.cartReducer = cartReducer;
+exports.useAuth = useAuth;
+exports.useCart = useCart;
+exports.useCustomer = useCustomer;
+exports.useFeaturedProducts = useFeaturedProducts;
+exports.useGQLPostBySlug = useGQLPostBySlug;
+exports.useGQLPosts = useGQLPosts;
+exports.usePost = usePost;
+exports.usePostBySlug = usePostBySlug;
+exports.usePosts = usePosts;
+exports.usePostsPaginated = usePostsPaginated;
+exports.useProduct = useProduct;
+exports.useProductBySlug = useProductBySlug;
+exports.useProducts = useProducts;
+exports.useProductsPaginated = useProductsPaginated;
+exports.useWPGraphQL = useWPGraphQL;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map