@rebuy/hydrogen-sdk/dist/index.js

The React/Hydrogen wrapper for the Rebuy Core SDK.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  RebuyContext: () => RebuyContext,
  RebuyContextBuilder: () => import_core_sdk3.RebuyContextBuilder,
  RebuyProductView: () => RebuyProductView,
  RebuyProvider: () => RebuyProvider,
  RecentlyViewed: () => RecentlyViewed,
  getRebuyData: () => getRebuyData,
  useRebuy: () => useRebuy
});
module.exports = __toCommonJS(src_exports);

// src/context.tsx
var import_core_sdk = require("@rebuy/core-sdk");
var import_react = require("react");
var import_jsx_runtime = require("react/jsx-runtime");
var RebuyContext = (0, import_react.createContext)(null);
var RebuyProvider = ({
  apiHost,
  apiKey,
  children,
  nonce
}) => {
  const sdk = (0, import_react.useMemo)(() => new import_core_sdk.RebuySDK({ apiHost, apiKey }), [apiKey, apiHost]);
  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RebuyContext.Provider, { value: sdk, children });
};
var useRebuy = () => {
  const context = (0, import_react.useContext)(RebuyContext);
  if (!context) {
    throw new Error("useRebuy must be used within a RebuyProvider");
  }
  return context;
};

// src/components/RecentlyViewed.tsx
var import_react2 = require("react");
var import_jsx_runtime2 = require("react/jsx-runtime");
var RecentlyViewed = ({
  className,
  emptyComponent,
  limit = 5,
  loadingComponent,
  onError
}) => {
  const [products, setProducts] = (0, import_react2.useState)([]);
  const [loading, setLoading] = (0, import_react2.useState)(true);
  const [error, setError] = (0, import_react2.useState)(null);
  const rebuy = useRebuy();
  (0, import_react2.useEffect)(() => {
    const fetchRecentlyViewed = async () => {
      try {
        setLoading(true);
        setError(null);
        const data = await rebuy.products.getRecentlyViewed({ limit });
        setProducts(data || []);
      } catch (err) {
        const error2 = err instanceof Error ? err : new Error(String(err));
        setError(error2);
        onError?.(error2);
        console.error("Failed to fetch recently viewed products:", error2);
      } finally {
        setLoading(false);
      }
    };
    fetchRecentlyViewed();
  }, [limit, rebuy, onError]);
  if (loading) {
    return loadingComponent || /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { children: "Loading recently viewed products..." }) });
  }
  if (error) {
    return null;
  }
  if (products.length === 0) {
    return emptyComponent || null;
  }
  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className, children: [
    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("h2", { children: "Recently Viewed" }),
    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("ul", { children: products.map((product) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("li", { children: product.title }, product.id)) })
  ] });
};

// src/components/RebuyProductView.tsx
var import_react3 = require("react");
var RebuyProductView = ({ customerId, product, rebuy: customRebuy }) => {
  const tracked = (0, import_react3.useRef)(false);
  const rebuyFromContext = useRebuy();
  (0, import_react3.useEffect)(() => {
    if (tracked.current)
      return;
    tracked.current = true;
    const trackView = async () => {
      try {
        const rebuyInstance = customRebuy || rebuyFromContext;
        if (!rebuyInstance) {
          console.warn("[RebuyProductView] Rebuy SDK not available for product view tracking");
          return;
        }
        let productId = product.id;
        if (productId.includes("/")) {
          const numericId = productId.split("/").pop();
          if (numericId) {
            productId = numericId;
          }
        }
        if (rebuyInstance && rebuyInstance.tracking && rebuyInstance.tracking.productView) {
          await rebuyInstance.tracking.productView(productId);
        } else {
          console.warn("[RebuyProductView] Rebuy SDK tracking.productView method not available");
        }
      } catch (error) {
        console.error("[RebuyProductView] Rebuy product view tracking failed:", error);
      }
    };
    trackView();
  }, [product.id, product.handle, customerId, customRebuy, rebuyFromContext]);
  return null;
};

// src/loader.ts
var import_core_sdk2 = require("@rebuy/core-sdk");
var import_core_sdk3 = require("@rebuy/core-sdk");
var getRebuyData = async (options) => {
  const { apiHost, apiKey, context, request } = options;
  if (!request) {
    console.warn("[getRebuyData] Request object is required for full context enrichment");
  }
  const debug = !!context.env?.REBUY_SDK_DEBUG;
  const logger = {
    log: (...args) => {
      if (debug) {
        console.log("[Rebuy Hydrogen SDK]", ...args);
      }
    }
  };
  logger.log("getRebuyData Entry:", {
    hasI18n: !!context.storefront?.i18n,
    hasRequest: !!request,
    i18nCountry: context.storefront?.i18n?.country,
    i18nLanguage: context.storefront?.i18n?.language,
    requestUrl: request?.url
  });
  const rebuyApiKey = apiKey || context.env?.REBUY_API_KEY || context.env?.PUBLIC_REBUY_API_KEY;
  const rebuyApiHost = apiHost || context.env?.REBUY_API_HOST;
  if (!rebuyApiKey) {
    throw new Error(
      "Rebuy API key is required. Provide it via options.apiKey or set REBUY_API_KEY or PUBLIC_REBUY_API_KEY in your environment."
    );
  }
  logger.log("Initializing Rebuy SDK with context builder support");
  const sdk = new import_core_sdk2.RebuySDK({
    apiHost: rebuyApiHost,
    apiKey: rebuyApiKey,
    debug
  });
  const builder = new import_core_sdk2.RebuyContextBuilder(sdk, debug);
  try {
    logger.log("Fetching cart from Hydrogen context...");
    const cart = await context.cart.get();
    if (cart) {
      logger.log("Cart found, adding to context");
      builder.withCart(cart);
    } else {
      logger.log("No cart found or cart is empty");
    }
  } catch (error) {
    console.warn("[getRebuyData] Failed to fetch cart for context:", error);
  }
  if (request && request.url) {
    try {
      logger.log("Adding URL context from request:", request.url);
      builder.withUrl(request.url);
    } catch (error) {
      console.warn("[getRebuyData] Failed to parse URL for context:", error);
    }
  }
  const i18n = context.storefront?.i18n;
  if (i18n) {
    if (i18n.country) {
      logger.log("Adding country context:", i18n.country);
      builder.withLocation(i18n.country);
    }
    if (i18n.language) {
      logger.log("Adding language context:", i18n.language);
      builder.withLanguage(i18n.language);
    }
  }
  const cartContext = builder.build();
  logger.log("getRebuyData Result:", {
    contextKeys: Object.keys(cartContext),
    contextValues: debug ? cartContext : "(hidden in non-debug mode)",
    sdkInitialized: !!sdk
  });
  return {
    rebuy: {
      cartContext,
      sdk
    }
  };
};
//# sourceMappingURL=index.js.map