@magicstoreai/hydrogen 0.1.0

package/dist/core.cjs

@@ -0,0 +1,746 @@
+"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/core.ts
+var core_exports = {};
+__export(core_exports, {
+  AnalyticsController: () => AnalyticsController,
+  CartController: () => CartController,
+  CustomerSessionController: () => CustomerSessionController,
+  WISHLIST_LIMIT: () => WISHLIST_LIMIT,
+  WishlistController: () => WishlistController,
+  attributionFrom: () => attributionFrom,
+  browserStorage: () => browserStorage,
+  currencySymbol: () => currencySymbol,
+  formatMoney: () => formatMoney,
+  groupAmount: () => groupAmount,
+  initialSelection: () => initialSelection,
+  isOptionValueAvailable: () => isOptionValueAvailable,
+  memoryStorage: () => memoryStorage,
+  moneyAmount: () => moneyAmount,
+  optionsOf: () => optionsOf,
+  selectOption: () => selectOption,
+  variantFor: () => variantFor,
+  visitorSessionId: () => visitorSessionId
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/analytics.ts
+var BATCH_LIMIT = 50;
+function visitorSessionId(storage, key = "magicstore.session-id") {
+  const existing = storage.get(key);
+  if (existing !== null && /^[0-9a-f-]{36}$/i.test(existing)) {
+    return existing;
+  }
+  const id = globalThis.crypto.randomUUID();
+  storage.set(key, id);
+  return id;
+}
+var AnalyticsController = class {
+  constructor(client, sessionId, options = {}) {
+    this.client = client;
+    this.sessionId = sessionId;
+    this.options = options;
+  }
+  client;
+  sessionId;
+  options;
+  queue = [];
+  timer = null;
+  /** A page view — starts the session with its first-touch attribution (UTM, click ids, referrer). */
+  pageView(path, extra = {}) {
+    this.track("PAGE_VIEW", { path: path.slice(0, 255), ...extra });
+  }
+  productView(productId, variantId) {
+    this.track("PRODUCT_VIEW", { productId, variantId: variantId ?? null });
+  }
+  collectionView(collectionId) {
+    this.track("COLLECTION_VIEW", { collectionId });
+  }
+  search(query, resultsCount) {
+    this.track("SEARCH", { query: query.slice(0, 255), resultsCount: resultsCount ?? null });
+  }
+  custom(name, properties) {
+    this.track("CUSTOM", {
+      name: name.slice(0, 64),
+      properties: properties ?? null
+    });
+  }
+  track(type, payload) {
+    this.queue.push({
+      type,
+      sessionId: this.sessionId,
+      occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: { ...this.options.context, ...payload }
+    });
+    if (this.queue.length >= BATCH_LIMIT) {
+      void this.flush();
+      return;
+    }
+    this.timer ??= setTimeout(() => void this.flush(), this.options.flushAfterMs ?? 2e3);
+  }
+  /** Sends what is queued now — call it when the page is hidden. */
+  async flush() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    while (this.queue.length > 0) {
+      const events = this.queue.splice(0, BATCH_LIMIT);
+      try {
+        await this.client.analyticsEventsStore({ body: { events } });
+      } catch {
+      }
+    }
+  }
+};
+function attributionFrom(url, referrer) {
+  const param = (name) => url.searchParams.get(name)?.slice(0, 255) || null;
+  return {
+    utmSource: param("utm_source"),
+    utmMedium: param("utm_medium"),
+    utmCampaign: param("utm_campaign"),
+    utmTerm: param("utm_term"),
+    utmContent: param("utm_content"),
+    utmId: param("utm_id"),
+    gclid: param("gclid"),
+    fbclid: param("fbclid"),
+    referrer: referrer ? referrer.slice(0, 255) : null
+  };
+}
+
+// src/cart.ts
+var import_storefront_client = require("@magicstoreai/storefront-client");
+
+// src/storage.ts
+function memoryStorage(initial = {}) {
+  const values = new Map(Object.entries(initial));
+  return {
+    get: (key) => values.get(key) ?? null,
+    set: (key, value) => void values.set(key, value),
+    remove: (key) => void values.delete(key)
+  };
+}
+function browserStorage() {
+  const fallback = memoryStorage();
+  const local = () => {
+    try {
+      return typeof window === "undefined" ? null : window.localStorage;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    get(key) {
+      try {
+        return local()?.getItem(key) ?? fallback.get(key);
+      } catch {
+        return fallback.get(key);
+      }
+    },
+    set(key, value) {
+      try {
+        const storage = local();
+        if (storage) {
+          storage.setItem(key, value);
+          return;
+        }
+      } catch {
+      }
+      fallback.set(key, value);
+    },
+    remove(key) {
+      try {
+        local()?.removeItem(key);
+      } catch {
+      }
+      fallback.remove(key);
+    }
+  };
+}
+function readJson(storage, key) {
+  const raw = storage.get(key);
+  if (raw === null) {
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    storage.remove(key);
+    return null;
+  }
+}
+var Observable = class {
+  constructor(value, serverValue) {
+    this.value = value;
+    this.serverValue = serverValue ?? value;
+  }
+  value;
+  listeners = /* @__PURE__ */ new Set();
+  serverValue;
+  get() {
+    return this.value;
+  }
+  set(value) {
+    this.value = value;
+    for (const listener of [...this.listeners]) {
+      listener();
+    }
+  }
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  getSnapshot = () => this.value;
+  getServerSnapshot = () => this.serverValue;
+};
+
+// src/cart.ts
+var GONE = /* @__PURE__ */ new Set(["CART_NOT_FOUND", "CART_CLOSED"]);
+var CartController = class extends Observable {
+  constructor(client, storage, key = "magicstore.cart-id") {
+    super(
+      { cart: null, status: storage.get(key) === null ? "idle" : "loading", error: null },
+      { cart: null, status: "loading", error: null }
+    );
+    this.client = client;
+    this.storage = storage;
+    this.key = key;
+  }
+  client;
+  storage;
+  key;
+  queue = Promise.resolve();
+  get cart() {
+    return this.get().cart;
+  }
+  get cartId() {
+    return this.storage.get(this.key);
+  }
+  /** Fetches the stored cart, if any. A cart that is gone is forgotten. */
+  load() {
+    return this.enqueue(async () => {
+      const id = this.cartId;
+      if (id === null) {
+        this.patch({ status: "idle" });
+        return null;
+      }
+      this.patch({ status: "loading" });
+      try {
+        const { data } = await this.client.cartsShow({ path: { id } });
+        return this.adopt(data);
+      } catch (error) {
+        return this.fail(error, null);
+      }
+    });
+  }
+  /** Adds lines; the first add creates the cart. */
+  addLines(lines) {
+    return this.mutate(null, (id) => {
+      const body = { lines: lines.map(toLine) };
+      return id === null ? this.client.cartsStore({ body }) : this.client.cartsLinesStore({ path: { id }, body });
+    });
+  }
+  /** The line's quantity outright; 0 removes it. Shown at once, rolled back if refused. */
+  updateLine(lineId, quantity) {
+    return this.mutate(
+      (cart) => withQuantity(cart, lineId, quantity),
+      (id) => this.client.cartsLinesUpdate({ path: { id: required(id), lineId }, body: { quantity } })
+    );
+  }
+  removeLine(lineId) {
+    return this.mutate(
+      (cart) => withQuantity(cart, lineId, 0),
+      (id) => this.client.cartsLinesDestroy({ path: { id: required(id), lineId } })
+    );
+  }
+  /** The cart's codes as a whole — `[]` takes the code off. A code that does not apply is kept, flagged. */
+  setDiscountCodes(discountCodes) {
+    return this.mutate(
+      null,
+      (id) => this.client.cartsDiscountCodes({ path: { id: required(id) }, body: { discountCodes } })
+    );
+  }
+  setNote(note) {
+    return this.mutate(
+      null,
+      (id) => this.client.cartsNote({ path: { id: required(id) }, body: { note } })
+    );
+  }
+  setAttributes(attributes) {
+    return this.mutate(
+      null,
+      (id) => this.client.cartsAttributes({ path: { id: required(id) }, body: { attributes } })
+    );
+  }
+  /** The gift promotion chosen from `cart.giftOptions`; null takes it off. */
+  setGift(promotionId) {
+    return this.mutate(
+      null,
+      (id) => this.client.cartsGift({ path: { id: required(id) }, body: { promotionId } })
+    );
+  }
+  /** Points to spend on this cart (signed-in customers). */
+  setPoints(points) {
+    return this.mutate(
+      null,
+      (id) => this.client.cartsPoints({ path: { id: required(id) }, body: { points } })
+    );
+  }
+  /**
+   * After sign-in: the cart becomes the customer's. When they already had an open cart, this one
+   * merges into it and the answer is THAT cart — its id replaces the stored one.
+   */
+  attachCustomer() {
+    return this.enqueue(async () => {
+      const id = this.cartId;
+      if (id === null) {
+        return null;
+      }
+      this.patch({ status: "updating" });
+      try {
+        const { data } = await this.client.cartsBuyerIdentity({ path: { id } });
+        return this.adopt(data);
+      } catch (error) {
+        return this.fail(error, this.cart);
+      }
+    });
+  }
+  /** After sign-out: the cart is the customer's, not this visitor's any more. */
+  forget() {
+    this.storage.remove(this.key);
+    this.set({ cart: null, status: "idle", error: null });
+  }
+  /** Shows `optimistic` at once (when given), sends the change, and adopts the server's cart or rolls back. */
+  mutate(optimistic, send) {
+    return this.enqueue(async () => {
+      const before = this.cart;
+      this.patch({
+        status: "updating",
+        error: null,
+        cart: optimistic !== null && before !== null ? optimistic(before) : before
+      });
+      try {
+        const { data } = await send(this.cartId);
+        return this.adopt(data);
+      } catch (error) {
+        return this.fail(error, before);
+      }
+    });
+  }
+  adopt(cart) {
+    this.storage.set(this.key, cart.id);
+    this.set({ cart, status: "idle", error: null });
+    return cart;
+  }
+  fail(error, rollback) {
+    const failure = error instanceof import_storefront_client.MagicStoreError ? error : new import_storefront_client.MagicStoreError({
+      status: 0,
+      code: "NETWORK_ERROR",
+      message: String(error),
+      requestId: ""
+    });
+    if (GONE.has(failure.code)) {
+      this.storage.remove(this.key);
+      this.set({ cart: null, status: "idle", error: failure });
+    } else {
+      this.set({ cart: rollback, status: "idle", error: failure });
+    }
+    throw failure;
+  }
+  patch(state) {
+    this.set({ ...this.get(), ...state });
+  }
+  enqueue(task) {
+    const run = this.queue.then(task, task);
+    this.queue = run.catch(() => void 0);
+    return run;
+  }
+};
+function toLine(line) {
+  return {
+    productId: line.productId,
+    variantId: line.variantId ?? null,
+    quantity: line.quantity ?? 1,
+    attributes: line.attributes ?? []
+  };
+}
+function required(id) {
+  if (id === null) {
+    throw new import_storefront_client.MagicStoreError({
+      status: 404,
+      code: "CART_NOT_FOUND",
+      message: "There is no cart yet.",
+      requestId: ""
+    });
+  }
+  return id;
+}
+function withQuantity(cart, lineId, quantity) {
+  const lines = quantity <= 0 ? cart.lines.filter((line) => line.id !== lineId) : cart.lines.map((line) => line.id === lineId ? { ...line, quantity } : line);
+  return { ...cart, lines, totalQuantity: lines.reduce((sum, line) => sum + line.quantity, 0) };
+}
+
+// src/money.ts
+var TEMPLATES = {
+  ru: {
+    UZS: "{amount} \u0441\u0443\u043C",
+    USD: "${amount}",
+    KGS: "{amount} \u0441\u043E\u043C",
+    KZT: "{amount} \u20B8",
+    RUB: "{amount} \u20BD"
+  },
+  uz: {
+    UZS: "{amount} so\u2018m",
+    USD: "${amount}",
+    KGS: "{amount} som",
+    KZT: "{amount} \u20B8",
+    RUB: "{amount} \u20BD"
+  },
+  en: {
+    UZS: "{amount} UZS",
+    USD: "${amount}",
+    KGS: "{amount} KGS",
+    KZT: "{amount} \u20B8",
+    RUB: "{amount} \u20BD"
+  }
+};
+function template(currencyCode, locale) {
+  const language = locale.toLowerCase().split(/[-_]/)[0] ?? "ru";
+  return (TEMPLATES[language] ?? TEMPLATES["ru"])[currencyCode] ?? `{amount} ${currencyCode}`;
+}
+function currencySymbol(currencyCode, locale) {
+  return template(currencyCode, locale).replace("{amount}", "").trim();
+}
+function groupAmount(amount) {
+  const negative = amount.startsWith("-");
+  const [integer = "0", fraction = ""] = amount.replace(/^[-+]/, "").split(".");
+  const grouped = integer.replace(/^0+(?=\d)/, "").replace(/\B(?=(\d{3})+(?!\d))/g, " ");
+  const kept = /^0*$/.test(fraction) ? "" : `.${fraction}`;
+  return `${negative ? "-" : ""}${grouped}${kept}`;
+}
+function formatMoney(money, options) {
+  const amount = groupAmount(money.amount);
+  const symbol = currencySymbol(money.currencyCode, options.locale);
+  switch (options.format?.format) {
+    case "SYMBOL_AFTER":
+      return `${amount} ${symbol}`.trim();
+    case "SYMBOL_BEFORE":
+      return `${symbol} ${amount}`.trim();
+    case "CODE_AFTER":
+      return `${amount} ${money.currencyCode}`;
+    default:
+      return template(money.currencyCode, options.locale).replace("{amount}", amount);
+  }
+}
+function moneyAmount(money) {
+  return Number(money.amount);
+}
+
+// src/session.ts
+var import_storefront_client2 = require("@magicstoreai/storefront-client");
+var REFRESH_AHEAD_MS = 6e4;
+var CustomerSessionController = class extends Observable {
+  constructor(storage, key = "magicstore.customer-session", now = () => Date.now()) {
+    super({ session: readJson(storage, key) }, { session: null });
+    this.storage = storage;
+    this.key = key;
+    this.now = now;
+  }
+  storage;
+  key;
+  now;
+  refreshing = null;
+  client = null;
+  /** The client the session signs in and refreshes through (created with this controller's token). */
+  attach(client) {
+    this.client = client;
+  }
+  get session() {
+    return this.get().session;
+  }
+  get customer() {
+    return this.session?.customer ?? null;
+  }
+  /** The bearer for the next call: refreshed when it is about to expire; null when signed out. */
+  accessToken = async () => {
+    const session = this.session;
+    if (session === null) {
+      return null;
+    }
+    if (Date.parse(session.expiresAt) - this.now() > REFRESH_AHEAD_MS) {
+      return session.accessToken;
+    }
+    return this.refresh();
+  };
+  /** One refresh at a time: every caller waiting meanwhile gets its result. */
+  refresh() {
+    this.refreshing ??= this.doRefresh().finally(() => {
+      this.refreshing = null;
+    });
+    return this.refreshing;
+  }
+  async doRefresh() {
+    const session = this.session;
+    if (session === null) {
+      return null;
+    }
+    if (Date.parse(session.refreshTokenExpiresAt) <= this.now()) {
+      this.store(null);
+      return null;
+    }
+    try {
+      const { data } = await this.requireClient().authTokenRefresh(
+        { body: { refreshToken: session.refreshToken } },
+        { customerToken: null }
+      );
+      this.store(data);
+      return data.accessToken;
+    } catch (error) {
+      if (error instanceof import_storefront_client2.MagicStoreError && error.status === 401) {
+        this.store(null);
+        return null;
+      }
+      return session.accessToken;
+    }
+  }
+  /** Texts a sign-in code. */
+  async requestOtp(phone) {
+    const { data } = await this.requireClient().authOtp(
+      { body: { phone } },
+      { customerToken: null }
+    );
+    return data;
+  }
+  async verifyOtp(phone, code, referralCode) {
+    const body = referralCode === void 0 ? { phone, code } : { phone, code, referralCode };
+    return this.signedIn(
+      this.requireClient().authOtpVerification({ body }, { customerToken: null })
+    );
+  }
+  async signInWithTelegram(initData, referralCode) {
+    const body = referralCode === void 0 ? { initData } : { initData, referralCode };
+    return this.signedIn(this.requireClient().authTelegram({ body }, { customerToken: null }));
+  }
+  async signInWithOq(oqToken) {
+    return this.signedIn(
+      this.requireClient().authOq({ body: { oqToken } }, { customerToken: null })
+    );
+  }
+  async signInWithClick(webSession) {
+    return this.signedIn(
+      this.requireClient().authClick({ body: { webSession } }, { customerToken: null })
+    );
+  }
+  /** Ends this sign-in on the server too; signed out locally whatever the server says. */
+  async signOut() {
+    const session = this.session;
+    this.store(null);
+    if (session === null) {
+      return;
+    }
+    try {
+      await this.requireClient().authTokenDestroy(void 0, {
+        customerToken: session.accessToken
+      });
+    } catch {
+    }
+  }
+  /** The customer as the server has them now (after a profile change). */
+  async reloadCustomer() {
+    if (this.session === null) {
+      return null;
+    }
+    const { data } = await this.requireClient().customerShow();
+    const current = this.session;
+    if (current !== null) {
+      this.store({ ...current, customer: data });
+    }
+    return data;
+  }
+  async signedIn(call) {
+    const { data } = await call;
+    this.store(data);
+    return data;
+  }
+  store(session) {
+    if (session === null) {
+      this.storage.remove(this.key);
+    } else {
+      this.storage.set(this.key, JSON.stringify(session));
+    }
+    this.set({ session });
+  }
+  requireClient() {
+    if (this.client === null) {
+      throw new Error("CustomerSessionController is not attached to a client.");
+    }
+    return this.client;
+  }
+};
+
+// src/variants.ts
+function optionsOf(variant) {
+  return Object.fromEntries(variant.selectedOptions.map((option) => [option.name, option.value]));
+}
+function variantFor(product, selected) {
+  return product.variants.find(
+    (variant) => variant.selectedOptions.every((option) => selected[option.name] === option.value)
+  ) ?? null;
+}
+function initialSelection(product, variantId) {
+  const start = product.variants.find((variant) => variant.id === variantId) ?? product.variants.find((variant) => variant.availableForSale) ?? product.variants[0];
+  return start ? optionsOf(start) : {};
+}
+function isOptionValueAvailable(product, selected, name, value) {
+  const candidate = { ...selected, [name]: value };
+  return product.variants.some(
+    (variant) => variant.availableForSale && variant.selectedOptions.every(
+      (option) => candidate[option.name] === void 0 || candidate[option.name] === option.value
+    )
+  );
+}
+function selectOption(product, selected, name, value) {
+  const candidate = { ...selected, [name]: value };
+  if (variantFor(product, candidate) !== null) {
+    return candidate;
+  }
+  const withValue = product.variants.filter(
+    (variant) => variant.selectedOptions.some((option) => option.name === name && option.value === value)
+  );
+  const score = (variant) => variant.selectedOptions.filter((option) => selected[option.name] === option.value).length + (variant.availableForSale ? 0.5 : 0);
+  const best = [...withValue].sort((a, b) => score(b) - score(a))[0];
+  return best ? optionsOf(best) : candidate;
+}
+
+// src/wishlist.ts
+var WISHLIST_LIMIT = 500;
+var WishlistController = class extends Observable {
+  constructor(client, storage, key = "magicstore.guest-wishlist") {
+    super(
+      { productIds: readJson(storage, key) ?? [], owner: "guest", status: "idle" },
+      { productIds: [], owner: "guest", status: "idle" }
+    );
+    this.client = client;
+    this.storage = storage;
+    this.key = key;
+  }
+  client;
+  storage;
+  key;
+  has(productId) {
+    return this.get().productIds.includes(productId);
+  }
+  async add(productId) {
+    if (this.has(productId)) {
+      return;
+    }
+    const before = this.get().productIds;
+    this.setIds([productId, ...before].slice(0, WISHLIST_LIMIT));
+    if (this.get().owner === "guest") {
+      return;
+    }
+    try {
+      await this.client.customerWishlistAdd({ path: { productId } });
+    } catch (error) {
+      this.setIds(before);
+      throw error;
+    }
+  }
+  async remove(productId) {
+    const before = this.get().productIds;
+    this.setIds(before.filter((id) => id !== productId));
+    if (this.get().owner === "guest") {
+      return;
+    }
+    try {
+      await this.client.customerWishlistRemove({ path: { productId } });
+    } catch (error) {
+      this.setIds(before);
+      throw error;
+    }
+  }
+  toggle(productId) {
+    return this.has(productId) ? this.remove(productId) : this.add(productId);
+  }
+  /** After sign-in: the guest's products join the customer's list, then the list is the server's. */
+  async signedIn() {
+    const guest = this.get().owner === "guest" ? this.get().productIds : [];
+    this.set({ ...this.get(), owner: "customer", status: "loading" });
+    for (const productId of [...guest].reverse()) {
+      try {
+        await this.client.customerWishlistAdd({ path: { productId } });
+      } catch {
+      }
+    }
+    this.storage.remove(this.key);
+    await this.reload();
+  }
+  /** After sign-out: back to an empty guest list — the customer's list stays on the server. */
+  signedOut() {
+    this.storage.remove(this.key);
+    this.set({ productIds: [], owner: "guest", status: "idle" });
+  }
+  /** The customer's list as the server has it. */
+  async reload() {
+    if (this.get().owner === "guest") {
+      return;
+    }
+    const ids = [];
+    for await (const product of this.client.paginate("customerWishlistIndex", {
+      query: { perPage: 100 }
+    })) {
+      ids.push(product.id);
+      if (ids.length >= WISHLIST_LIMIT) {
+        break;
+      }
+    }
+    this.set({ productIds: ids, owner: "customer", status: "idle" });
+  }
+  setIds(productIds) {
+    if (this.get().owner === "guest") {
+      this.storage.set(this.key, JSON.stringify(productIds));
+    }
+    this.set({ ...this.get(), productIds });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnalyticsController,
+  CartController,
+  CustomerSessionController,
+  WISHLIST_LIMIT,
+  WishlistController,
+  attributionFrom,
+  browserStorage,
+  currencySymbol,
+  formatMoney,
+  groupAmount,
+  initialSelection,
+  isOptionValueAvailable,
+  memoryStorage,
+  moneyAmount,
+  optionsOf,
+  selectOption,
+  variantFor,
+  visitorSessionId
+});
+//# sourceMappingURL=core.cjs.map