@loczer/storefront-sdk 0.147.0 → 0.149.0

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

@@ -0,0 +1,273 @@
+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))
+    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 { dateString: void 0, weekday: void 0 };
+  const t = k(e);
+  let s;
+  try {
+    s = W(t);
+  } 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({
+    dateString: r
+  }), o = typeof l == "number" ? l : n.days.find((d) => !d.isClosed && d.openingSlots.length)?.day ?? t.defaultWeekday, a = t.getIntervalsForWeekday(o, {
+    dateString: r
+  });
+  if (i?.fillGaps) {
+    if (!a.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,
+        isExtra: !1
+      });
+    }
+    return m;
+  }
+  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,
+          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
+  }));
+  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}`,
+        isExtra: !0,
+        extraAmount: a.extraAmount
+      };
+      continue;
+    }
+    o.push({
+      value: g,
+      label: `${g} - ${m}`,
+      startMinutes: a.startMinutes,
+      endMinutes: c,
+      isExtra: !0,
+      extraAmount: a.extraAmount
+    });
+  }
+  return o.sort((a, c) => a.startMinutes - c.startMinutes);
+}, V = (e, t) => {
+  if (e.length <= 1)
+    return e;
+  const s = [];
+  let i = 0;
+  for (; i < e.length; ) {
+    const r = e[i];
+    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);
+      s.push({
+        ...r,
+        value: c,
+        label: `${c} - ${d}`,
+        startMinutes: o,
+        endMinutes: a,
+        isDisabled: !0,
+        disabledReason: N
+      }), i = n;
+      continue;
+    }
+    s.push(r), i += 1;
+  }
+  return s;
+}, h = ({
+  slots: e,
+  baselineSlots: t,
+  slotInterval: s
+}) => {
+  const i = new Set(e.map((n) => n.startMinutes)), r = t.filter((n) => !i.has(n.startMinutes)).map((n) => ({
+    ...n,
+    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,
+  {
+    getNormalizedOpeningHours: t.getSeasonNormalizedOpeningHours,
+    getIntervalsForWeekday: t.getSeasonIntervalsForWeekday,
+    defaultWeekday: t.defaultSeasonWeekday
+  },
+  t.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
+} = {}) => {
+  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
+  });
+  return {
+    startTimeSlots: h({
+      slots: f,
+      baselineSlots: g,
+      slotInterval: i
+    }),
+    endTimeSlots: h({
+      slots: b,
+      baselineSlots: g,
+      slotInterval: i
+    })
+  };
+}, G = async (e, {
+  date: t
+} = {}) => j(e, { date: t });
+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
+};

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

@@ -0,0 +1,147 @@
+export type Weekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export type StoreOpeningSlot = {
+    start: string;
+    end: string;
+};
+export type StoreOpeningDay = {
+    day: Weekday;
+    openingSlots: StoreOpeningSlot[];
+};
+export type StoreOpeningOverride = {
+    date: string;
+    openingSlots: StoreOpeningSlot[];
+};
+export type StoreOpeningSeason = {
+    name?: string;
+    startDate: string;
+    endDate: string;
+    openingHours: StoreOpeningDay[];
+};
+export type StoreOpeningHours = StoreOpeningSeason[];
+export type BookingTimingConfig = {
+    slotIntervalMinutes: number;
+    autoFillCutoffMinutes: number;
+    pastToleranceMinutes: number;
+    minBufferMinutes: number;
+};
+export declare const minutesToTimeString: (minutes: number) => string;
+export declare const parseTimeToMinutes: (time?: string | null) => number | null;
+export type NormalizedOpeningSlot = {
+    startMinutes: number;
+    endMinutes: number;
+    startLabel: string;
+    endLabel: string;
+    rangeLabel: string;
+};
+export type NormalizedWorkingDay = {
+    day: Weekday;
+    isClosed: boolean;
+    openingSlots: NormalizedOpeningSlot[];
+    openingMinutes: number | null;
+    closingMinutes: number | null;
+    summaryLabel: string | null;
+};
+export type NormalizedOpeningHours = {
+    days: NormalizedWorkingDay[];
+    defaultOpeningMinutes: number;
+    defaultClosingMinutes: number;
+    defaultOpeningLabel: string;
+    defaultClosingLabel: string;
+    defaultSummaryLabel: string;
+    season: {
+        name?: string;
+        startDate: string;
+        endDate: string;
+    } | null;
+};
+export type NormalizeOpeningHoursOptions = {
+    referenceDate?: Date | string | null;
+};
+export declare const normalizeOpeningHours: (openingHours: StoreOpeningHours, openingHoursOverrides: StoreOpeningOverride[], options?: NormalizeOpeningHoursOptions) => NormalizedOpeningHours;
+export type BookingPeriodConfig = {
+    timing: BookingTimingConfig;
+    openingHours: StoreOpeningHours;
+    openingHoursOverrides: StoreOpeningOverride[];
+    timeZone: string;
+};
+export type BookingPeriodConstants = ReturnType<typeof createBookingPeriodConstants>;
+export declare const createBookingPeriodConstants: (config: BookingPeriodConfig) => {
+    timeZone: string;
+    slotIntervalMinutes: number;
+    autoFillCutoffMinutes: number;
+    pastToleranceMinutes: number;
+    minBufferMinutes: number;
+    defaultOpeningMinutes: number;
+    defaultClosingMinutes: number;
+    defaultOpeningLabel: string;
+    defaultClosingLabel: string;
+    defaultSummaryLabel: string;
+    defaultWeekday: Weekday;
+    defaultSeasonWeekday: Weekday;
+    defaultStartMinutes: number;
+    defaultStartTime: string;
+    defaultEndMinutes: number;
+    defaultEndTime: string;
+    getDayHours: (weekday: Weekday, options?: {
+        dateString?: string;
+    }) => NormalizedWorkingDay | undefined;
+    getIntervalsForWeekday: (weekday: Weekday, options?: {
+        dateString?: string;
+    }) => NormalizedOpeningSlot[];
+    getSeasonDayHours: (weekday: Weekday, options?: {
+        dateString?: string;
+    }) => NormalizedWorkingDay | undefined;
+    getSeasonIntervalsForWeekday: (weekday: Weekday, options?: {
+        dateString?: string;
+    }) => NormalizedOpeningSlot[];
+    getFirstStartMinutesForWeekday: (weekday: Weekday, fromMinutes?: number | null, options?: {
+        dateString?: string;
+    }) => number | null;
+    getLastStartMinutesForWeekday: (weekday: Weekday, options?: {
+        dateString?: string;
+    }) => number | null;
+    isValidStartMinutesForWeekday: (weekday: Weekday, minutes: number | null, options?: {
+        dateString?: string;
+    }) => boolean;
+    getNormalizedOpeningHours: (options?: {
+        dateString?: string;
+    }) => NormalizedOpeningHours;
+    getSeasonNormalizedOpeningHours: (options?: {
+        dateString?: string;
+    }) => NormalizedOpeningHours;
+};
+export interface DefaultBookingPeriod {
+    startDate: Date;
+    startTime: string;
+    endDate: Date;
+    endTime: string;
+}
+export interface DefaultBookingPeriodOptions {
+    referenceDate?: Date;
+    config: BookingPeriodConfig;
+}
+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 interface BookingPeriodInput {
+    startDate?: Date | string | null;
+    startTime?: string | null;
+    endDate?: Date | string | null;
+    endTime?: string | null;
+}
+export interface BookingPeriodAdjustmentResult {
+    startDateString?: string;
+    startTime?: string | null;
+    endDateString?: string;
+    endTime?: string | null;
+    wasAdjusted: boolean;
+    adjustmentReason?: "start_date_in_past" | "start_time_in_past";
+    shouldResetEnd: boolean;
+}
+export interface BookingPeriodAdjustmentOptions {
+    referenceDate?: Date;
+    toleranceMinutes?: number;
+    config: BookingPeriodConfig;
+}
+export declare const adjustBookingPeriod: (period: BookingPeriodInput, options: BookingPeriodAdjustmentOptions) => BookingPeriodAdjustmentResult;
+//# sourceMappingURL=booking-period.d.ts.map