@loczer/storefront-sdk 0.150.0 → 0.152.0

package/dist/lib/booking-period-time-slots.d.ts

@@ -13,37 +13,6 @@ export type TimeSlot = TimeSlotBase & {
     isDisabled: boolean;
     disabledReason?: string;
 };
-export interface DisabledTimeSlotRule {
-    startMinutes?: number;
-    endMinutes?: number;
-    values?: string[];
-    reason?: string;
-    dates?: string[];
-    weekdays?: number[];
-}
-export interface DisabledTimeSlotRuleContext {
-    date?: string;
-    slotInterval: number;
-}
-export declare const staticDisabledTimeSlotRules: DisabledTimeSlotRule[];
-export declare const getDisabledTimeSlotRulesSync: (_context: DisabledTimeSlotRuleContext) => DisabledTimeSlotRule[];
-export declare const getDisabledTimeSlotRules: (context: DisabledTimeSlotRuleContext) => Promise<DisabledTimeSlotRule[]>;
-export interface ExtraTimeSlotRule {
-    startMinutes: number;
-    endMinutes?: number;
-    extraAmount: number;
-    dates?: string[];
-    weekdays?: number[];
-    journeyTypes?: JourneyType[];
-}
-export interface ExtraTimeSlotRuleContext {
-    date?: string;
-    slotInterval: number;
-    journeyType?: JourneyType;
-}
-export declare const staticExtraTimeSlotRules: ExtraTimeSlotRule[];
-export declare const getExtraTimeSlotRulesSync: (_context: ExtraTimeSlotRuleContext) => ExtraTimeSlotRule[];
-export declare const getExtraTimeSlotRules: (context: ExtraTimeSlotRuleContext) => Promise<ExtraTimeSlotRule[]>;
 export declare const toBusinessDateString: (date: string) => string;
 export declare const getBookingPeriodTimeSlotsSync: (bookingPeriodConfig: BookingPeriodConfig, { date, }?: {
     date?: string;

package/dist/lib/booking-period-time-slots.js

@@ -1,273 +1,174 @@
-import * as z from "./booking-period.js";
-const { businessDateStringToDate: A, createBookingPeriodConstants: B, minutesToTimeString: y } = z, C = [], E = (e) => [], H = async (e) => E(), L = [
-  {
-    startMinutes: 1140,
-    extraAmount: 1e3,
-    journeyTypes: ["end"]
-  },
-  {
-    startMinutes: 1170,
-    extraAmount: 2e3,
-    journeyTypes: ["end"]
-  }
-], w = (e) => [], P = async (e) => w(), M = /^\d{4}-\d{2}-\d{2}$/, N = "closed", W = (e) => {
-  if (!M.test(e))
+import * as $ from "./booking-period.js";
+const { businessDateStringToDate: A, createBookingPeriodConstants: W, minutesToTimeString: g } = $, p = /^\d{4}-\d{2}-\d{2}$/, w = "closed", D = (t) => {
+  if (!p.test(t))
     throw new Error("Invalid time slot date parameter format");
-  return e;
-}, k = (e) => M.test(e) ? e : /^\d{8}$/.test(e) ? `${e.slice(0, 4)}-${e.slice(4, 6)}-${e.slice(6, 8)}` : e, D = (e) => {
-  if (!e)
+  return t;
+}, v = (t) => p.test(t) ? t : /^\d{8}$/.test(t) ? `${t.slice(0, 4)}-${t.slice(4, 6)}-${t.slice(6, 8)}` : t, z = (t) => {
+  if (!t)
     return { dateString: void 0, weekday: void 0 };
-  const t = k(e);
+  const e = v(t);
   let s;
   try {
-    s = W(t);
+    s = D(e);
   } catch {
     return { dateString: void 0, weekday: void 0 };
   }
-  const i = A(s);
-  return Number.isNaN(i.getTime()) ? { dateString: void 0, weekday: void 0 } : { dateString: s, weekday: (i.getDay() + 6) % 7 };
-}, v = (e, t, s, i) => {
-  const { dateString: r, weekday: l } = D(e), n = t.getNormalizedOpeningHours({
+  const n = A(s);
+  return Number.isNaN(n.getTime()) ? { dateString: void 0, weekday: void 0 } : { dateString: s, weekday: (n.getDay() + 6) % 7 };
+}, E = (t, e, s, n) => {
+  const { dateString: r, weekday: o } = z(t), a = e.getNormalizedOpeningHours({
     dateString: r
-  }), o = typeof l == "number" ? l : n.days.find((d) => !d.isClosed && d.openingSlots.length)?.day ?? t.defaultWeekday, a = t.getIntervalsForWeekday(o, {
+  }), l = typeof o == "number" ? o : a.days.find((c) => !c.isClosed && c.openingSlots.length)?.day ?? e.defaultWeekday, d = e.getIntervalsForWeekday(l, {
     dateString: r
   });
-  if (i?.fillGaps) {
-    if (!a.length)
+  if (n?.fillGaps) {
+    if (!d.length)
       return [];
-    const d = a.reduce((u, S) => S.startMinutes < u.startMinutes ? S : u), g = a.reduce((u, S) => S.endMinutes > u.endMinutes ? S : u), m = [], f = Math.ceil(d.startMinutes / s) * s, b = Math.max(f, g.endMinutes - s);
-    if (b < f)
-      return m;
-    for (let u = f; u <= b; u += s) {
-      const S = y(u), T = u + s, $ = y(T);
-      m.push({
-        value: S,
-        label: `${S} - ${$}`,
-        startMinutes: u,
-        endMinutes: T,
+    const c = d.reduce((i, u) => u.startMinutes < i.startMinutes ? u : i), x = d.reduce((i, u) => u.endMinutes > i.endMinutes ? u : i), S = [], m = Math.ceil(c.startMinutes / s) * s, M = Math.max(m, x.endMinutes - s);
+    if (M < m)
+      return S;
+    for (let i = m; i <= M; i += s) {
+      const u = g(i), b = i + s, T = g(b);
+      S.push({
+        value: u,
+        label: `${u} - ${T}`,
+        startMinutes: i,
+        endMinutes: b,
         isExtra: !1
       });
     }
-    return m;
+    return S;
   }
-  const c = [];
-  for (const d of a) {
-    const g = Math.ceil(d.startMinutes / s) * s, m = d.endMinutes - s;
-    if (!(m < g))
-      for (let f = g; f <= m; f += s) {
-        const b = y(f), u = f + s, S = y(u);
-        c.push({
-          value: b,
-          label: `${b} - ${S}`,
-          startMinutes: f,
-          endMinutes: u,
+  const f = [];
+  for (const c of d) {
+    const x = Math.ceil(c.startMinutes / s) * s, S = c.endMinutes - s;
+    if (!(S < x))
+      for (let m = x; m <= S; m += s) {
+        const M = g(m), i = m + s, u = g(i);
+        f.push({
+          value: M,
+          label: `${M} - ${u}`,
+          startMinutes: m,
+          endMinutes: i,
           isExtra: !1
         });
       }
   }
-  return c;
-}, O = (e, t, s) => {
-  if (t.dates?.length && (!s.dateString || !t.dates.some((n) => {
-    const o = k(n);
-    return M.test(o) ? o === s.dateString : !1;
-  })) || t.weekdays?.length && (s.weekday == null || !t.weekdays.includes(s.weekday)))
-    return !1;
-  const i = t.values?.includes(e.value) ?? !1;
-  let r = !1;
-  if (typeof t.startMinutes == "number") {
-    const l = typeof t.endMinutes == "number" ? t.endMinutes : t.startMinutes + s.slotInterval;
-    r = e.startMinutes >= t.startMinutes && e.startMinutes < l;
-  }
-  return !!(t.values?.length && i || typeof t.startMinutes == "number" && r);
-}, F = (e, t) => !(e.dates?.length && (!t.dateString || !e.dates.some((i) => {
-  const r = k(i);
-  return M.test(r) ? r === t.dateString : !1;
-})) || e.weekdays?.length && (t.weekday == null || !e.weekdays.includes(t.weekday)) || e.journeyTypes?.length && (!t.journeyType || !e.journeyTypes.includes(t.journeyType))), x = ({
-  slots: e,
-  rules: t,
-  date: s,
-  slotInterval: i
-}) => {
-  if (!t.length)
-    return e.map((n) => ({
-      ...n,
-      isDisabled: !1
-    }));
-  const { dateString: r, weekday: l } = D(s);
-  return e.map((n) => {
-    const o = t.find(
-      (a) => O(n, a, {
-        dateString: r,
-        weekday: l,
-        slotInterval: i
-      })
-    );
-    return o ? {
-      ...n,
-      isDisabled: !0,
-      disabledReason: o.reason
-    } : {
-      ...n,
-      isDisabled: !1
-    };
-  });
-}, I = ({
-  slots: e,
-  rules: t,
-  date: s,
-  slotInterval: i,
-  journeyType: r
-}) => {
-  if (!t.length)
-    return e.map((a) => ({
-      ...a
-    }));
-  const { dateString: l, weekday: n } = D(s), o = e.map((a) => ({
-    ...a
+  return f;
+}, N = (t, e, s, n) => {
+  if (n !== "end" || t.length === 0 || e.length === 0)
+    return [];
+  const r = e.reduce(
+    (o, a) => Math.max(o, a.endMinutes),
+    0
+  );
+  return [...t].sort((o, a) => o.minutesAfterClose - a.minutesAfterClose).map((o) => ({
+    startMinutes: Math.max(r, r + o.minutesAfterClose - s),
+    endMinutes: r + o.minutesAfterClose,
+    extraAmount: o.extraAmount
   }));
-  for (const a of t) {
-    if (!F(a, {
-      dateString: l,
-      weekday: n,
-      journeyType: r
-    }))
-      continue;
-    const c = typeof a.endMinutes == "number" ? a.endMinutes : a.startMinutes + i, d = o.findIndex((f) => f.startMinutes === a.startMinutes), g = y(a.startMinutes), m = y(c);
-    if (d >= 0) {
-      o[d] = {
-        ...o[d],
-        endMinutes: c,
-        label: `${g} - ${m}`,
+}, B = (t, e) => {
+  const s = t.map((n) => ({
+    ...n
+  }));
+  for (const n of e) {
+    const r = g(n.startMinutes), o = g(n.endMinutes), a = s.findIndex((l) => l.startMinutes === n.startMinutes);
+    if (a >= 0) {
+      s[a] = {
+        ...s[a],
+        endMinutes: n.endMinutes,
+        label: `${r} - ${o}`,
         isExtra: !0,
-        extraAmount: a.extraAmount
+        extraAmount: n.extraAmount
       };
       continue;
     }
-    o.push({
-      value: g,
-      label: `${g} - ${m}`,
-      startMinutes: a.startMinutes,
-      endMinutes: c,
+    s.push({
+      value: r,
+      label: `${r} - ${o}`,
+      startMinutes: n.startMinutes,
+      endMinutes: n.endMinutes,
       isExtra: !0,
-      extraAmount: a.extraAmount
+      extraAmount: n.extraAmount
     });
   }
-  return o.sort((a, c) => a.startMinutes - c.startMinutes);
-}, V = (e, t) => {
-  if (e.length <= 1)
-    return e;
+  return s.sort((n, r) => n.startMinutes - r.startMinutes);
+}, C = (t, e) => {
+  if (t.length <= 1)
+    return t;
   const s = [];
-  let i = 0;
-  for (; i < e.length; ) {
-    const r = e[i];
+  let n = 0;
+  for (; n < t.length; ) {
+    const r = t[n];
     if (r.isDisabled && !r.isExtra && r.disabledReason == null) {
-      let l = r, n = i + 1;
-      for (; n < e.length && e[n].isDisabled && !e[n].isExtra && e[n].disabledReason == null && e[n].startMinutes === l.startMinutes + t; )
-        l = e[n], n += 1;
-      const o = r.startMinutes, a = l.endMinutes, c = y(o), d = y(a);
+      let o = r, a = n + 1;
+      for (; a < t.length && t[a].isDisabled && !t[a].isExtra && t[a].disabledReason == null && t[a].startMinutes === o.startMinutes + e; )
+        o = t[a], a += 1;
+      const l = r.startMinutes, d = o.endMinutes, f = g(l), c = g(d);
       s.push({
         ...r,
-        value: c,
-        label: `${c} - ${d}`,
-        startMinutes: o,
-        endMinutes: a,
+        value: f,
+        label: `${f} - ${c}`,
+        startMinutes: l,
+        endMinutes: d,
         isDisabled: !0,
-        disabledReason: N
-      }), i = n;
+        disabledReason: w
+      }), n = a;
       continue;
     }
-    s.push(r), i += 1;
+    s.push(r), n += 1;
   }
   return s;
 }, h = ({
-  slots: e,
-  baselineSlots: t,
+  slots: t,
+  baselineSlots: e,
   slotInterval: s
 }) => {
-  const i = new Set(e.map((n) => n.startMinutes)), r = t.filter((n) => !i.has(n.startMinutes)).map((n) => ({
-    ...n,
+  const n = new Set(t.map((a) => a.startMinutes)), r = e.filter((a) => !n.has(a.startMinutes)).map((a) => ({
+    ...a,
     isDisabled: !0
-  })), l = [...e, ...r].sort((n, o) => n.startMinutes - o.startMinutes);
-  return V(l, s);
-}, _ = (e, t) => v(e, {
-  getNormalizedOpeningHours: t.getNormalizedOpeningHours,
-  getIntervalsForWeekday: t.getIntervalsForWeekday,
-  defaultWeekday: t.defaultWeekday
-}, t.slotIntervalMinutes), R = (e, t) => v(
-  e,
+  })), o = [...t, ...r].sort((a, l) => a.startMinutes - l.startMinutes);
+  return C(o, s);
+}, O = (t, e) => E(t, {
+  getNormalizedOpeningHours: e.getNormalizedOpeningHours,
+  getIntervalsForWeekday: e.getIntervalsForWeekday,
+  defaultWeekday: e.defaultWeekday
+}, e.slotIntervalMinutes), F = (t, e) => E(
+  t,
   {
-    getNormalizedOpeningHours: t.getSeasonNormalizedOpeningHours,
-    getIntervalsForWeekday: t.getSeasonIntervalsForWeekday,
-    defaultWeekday: t.defaultSeasonWeekday
+    getNormalizedOpeningHours: e.getSeasonNormalizedOpeningHours,
+    getIntervalsForWeekday: e.getSeasonIntervalsForWeekday,
+    defaultWeekday: e.defaultSeasonWeekday
   },
-  t.slotIntervalMinutes,
+  e.slotIntervalMinutes,
   { fillGaps: !0 }
-), p = (e, t, s) => {
-  const i = t.slotIntervalMinutes, r = _(e, t), l = w();
-  return I({
-    slots: r,
-    rules: l,
-    date: e,
-    slotInterval: i,
-    journeyType: s
-  });
-}, j = (e, {
-  date: t
+), y = (t, e, s, n) => {
+  const r = e.slotIntervalMinutes, o = O(t, e), a = N(n, o, r, s);
+  return B(o, a);
+}, k = (t) => t.map((e) => ({
+  ...e,
+  isDisabled: !1
+})), I = (t, {
+  date: e
 } = {}) => {
-  const s = B(e), i = s.slotIntervalMinutes, r = p(void 0, s, "start"), l = p(void 0, s, "end"), n = R(void 0, s), o = {
-    startTimeSlots: h({
-      slots: r.map((u) => ({
-        ...u,
-        isDisabled: !1
-      })),
-      baselineSlots: n,
-      slotInterval: i
-    }),
-    endTimeSlots: h({
-      slots: l.map((u) => ({
-        ...u,
-        isDisabled: !1
-      })),
-      baselineSlots: n,
-      slotInterval: i
-    })
-  };
-  if (!t || !M.test(t))
-    return o;
-  const a = W(t), c = p(a, s, "start"), d = p(a, s, "end"), g = R(a, s), m = E(), f = x({
-    slots: c,
-    rules: m,
-    date: a,
-    slotInterval: i
-  }), b = x({
-    slots: d,
-    rules: m,
-    date: a,
-    slotInterval: i
-  });
+  const s = W(t), n = s.slotIntervalMinutes, r = t.extraTimeSlots ?? [], o = e && p.test(e) ? D(e) : void 0, a = y(o, s, "start", r), l = y(o, s, "end", r), d = F(o, s);
   return {
     startTimeSlots: h({
-      slots: f,
-      baselineSlots: g,
-      slotInterval: i
+      slots: k(a),
+      baselineSlots: d,
+      slotInterval: n
     }),
     endTimeSlots: h({
-      slots: b,
-      baselineSlots: g,
-      slotInterval: i
+      slots: k(l),
+      baselineSlots: d,
+      slotInterval: n
     })
   };
-}, G = async (e, {
-  date: t
-} = {}) => j(e, { date: t });
+}, R = async (t, {
+  date: e
+} = {}) => I(t, { date: e });
 export {
-  G as getBookingPeriodTimeSlots,
-  j as getBookingPeriodTimeSlotsSync,
-  H as getDisabledTimeSlotRules,
-  E as getDisabledTimeSlotRulesSync,
-  P as getExtraTimeSlotRules,
-  w as getExtraTimeSlotRulesSync,
-  C as staticDisabledTimeSlotRules,
-  L as staticExtraTimeSlotRules,
-  W as toBusinessDateString
+  R as getBookingPeriodTimeSlots,
+  I as getBookingPeriodTimeSlotsSync,
+  D as toBusinessDateString
 };

package/dist/lib/booking-period.d.ts

@@ -58,11 +58,16 @@ export type NormalizeOpeningHoursOptions = {
     referenceDate?: Date | string | null;
 };
 export declare const normalizeOpeningHours: (openingHours: StoreOpeningHours, openingHoursOverrides: StoreOpeningOverride[], options?: NormalizeOpeningHoursOptions) => NormalizedOpeningHours;
+export type BookingPeriodExtraTimeSlotRule = {
+    minutesAfterClose: number;
+    extraAmount: number;
+};
 export type BookingPeriodConfig = {
     timing: BookingTimingConfig;
     openingHours: StoreOpeningHours;
     openingHoursOverrides: StoreOpeningOverride[];
     timeZone: string;
+    extraTimeSlots?: BookingPeriodExtraTimeSlotRule[];
 };
 export type BookingPeriodConstants = ReturnType<typeof createBookingPeriodConstants>;
 export declare const createBookingPeriodConstants: (config: BookingPeriodConfig) => {
@@ -110,6 +115,14 @@ export declare const createBookingPeriodConstants: (config: BookingPeriodConfig)
         dateString?: string;
     }) => NormalizedOpeningHours;
 };
+export declare const instantToBusinessDateTimeParts: (date: Date, timeZone: string) => {
+    dateString: string;
+    timeString: string;
+    minutesFromMidnight: number;
+} | undefined;
+export declare const normalizeBusinessDateString: (dateString: string) => string | undefined;
+export declare const calendarDateToBusinessDateString: (date: Date | null | undefined) => string | undefined;
+export declare const instantToBusinessDateString: (date: Date, timeZone: string) => string | undefined;
 export interface DefaultBookingPeriod {
     startDate: Date;
     startTime: string;
@@ -123,6 +136,7 @@ export interface DefaultBookingPeriodOptions {
 export declare const getDefaultBookingPeriod: (options: DefaultBookingPeriodOptions) => DefaultBookingPeriod;
 export declare const dateToBusinessDateString: (date: Date | string | null | undefined, timeZone: string) => string | undefined;
 export declare const businessDateStringToDate: (dateString: string) => Date;
+export declare const getWeekdayFromDateString: (dateString: string) => Weekday;
 export interface BookingPeriodInput {
     startDate?: Date | string | null;
     startTime?: string | null;