@loczer/storefront-sdk 0.147.0 → 0.149.0

package/dist/lib/booking-period.js

@@ -0,0 +1,349 @@
+const k = (t) => {
+  const e = Math.max(0, t), n = Math.floor(e / 60) % 24, a = e % 60;
+  return `${String(n).padStart(2, "0")}:${String(a).padStart(2, "0")}`;
+}, O = (t) => {
+  if (!t) return null;
+  const [e, n] = t.split(":"), a = Number(e), s = Number(n);
+  return !Number.isFinite(a) || !Number.isFinite(s) || a < 0 || s < 0 ? null : a * 60 + s;
+}, X = (t) => {
+  const e = t.includes("-") ? t.replace(/-/g, "") : t;
+  return /^\d{8}$/.test(e) ? Number(e) : null;
+}, Z = (t) => {
+  const e = String(Math.trunc(t)).padStart(8, "0");
+  return `${e.slice(0, 4)}-${e.slice(4, 6)}-${e.slice(6, 8)}`;
+}, H = (t) => {
+  const e = t.getFullYear(), n = t.getMonth() + 1, a = t.getDate(), s = String(n).padStart(2, "0"), r = String(a).padStart(2, "0");
+  return +`${e}${s}${r}`;
+}, E = (t) => {
+  if (!t)
+    return null;
+  if (t instanceof Date)
+    return Number.isNaN(t.getTime()) ? null : H(t);
+  const e = X(t);
+  if (e != null)
+    return e;
+  const n = new Date(t);
+  return Number.isNaN(n.getTime()) ? null : H(n);
+}, B = (t, e) => {
+  const n = t ? E(t) : null;
+  return n != null ? Z(n) : t || Z(e);
+}, tt = (t) => {
+  const e = Z(t), [n, a, s] = e.split("-").map(Number), o = new Date(n, (a || 1) - 1, s || 1).getDay();
+  return Number.isNaN(o) ? 0 : (o + 6) % 7;
+}, Y = (t) => Array.isArray(t) ? t.map((e) => {
+  if (!e || typeof e != "object")
+    return null;
+  const n = typeof e.start == "string" ? e.start : "", a = typeof e.end == "string" ? e.end : "";
+  return !n || !a ? null : { start: n, end: a };
+}).filter((e) => !!e) : [], et = (t) => {
+  const e = O(t.start), n = O(t.end);
+  if (e == null || n == null || n <= e)
+    return null;
+  const a = k(e), s = k(n);
+  return {
+    startMinutes: e,
+    endMinutes: n,
+    startLabel: a,
+    endLabel: s,
+    rangeLabel: `${a} - ${s}`
+  };
+}, nt = (t, e) => {
+  const n = e.map(et).filter((r) => !!r).sort((r, o) => r.startMinutes - o.startMinutes);
+  if (!n.length)
+    return {
+      day: t,
+      isClosed: !0,
+      openingSlots: [],
+      openingMinutes: null,
+      closingMinutes: null,
+      summaryLabel: null
+    };
+  const a = n[0], s = n[n.length - 1];
+  return {
+    day: t,
+    isClosed: !1,
+    openingSlots: n,
+    openingMinutes: a.startMinutes,
+    closingMinutes: s.endMinutes,
+    summaryLabel: n.map((r) => r.rangeLabel).join(" / ")
+  };
+}, I = (t, e, n = {}) => {
+  const a = Array.isArray(t) ? t : [], s = Array.isArray(e) ? e : [], r = /* @__PURE__ */ new Map();
+  for (const i of s) {
+    if (!i || typeof i != "object")
+      continue;
+    const l = E(i.date);
+    l != null && r.set(l, Y(i.openingSlots));
+  }
+  const o = E(n.referenceDate) ?? H(/* @__PURE__ */ new Date()), y = tt(o), c = r.get(o);
+  let f, m;
+  for (const i of a) {
+    if (!i || typeof i != "object")
+      continue;
+    const l = E(i.startDate), h = E(i.endDate);
+    if (l == null || h == null) {
+      m || (m = i);
+      continue;
+    }
+    const w = Math.min(l, h), F = Math.max(l, h);
+    if (o >= w && o <= F) {
+      f = i;
+      break;
+    }
+    m || (m = i);
+  }
+  const u = f ?? m ?? null, S = Array.isArray(u?.openingHours) ? u.openingHours : [], M = /* @__PURE__ */ new Map();
+  for (const i of S) {
+    if (!i || typeof i.day != "number")
+      continue;
+    const l = (i.day % 7 + 7) % 7, h = Y(i.openingSlots);
+    M.set(l, h);
+  }
+  c && M.set(y, c);
+  const b = [];
+  for (let i = 0; i < 7; i += 1) {
+    const l = i, h = M.get(l) ?? [];
+    b.push(nt(l, h));
+  }
+  const T = b.flatMap((i) => i.openingSlots);
+  if (!T.length)
+    return {
+      days: b,
+      defaultOpeningMinutes: 0,
+      defaultClosingMinutes: 0,
+      defaultOpeningLabel: "00:00",
+      defaultClosingLabel: "00:00",
+      defaultSummaryLabel: "",
+      season: u ? {
+        name: typeof u.name == "string" ? u.name : void 0,
+        startDate: B(u.startDate, o),
+        endDate: B(u.endDate, o)
+      } : null
+    };
+  const C = T.reduce((i, l) => l.startMinutes < i.startMinutes ? l : i), x = T.reduce((i, l) => l.endMinutes > i.endMinutes ? l : i), g = b.find((i) => !i.isClosed && i.summaryLabel) ?? b[0];
+  return {
+    days: b,
+    defaultOpeningMinutes: C.startMinutes,
+    defaultClosingMinutes: x.endMinutes,
+    defaultOpeningLabel: C.startLabel,
+    defaultClosingLabel: x.endLabel,
+    defaultSummaryLabel: g.summaryLabel ?? `${C.startLabel} - ${x.endLabel}`,
+    season: u ? {
+      name: typeof u.name == "string" ? u.name : void 0,
+      startDate: B(u.startDate, o),
+      endDate: B(u.endDate, o)
+    } : null
+  };
+}, G = (t) => {
+  const { timing: e, openingHours: n, openingHoursOverrides: a, timeZone: s } = t, r = e.slotIntervalMinutes, o = I(n, a), y = I(n, []), c = (d) => d?.dateString ? I(n, a, {
+    referenceDate: d.dateString
+  }) : o, f = (d) => d?.dateString ? I(n, [], {
+    referenceDate: d.dateString
+  }) : y, m = (d, D) => c(D).days.find((p) => p.day === d), u = (d, D) => m(d, D)?.openingSlots ?? [], S = (d, D) => f(D).days.find((p) => p.day === d), M = (d, D) => S(d, D)?.openingSlots ?? [], b = (d, D, L) => {
+    const p = u(d, L);
+    if (!p.length)
+      return null;
+    const z = typeof D == "number" ? Math.max(D, 0) : Number.NEGATIVE_INFINITY;
+    for (const $ of p) {
+      const N = $.startMinutes, V = $.endMinutes - r;
+      if (V < N)
+        continue;
+      const Q = Math.max(N, z), K = Math.ceil(Q / r) * r;
+      if (!(K < N) && !(K > V))
+        return K;
+    }
+    return null;
+  }, T = (d, D) => {
+    const L = u(d, D);
+    for (let p = L.length - 1; p >= 0; p -= 1) {
+      const z = L[p], $ = z.startMinutes, N = z.endMinutes - r;
+      if (!(N < $))
+        return N;
+    }
+    return null;
+  }, C = (d, D, L) => {
+    if (D == null)
+      return !1;
+    const p = u(d, L);
+    return p.length ? p.some((z) => {
+      const $ = z.startMinutes, N = z.endMinutes - r;
+      return N < $ ? !1 : D >= $ && D <= N;
+    }) : !1;
+  }, g = o.days.find((d) => !d.isClosed && d.openingSlots.length)?.day ?? o.days[0]?.day ?? 0, l = y.days.find((d) => !d.isClosed && d.openingSlots.length)?.day ?? y.days[0]?.day ?? 0, h = Math.ceil(Math.max(0, o.defaultOpeningMinutes) / r) * r, w = b(g) ?? h;
+  let F = w + r;
+  const J = Math.floor(Math.max(0, o.defaultClosingMinutes - r) / r) * r, _ = T(g) ?? J;
+  (!Number.isFinite(F) || F > _) && (F = w), Number.isFinite(F) || (F = Math.max(0, o.defaultOpeningMinutes));
+  const j = Math.max(0, F), R = Math.max(j, _);
+  return {
+    timeZone: s,
+    slotIntervalMinutes: r,
+    autoFillCutoffMinutes: e.autoFillCutoffMinutes,
+    pastToleranceMinutes: e.pastToleranceMinutes,
+    minBufferMinutes: e.minBufferMinutes,
+    defaultOpeningMinutes: o.defaultOpeningMinutes,
+    defaultClosingMinutes: o.defaultClosingMinutes,
+    defaultOpeningLabel: o.defaultOpeningLabel,
+    defaultClosingLabel: o.defaultClosingLabel,
+    defaultSummaryLabel: o.defaultSummaryLabel,
+    defaultWeekday: g,
+    defaultSeasonWeekday: l,
+    defaultStartMinutes: j,
+    defaultStartTime: k(j),
+    defaultEndMinutes: R,
+    defaultEndTime: k(R),
+    getDayHours: m,
+    getIntervalsForWeekday: u,
+    getSeasonDayHours: S,
+    getSeasonIntervalsForWeekday: M,
+    getFirstStartMinutesForWeekday: b,
+    getLastStartMinutesForWeekday: T,
+    isValidStartMinutesForWeekday: C,
+    getNormalizedOpeningHours: c,
+    getSeasonNormalizedOpeningHours: f
+  };
+}, at = (t, e, n) => new Intl.DateTimeFormat("en-CA", {
+  timeZone: e,
+  ...n
+}).format(t), A = (t, e) => {
+  const a = new Intl.DateTimeFormat("en-CA", {
+    timeZone: e,
+    hour12: !1,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit"
+  }).formatToParts(t), s = Object.fromEntries(a.map((c) => [c.type, c.value])), r = `${s.year}-${s.month}-${s.day}`, o = `${s.hour}:${s.minute}`, y = Number(s.hour) * 60 + Number(s.minute);
+  return { dateString: r, timeString: o, minutesFromMidnight: y };
+}, q = (t) => {
+  const n = (t.includes("-") ? t.replace(/-/g, "") : t).match(/^(\d{4})(\d{2})(\d{2})$/);
+  if (!n)
+    return { year: Number.NaN, month: Number.NaN, day: Number.NaN };
+  const [, a, s, r] = n;
+  return { year: Number(a), month: Number(s), day: Number(r) };
+}, rt = (t, e) => {
+  const n = new Date(t.getTime());
+  return n.setUTCDate(n.getUTCDate() + e), n;
+}, st = (t, e) => {
+  const { dateString: n, minutesFromMidnight: a } = A(t, e.timeZone), s = W(n);
+  if (Number.isNaN(s.getTime()))
+    return { baseDate: /* @__PURE__ */ new Date(), minutesFromMidnight: a };
+  const r = new Date(s.getFullYear(), s.getMonth(), s.getDate());
+  return a >= e.autoFillCutoffMinutes && r.setDate(r.getDate() + 1), { baseDate: r, minutesFromMidnight: a };
+}, ot = (t) => {
+  const e = t.referenceDate ?? /* @__PURE__ */ new Date(), n = G(t.config), { baseDate: a } = st(e, n), s = new Date(a.getTime()), r = new Date(a.getTime()), o = n.defaultStartTime, y = n.defaultEndTime, c = it(
+    {
+      startDate: s,
+      startTime: o,
+      endDate: r,
+      endTime: y
+    },
+    { referenceDate: e, config: t.config }
+  ), f = c.startDateString ? W(c.startDateString) : s, m = c.shouldResetEnd ? new Date(f.getTime()) : c.endDateString ? W(c.endDateString) : r, u = c.startTime ?? o, S = c.endTime ?? y;
+  return {
+    startDate: new Date(f.getTime()),
+    startTime: u,
+    endDate: new Date(m.getTime()),
+    endTime: S
+  };
+}, U = (t, e) => {
+  if (t) {
+    if (typeof t == "string") {
+      const { year: n, month: a, day: s } = q(t);
+      return !Number.isFinite(n) || !Number.isFinite(a) || !Number.isFinite(s) ? void 0 : `${String(n).padStart(4, "0")}-${String(a).padStart(2, "0")}-${String(s).padStart(2, "0")}`;
+    }
+    return at(t, e, { year: "numeric", month: "2-digit", day: "2-digit" });
+  }
+}, W = (t) => {
+  const { year: e, month: n, day: a } = q(t);
+  return new Date(e, n - 1, a);
+}, v = (t) => {
+  const n = W(t).getDay();
+  return Number.isNaN(n) ? 0 : (n + 6) % 7;
+}, P = (t, e, n) => {
+  const { dateString: a, minutesFromMidnight: s } = A(t, e.timeZone), r = e.slotIntervalMinutes, o = v(a), y = typeof n == "number" ? n : s + e.minBufferMinutes;
+  let c = Math.ceil(Math.max(y, 0) / r) * r, f = t, m = a, u = o, S = 0;
+  for (; S < 14; ) {
+    const M = e.getFirstStartMinutesForWeekday(
+      u,
+      S === 0 ? c : null,
+      { dateString: m }
+    );
+    if (typeof M == "number")
+      return {
+        dateString: m,
+        time: k(M)
+      };
+    S += 1, f = rt(f, 1), m = A(f, e.timeZone).dateString, u = v(m), c = 0;
+  }
+  return {
+    dateString: a,
+    time: k(e.defaultStartMinutes)
+  };
+}, it = (t, e) => {
+  const n = e.referenceDate ?? /* @__PURE__ */ new Date(), a = G(e.config), s = e.toleranceMinutes ?? a.pastToleranceMinutes, r = U(t.startDate, a.timeZone), o = U(t.endDate, a.timeZone), y = t.startTime ?? null;
+  if (!r)
+    return {
+      startDateString: r,
+      startTime: y,
+      endDateString: o,
+      endTime: t.endTime ?? null,
+      wasAdjusted: !1,
+      shouldResetEnd: !1
+    };
+  const c = A(n, a.timeZone);
+  let f = r, m = y, u, S = !1;
+  if (r < c.dateString) {
+    const g = P(n, a);
+    f = g.dateString, m = g.time, u = "start_date_in_past", S = !0;
+  } else if (r === c.dateString) {
+    const g = O(y), i = c.minutesFromMidnight - s;
+    if (g == null || g < i) {
+      const l = P(n, a);
+      f = l.dateString, m = l.time, u = "start_time_in_past", S = !0;
+    }
+  }
+  const M = f ?? r;
+  if (M) {
+    const g = v(M), i = O(m);
+    if (!a.isValidStartMinutesForWeekday(g, i, {
+      dateString: M
+    })) {
+      const l = a.getFirstStartMinutesForWeekday(g, null, {
+        dateString: M
+      });
+      if (typeof l == "number")
+        m = k(l), S = !0;
+      else {
+        const h = W(M), w = P(h, a, 0);
+        f = w.dateString, m = w.time, S = !0;
+      }
+    }
+  }
+  const b = S, T = b ? void 0 : o, C = (() => {
+    const g = f ?? r;
+    if (!g)
+      return a.defaultEndTime;
+    const i = v(g), l = a.getLastStartMinutesForWeekday(i, { dateString: g });
+    return typeof l == "number" ? k(l) : a.defaultEndTime;
+  })(), x = b ? C : t.endTime ?? null;
+  return {
+    startDateString: f,
+    startTime: m,
+    endDateString: T,
+    endTime: x,
+    wasAdjusted: S,
+    adjustmentReason: u,
+    shouldResetEnd: b
+  };
+};
+export {
+  it as adjustBookingPeriod,
+  W as businessDateStringToDate,
+  G as createBookingPeriodConstants,
+  U as dateToBusinessDateString,
+  ot as getDefaultBookingPeriod,
+  k as minutesToTimeString,
+  I as normalizeOpeningHours,
+  O as parseTimeToMinutes
+};

package/dist/lib/booking.d.ts

@@ -0,0 +1,39 @@
+import { StorefrontConfiguration } from '../storefrontSchemas';
+import { BookingPeriodConfig } from './booking-period';
+export declare const BOOKING_SEARCH_KEYS: readonly ["fulfillment", "start_date", "start_time", "end_date", "end_time", "start_address", "end_address"];
+export type BookingFulfillment = "pickup" | "delivery";
+export type StorefrontBookingParams = {
+    fulfillment: BookingFulfillment;
+    start_date: string;
+    start_time: string;
+    end_date: string;
+    end_time: string;
+    start_address: string;
+    end_address: string;
+};
+type BookingSearchStorage = Pick<Storage, "getItem" | "removeItem" | "setItem"> | null | undefined;
+export declare const TIME_OPTIONS: string[];
+export declare const getDefaultBookingParams: (now?: Date) => StorefrontBookingParams;
+export declare const createBookingPeriodConfigFromStorefrontConfiguration: (storefrontConfiguration: StorefrontConfiguration) => BookingPeriodConfig;
+export declare const getDefaultBookingParamsForStorefrontConfiguration: (storefrontConfiguration: StorefrontConfiguration, now?: Date) => StorefrontBookingParams;
+export declare const getBookingParamsFromSearch: (searchParams: URLSearchParams, fallback?: Partial<StorefrontBookingParams>) => StorefrontBookingParams;
+export declare const applyBookingParamsToSearch: (searchParams: URLSearchParams, booking: Partial<StorefrontBookingParams>) => URLSearchParams;
+export declare const pickBookingSearchParams: (searchParams: URLSearchParams) => URLSearchParams;
+export declare const getBookingSessionStorageKey: (storeSlug?: string) => string;
+export declare const readBookingSearchParamsFromStorage: (storage: BookingSearchStorage, storeSlug?: string) => URLSearchParams;
+export declare const writeBookingSearchParamsToStorage: (storage: BookingSearchStorage, storeSlug: string | undefined, booking: Partial<StorefrontBookingParams> | URLSearchParams) => void;
+export declare const readBookingSearchParamsFromSessionStorage: (storeSlug?: string) => URLSearchParams;
+export declare const writeBookingSearchParamsToSessionStorage: (storeSlug: string | undefined, booking: Partial<StorefrontBookingParams> | URLSearchParams) => void;
+export declare const resolveBookingSearchParams: (searchParams: URLSearchParams, options?: {
+    storage?: BookingSearchStorage;
+    storeSlug?: string;
+}) => URLSearchParams;
+export declare const resolveBookingSearchParamsFromSessionStorage: (searchParams: URLSearchParams, storeSlug?: string) => URLSearchParams;
+export declare const getBookingDurationMinutes: (booking: StorefrontBookingParams) => number;
+export declare const getBookingDurationLabel: (booking: StorefrontBookingParams) => {
+    hours: number;
+    minutes: number;
+    label: string;
+};
+export {};
+//# sourceMappingURL=booking.d.ts.map

package/dist/lib/booking.js

@@ -0,0 +1,159 @@
+import { differenceInMinutes as p, format as T } from "date-fns";
+import { getDefaultBookingPeriod as h, parseTimeToMinutes as B } from "./booking-period.js";
+const E = [
+  "fulfillment",
+  "start_date",
+  "start_time",
+  "end_date",
+  "end_time",
+  "start_address",
+  "end_address"
+], P = "loczer_storefront_booking:", i = (t) => T(t, "yyyy-MM-dd"), D = () => {
+  const t = [];
+  for (let e = 8; e <= 18; e += 1)
+    for (const n of [0, 30])
+      e === 18 && n > 0 || t.push(`${String(e).padStart(2, "0")}:${String(n).padStart(2, "0")}`);
+  return t;
+}, u = D(), I = (t = /* @__PURE__ */ new Date()) => {
+  const e = i(t);
+  return {
+    fulfillment: "pickup",
+    start_date: e,
+    start_time: u[3] ?? "09:30",
+    end_date: e,
+    end_time: u.at(-1) ?? "18:00",
+    start_address: "",
+    end_address: ""
+  };
+}, M = 30, U = 15, k = 10, w = 960, y = (t) => B(t) ?? w, L = (t) => (Math.trunc(t) % 7 + 7) % 7, F = (t) => ({
+  timing: {
+    slotIntervalMinutes: M,
+    autoFillCutoffMinutes: y(t.settings.sameDayCutoff),
+    pastToleranceMinutes: U,
+    minBufferMinutes: k
+  },
+  openingHours: t.bookingEngine.shop.openingHours.map((e) => ({
+    ...e,
+    openingHours: e.openingHours.map((n) => ({
+      ...n,
+      day: L(n.day)
+    }))
+  })),
+  openingHoursOverrides: t.bookingEngine.shop.openingHoursOverrides ?? [],
+  timeZone: t.bookingEngine.shop.timeZone
+}), C = (t, e = /* @__PURE__ */ new Date()) => {
+  const n = F(t), r = h({
+    config: n,
+    referenceDate: e
+  });
+  return {
+    fulfillment: "pickup",
+    start_date: i(r.startDate),
+    start_time: r.startTime,
+    end_date: i(r.endDate),
+    end_time: r.endTime,
+    start_address: "",
+    end_address: ""
+  };
+}, a = (t, e, n) => {
+  const r = t.get(e);
+  return r == null || r.trim() === "" ? n : r;
+}, K = (t, e) => {
+  const n = { ...I(), ...e }, r = t.get("fulfillment") === "delivery" ? "delivery" : t.get("fulfillment") === "pickup" ? "pickup" : n.fulfillment, s = a(t, "start_date", n.start_date), o = a(t, "start_time", n.start_time), _ = a(t, "end_date", n.end_date), f = a(t, "end_time", n.end_time), S = a(t, "start_address", n.start_address), g = a(t, "end_address", n.end_address);
+  return {
+    fulfillment: r,
+    start_date: s,
+    start_time: o,
+    end_date: _,
+    end_time: f,
+    start_address: S,
+    end_address: g
+  };
+}, N = (t, e) => {
+  const n = new URLSearchParams(t), r = (s, o) => {
+    if (o != null) {
+      if (o.trim() === "") {
+        n.delete(s);
+        return;
+      }
+      n.set(s, o);
+    }
+  };
+  return r("fulfillment", e.fulfillment), r("start_date", e.start_date), r("start_time", e.start_time), r("end_date", e.end_date), r("end_time", e.end_time), r("start_address", e.start_address), r("end_address", e.end_address), n;
+}, d = (t) => {
+  const e = new URLSearchParams();
+  for (const n of E) {
+    const r = t.get(n);
+    if (r == null) continue;
+    const s = r.trim();
+    s.length !== 0 && e.set(n, s);
+  }
+  return e;
+}, c = () => {
+  if (typeof window > "u")
+    return null;
+  try {
+    return window.sessionStorage;
+  } catch {
+    return null;
+  }
+}, O = (t) => t instanceof URLSearchParams ? d(t) : N(new URLSearchParams(), t), m = (t) => {
+  const e = t?.trim() ?? "";
+  return e ? `${P}${e}` : "";
+}, l = (t, e) => {
+  const n = m(e);
+  if (!n || !t)
+    return new URLSearchParams();
+  try {
+    const r = t.getItem(n);
+    return r ? d(new URLSearchParams(r)) : new URLSearchParams();
+  } catch {
+    return new URLSearchParams();
+  }
+}, R = (t, e, n) => {
+  const r = m(e);
+  if (!r || !t)
+    return;
+  const s = O(n).toString();
+  try {
+    if (!s) {
+      t.removeItem(r);
+      return;
+    }
+    t.setItem(r, s);
+  } catch {
+  }
+}, z = (t) => l(c(), t), x = (t, e) => {
+  R(c(), t, e);
+}, $ = (t, e) => {
+  const n = d(t);
+  return n.toString() ? n : l(e?.storage, e?.storeSlug);
+}, G = (t, e) => $(t, {
+  storage: c(),
+  storeSlug: e
+}), A = (t) => {
+  const e = /* @__PURE__ */ new Date(`${t.start_date}T${t.start_time}:00`), n = /* @__PURE__ */ new Date(`${t.end_date}T${t.end_time}:00`);
+  return Number.isNaN(e.getTime()) || Number.isNaN(n.getTime()) ? 0 : Math.max(0, p(n, e));
+}, V = (t) => {
+  const e = A(t), n = Math.floor(e / 60), r = e % 60;
+  return r === 0 ? { hours: n, minutes: r, label: `${n}h` } : { hours: n, minutes: r, label: `${n}h${String(r).padStart(2, "0")}` };
+};
+export {
+  E as BOOKING_SEARCH_KEYS,
+  u as TIME_OPTIONS,
+  N as applyBookingParamsToSearch,
+  F as createBookingPeriodConfigFromStorefrontConfiguration,
+  V as getBookingDurationLabel,
+  A as getBookingDurationMinutes,
+  K as getBookingParamsFromSearch,
+  m as getBookingSessionStorageKey,
+  I as getDefaultBookingParams,
+  C as getDefaultBookingParamsForStorefrontConfiguration,
+  d as pickBookingSearchParams,
+  z as readBookingSearchParamsFromSessionStorage,
+  l as readBookingSearchParamsFromStorage,
+  $ as resolveBookingSearchParams,
+  G as resolveBookingSearchParamsFromSessionStorage,
+  x as writeBookingSearchParamsToSessionStorage,
+  R as writeBookingSearchParamsToStorage
+};

package/dist/lib/cart.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+export type StorefrontCartItem = {
+    key: string;
+    kind: "bike" | "e-bike" | "accessory";
+    productId: string;
+    productVariantId?: string;
+    quantity: number;
+};
+type StorefrontCartContextValue = {
+    items: StorefrontCartItem[];
+    itemCount: number;
+    addItem: (item: Omit<StorefrontCartItem, "key"> & {
+        key?: string;
+    }) => void;
+    setQuantity: (key: string, quantity: number) => void;
+    removeItem: (key: string) => void;
+    clear: () => void;
+};
+export declare function StorefrontCartProvider({ storeSlug, children }: {
+    storeSlug: string;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const useStorefrontCart: () => StorefrontCartContextValue;
+export {};
+//# sourceMappingURL=cart.d.ts.map

package/dist/lib/cart.js

@@ -0,0 +1,87 @@
+import { jsx as q } from "react/jsx-runtime";
+import { createContext as v, useContext as M, useState as w, useEffect as C, useCallback as I, useMemo as h } from "react";
+const g = v(void 0), V = "loczer.storefront.cart.v4", b = (r) => {
+  const i = r.productVariantId ? `variant:${r.productVariantId}` : "product";
+  return `${r.kind}:${r.productId}:${i}`.toLowerCase();
+}, $ = (r) => {
+  if (!r) return { items: [] };
+  try {
+    const i = JSON.parse(r);
+    return { items: (Array.isArray(i.items) ? i.items : []).map((c) => {
+      const t = c ?? {}, s = t.kind === "accessory" ? "accessory" : t.kind === "e-bike" ? "e-bike" : t.kind === "bike" ? "bike" : null, m = typeof t.productId == "string" ? t.productId.trim() : "", f = typeof t.productVariantId == "string" ? t.productVariantId.trim() : "", y = typeof t.quantity == "number" ? Math.floor(t.quantity) : 0;
+      if (!s || m.length === 0 || y <= 0) return null;
+      const p = {
+        kind: s,
+        productId: m,
+        ...f ? { productVariantId: f } : {},
+        quantity: y
+      };
+      return { key: b(p), ...p };
+    }).filter((c) => c !== null) };
+  } catch {
+    return { items: [] };
+  }
+};
+function K({ storeSlug: r, children: i }) {
+  const u = `${V}.${r || "unknown"}`, [k, c] = w(!1), [t, s] = w({ items: [] });
+  C(() => {
+    if (typeof window > "u") return;
+    const e = $(window.localStorage.getItem(u));
+    s((o) => !k && o.items.length > 0 ? o : e), c(!0);
+  }, [u]), C(() => {
+    typeof window > "u" || k && window.localStorage.setItem(u, JSON.stringify(t));
+  }, [k, t, u]);
+  const m = I((e) => {
+    s((o) => {
+      const n = e.key?.trim() ? e.key.trim().toLowerCase() : b(e), l = Math.max(1, Math.floor(e.quantity));
+      return o.items.find((d) => d.key === n) ? {
+        items: o.items.map(
+          (d) => d.key === n ? { ...d, quantity: d.quantity + l } : d
+        )
+      } : {
+        items: [
+          ...o.items,
+          {
+            key: n,
+            kind: e.kind,
+            productId: e.productId,
+            productVariantId: e.productVariantId,
+            quantity: l
+          }
+        ]
+      };
+    });
+  }, []), f = I((e, o) => {
+    s((n) => {
+      const l = Math.max(0, Math.floor(o));
+      return l <= 0 ? { items: n.items.filter((a) => a.key !== e) } : {
+        items: n.items.map((a) => a.key === e ? { ...a, quantity: l } : a)
+      };
+    });
+  }, []), y = I((e) => {
+    s((o) => ({ items: o.items.filter((n) => n.key !== e) }));
+  }, []), p = I(() => {
+    s({ items: [] });
+  }, []), S = h(() => t.items.reduce((e, o) => e + o.quantity, 0), [t.items]), x = h(
+    () => ({
+      items: t.items,
+      itemCount: S,
+      addItem: m,
+      setQuantity: f,
+      removeItem: y,
+      clear: p
+    }),
+    [m, p, S, y, f, t.items]
+  );
+  return /* @__PURE__ */ q(g.Provider, { value: x, children: i });
+}
+const P = () => {
+  const r = M(g);
+  if (!r)
+    throw new Error("useStorefrontCart must be used within StorefrontCartProvider");
+  return r;
+};
+export {
+  K as StorefrontCartProvider,
+  P as useStorefrontCart
+};

package/dist/lib/cartSummary.d.ts

@@ -0,0 +1,31 @@
+import { StorefrontCartItem } from './cart';
+import { StorefrontAvailabilityIssue } from './storefrontAvailability';
+import { StorefrontProductsCollections } from './products';
+export type StorefrontCartSummaryLine = StorefrontCartItem & {
+    checkoutProductId: string;
+    productName: string;
+    productWarning?: string;
+    productVariantLabel?: string;
+    productVariantDescription?: string;
+    productVariantIsSize: boolean;
+    unitPriceMinor: number;
+    lineTotalMinor: number;
+    estimatedLineTotalMinor?: number;
+    availabilityStatus?: "AVAILABLE" | "LOW_STOCK" | "OUT_OF_STOCK";
+    insufficientCapacity?: boolean;
+    availabilityIssue?: StorefrontAvailabilityIssue;
+};
+export type StorefrontCartSummary = {
+    lines: StorefrontCartSummaryLine[];
+    totalPerDayMinor: number;
+    estimatedDays?: number;
+    estimatedTotalMinor?: number;
+};
+export declare const buildStorefrontCartSummary: (params: {
+    items: StorefrontCartItem[];
+    language: string;
+    fallbackLanguage?: string;
+    products: StorefrontProductsCollections;
+    estimatedDays?: number;
+}) => StorefrontCartSummary;
+//# sourceMappingURL=cartSummary.d.ts.map