@loczer/storefront-sdk 0.150.0 → 0.152.0

package/dist/StorefrontProvider.d.ts

@@ -97,6 +97,10 @@ export declare const loader: ({ ctx, params }: LoaderArgs) => Promise<{
                         end: string;
                     }[];
                 }[] | undefined;
+                extraTimeSlots?: {
+                    minutesAfterClose: number;
+                    extraAmount: number;
+                }[] | undefined;
             };
             currency: "EUR" | "USD" | "GBP" | "CHF";
             checkout: {
@@ -339,6 +343,10 @@ declare const storefrontConfigurationSchema: z.ZodObject<{
                     end: string;
                 }[];
             }[] | undefined;
+            extraTimeSlots?: {
+                minutesAfterClose: number;
+                extraAmount: number;
+            }[] | undefined;
         };
         currency: "EUR" | "USD" | "GBP" | "CHF";
         checkout: {
@@ -403,6 +411,10 @@ declare const storefrontConfigurationSchema: z.ZodObject<{
                     end: string;
                 }[];
             }[] | undefined;
+            extraTimeSlots?: {
+                minutesAfterClose: number;
+                extraAmount: number;
+            }[] | undefined;
         };
         currency: "EUR" | "USD" | "GBP" | "CHF";
         checkout: {
@@ -768,6 +780,10 @@ export declare function useStorefrontConfig(): {
                         end: string;
                     }[];
                 }[] | undefined;
+                extraTimeSlots?: {
+                    minutesAfterClose: number;
+                    extraAmount: number;
+                }[] | undefined;
             };
             currency: "EUR" | "USD" | "GBP" | "CHF";
             checkout: {
@@ -980,6 +996,10 @@ export declare function useStorefrontConfig(): {
                         end: string;
                     }[];
                 }[] | undefined;
+                extraTimeSlots?: {
+                    minutesAfterClose: number;
+                    extraAmount: number;
+                }[] | undefined;
             };
             currency: "EUR" | "USD" | "GBP" | "CHF";
             checkout: {

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

@@ -16,14 +16,20 @@ declare namespace bookingPeriod {
         NormalizedOpeningHours,
         NormalizeOpeningHoursOptions,
         normalizeOpeningHours,
+        BookingPeriodExtraTimeSlotRule,
         BookingPeriodConfig_2 as BookingPeriodConfig,
         BookingPeriodConstants,
         createBookingPeriodConstants,
+        instantToBusinessDateTimeParts,
+        normalizeBusinessDateString,
+        calendarDateToBusinessDateString,
+        instantToBusinessDateString,
         DefaultBookingPeriod,
         DefaultBookingPeriodOptions,
         getDefaultBookingPeriod,
         dateToBusinessDateString,
         businessDateStringToDate,
+        getWeekdayFromDateString,
         BookingPeriodInput,
         BookingPeriodAdjustmentResult,
         BookingPeriodAdjustmentOptions,
@@ -54,10 +60,16 @@ declare type BookingPeriodConfig_2 = {
     openingHours: StoreOpeningHours;
     openingHoursOverrides: StoreOpeningOverride[];
     timeZone: string;
+    extraTimeSlots?: BookingPeriodExtraTimeSlotRule[];
 };
 
 declare type BookingPeriodConstants = ReturnType<typeof createBookingPeriodConstants>;
 
+declare type BookingPeriodExtraTimeSlotRule = {
+    minutesAfterClose: number;
+    extraAmount: number;
+};
+
 declare interface BookingPeriodInput {
     startDate?: Date | string | null;
     startTime?: string | null;
@@ -74,6 +86,8 @@ declare type BookingTimingConfig = {
 
 declare const businessDateStringToDate: (dateString: string) => Date;
 
+declare const calendarDateToBusinessDateString: (date: Date | null | undefined) => string | undefined;
+
 declare const createBookingPeriodConstants: (config: BookingPeriodConfig_2) => {
     timeZone: string;
     slotIntervalMinutes: number;
@@ -134,35 +148,6 @@ declare interface DefaultBookingPeriodOptions {
     config: BookingPeriodConfig_2;
 }
 
-export declare interface DisabledTimeSlotRule {
-    startMinutes?: number;
-    endMinutes?: number;
-    values?: string[];
-    reason?: string;
-    dates?: string[];
-    weekdays?: number[];
-}
-
-export declare interface DisabledTimeSlotRuleContext {
-    date?: string;
-    slotInterval: number;
-}
-
-export declare interface ExtraTimeSlotRule {
-    startMinutes: number;
-    endMinutes?: number;
-    extraAmount: number;
-    dates?: string[];
-    weekdays?: number[];
-    journeyTypes?: JourneyType[];
-}
-
-export declare interface ExtraTimeSlotRuleContext {
-    date?: string;
-    slotInterval: number;
-    journeyType?: JourneyType;
-}
-
 export declare const getBookingPeriodTimeSlots: (bookingPeriodConfig: BookingPeriodConfig, { date, }?: {
     date?: string;
 }) => Promise<{
@@ -179,18 +164,22 @@ export declare const getBookingPeriodTimeSlotsSync: (bookingPeriodConfig: Bookin
 
 declare const getDefaultBookingPeriod: (options: DefaultBookingPeriodOptions) => DefaultBookingPeriod;
 
-export declare const getDisabledTimeSlotRules: (context: DisabledTimeSlotRuleContext) => Promise<DisabledTimeSlotRule[]>;
-
-export declare const getDisabledTimeSlotRulesSync: (_context: DisabledTimeSlotRuleContext) => DisabledTimeSlotRule[];
+declare const getWeekdayFromDateString: (dateString: string) => Weekday;
 
-export declare const getExtraTimeSlotRules: (context: ExtraTimeSlotRuleContext) => Promise<ExtraTimeSlotRule[]>;
+declare const instantToBusinessDateString: (date: Date, timeZone: string) => string | undefined;
 
-export declare const getExtraTimeSlotRulesSync: (_context: ExtraTimeSlotRuleContext) => ExtraTimeSlotRule[];
+declare const instantToBusinessDateTimeParts: (date: Date, timeZone: string) => {
+    dateString: string;
+    timeString: string;
+    minutesFromMidnight: number;
+} | undefined;
 
 export declare type JourneyType = "start" | "end";
 
 declare const minutesToTimeString: (minutes: number) => string;
 
+declare const normalizeBusinessDateString: (dateString: string) => string | undefined;
+
 declare type NormalizedOpeningHours = {
     days: NormalizedWorkingDay[];
     defaultOpeningMinutes: number;
@@ -230,10 +219,6 @@ declare type NormalizeOpeningHoursOptions = {
 
 declare const parseTimeToMinutes: (time?: string | null) => number | null;
 
-export declare const staticDisabledTimeSlotRules: DisabledTimeSlotRule[];
-
-export declare const staticExtraTimeSlotRules: ExtraTimeSlotRule[];
-
 declare type StoreOpeningDay = {
     day: Weekday;
     openingSlots: StoreOpeningSlot[];

package/dist/booking-period.d.ts

@@ -21,10 +21,16 @@ export declare type BookingPeriodConfig = {
     openingHours: StoreOpeningHours;
     openingHoursOverrides: StoreOpeningOverride[];
     timeZone: string;
+    extraTimeSlots?: BookingPeriodExtraTimeSlotRule[];
 };
 
 export declare type BookingPeriodConstants = ReturnType<typeof createBookingPeriodConstants>;
 
+export declare type BookingPeriodExtraTimeSlotRule = {
+    minutesAfterClose: number;
+    extraAmount: number;
+};
+
 export declare interface BookingPeriodInput {
     startDate?: Date | string | null;
     startTime?: string | null;
@@ -41,6 +47,8 @@ export declare type BookingTimingConfig = {
 
 export declare const businessDateStringToDate: (dateString: string) => Date;
 
+export declare const calendarDateToBusinessDateString: (date: Date | null | undefined) => string | undefined;
+
 export declare const createBookingPeriodConstants: (config: BookingPeriodConfig) => {
     timeZone: string;
     slotIntervalMinutes: number;
@@ -103,8 +111,20 @@ export declare interface DefaultBookingPeriodOptions {
 
 export declare const getDefaultBookingPeriod: (options: DefaultBookingPeriodOptions) => DefaultBookingPeriod;
 
+export declare const getWeekdayFromDateString: (dateString: string) => Weekday;
+
+export declare const instantToBusinessDateString: (date: Date, timeZone: string) => string | undefined;
+
+export declare const instantToBusinessDateTimeParts: (date: Date, timeZone: string) => {
+    dateString: string;
+    timeString: string;
+    minutesFromMidnight: number;
+} | undefined;
+
 export declare const minutesToTimeString: (minutes: number) => string;
 
+export declare const normalizeBusinessDateString: (dateString: string) => string | undefined;
+
 export declare type NormalizedOpeningHours = {
     days: NormalizedWorkingDay[];
     defaultOpeningMinutes: number;

package/dist/booking.d.ts

@@ -11,6 +11,12 @@ declare type BookingPeriodConfig = {
     openingHours: StoreOpeningHours;
     openingHoursOverrides: StoreOpeningOverride[];
     timeZone: string;
+    extraTimeSlots?: BookingPeriodExtraTimeSlotRule[];
+};
+
+declare type BookingPeriodExtraTimeSlotRule = {
+    minutesAfterClose: number;
+    extraAmount: number;
 };
 
 declare type BookingSearchStorage = Pick<Storage, "getItem" | "removeItem" | "setItem"> | null | undefined;
@@ -22,6 +28,10 @@ declare type BookingTimingConfig = {
     minBufferMinutes: number;
 };
 
+export declare const createBookingPeriodConfigFromBookingEngineConfiguration: (bookingEngine: StorefrontConfiguration["bookingEngine"], options?: {
+    sameDayCutoff?: string;
+}) => BookingPeriodConfig;
+
 export declare const createBookingPeriodConfigFromStorefrontConfiguration: (storefrontConfiguration: StorefrontConfiguration) => BookingPeriodConfig;
 
 export declare const getBookingDurationLabel: (booking: StorefrontBookingParams) => {
@@ -173,6 +183,10 @@ declare const storefrontConfigurationSchema: z.ZodObject<{
                     end: string;
                 }[];
             }[] | undefined;
+            extraTimeSlots?: {
+                minutesAfterClose: number;
+                extraAmount: number;
+            }[] | undefined;
         };
         currency: "EUR" | "USD" | "GBP" | "CHF";
         checkout: {
@@ -237,6 +251,10 @@ declare const storefrontConfigurationSchema: z.ZodObject<{
                     end: string;
                 }[];
             }[] | undefined;
+            extraTimeSlots?: {
+                minutesAfterClose: number;
+                extraAmount: number;
+            }[] | undefined;
         };
         currency: "EUR" | "USD" | "GBP" | "CHF";
         checkout: {

package/dist/checkoutSubmit.d.ts

@@ -1,5 +1,36 @@
 import { z } from 'zod';
 
+export declare const requestBaseSchema: z.ZodObject<{
+    storeSlug: z.ZodString;
+    schedule: z.ZodObject<{
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+        startTime: z.ZodString;
+        endTime: z.ZodString;
+    }, z.core.$strip>;
+    fulfillment: z.ZodDefault<z.ZodEnum<{
+        pickup: "pickup";
+        delivery: "delivery";
+    }>>;
+    startAddress: z.ZodOptional<z.ZodString>;
+    endAddress: z.ZodOptional<z.ZodString>;
+    couponCode: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    couponAutoApplied: z.ZodOptional<z.ZodBoolean>;
+    customer: z.ZodObject<{
+        fullName: z.ZodString;
+        email: z.ZodString;
+        phone: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+        notes: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    }, z.core.$strip>;
+    items: z.ZodArray<z.ZodObject<{
+        kind: any;
+        productId: z.ZodString;
+        productVariantId: z.ZodOptional<z.ZodString>;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>;
+    nowIso: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
 export declare type RequestCheckoutItem = z.infer<typeof requestCheckoutItemSchema>;
 
 export declare const requestCheckoutItemSchema: z.ZodObject<{
@@ -9,6 +40,11 @@ export declare const requestCheckoutItemSchema: z.ZodObject<{
     quantity: z.ZodNumber;
 }, z.core.$strip>;
 
+export declare const requestDeliveryRefinement: (payload: {
+    fulfillment?: string;
+    startAddress?: string;
+}, ctx: z.RefinementCtx) => void;
+
 export declare type RequestPayload = z.infer<typeof requestSchema>;
 
 export declare const requestSchema: z.ZodObject<{

package/dist/chunks/pkg/booking-engine/dist/schemas/{booking-engine-configuration-CnBdp3jk.js → booking-engine-configuration-BKlzwJJX.js}

@@ -1,9 +1,9 @@
 import { z as e } from "zod";
 import { localizedStringSchema as s } from "../models/LocalizedString--6q77SPQ.js";
-import { priceUnitSchema as a } from "../models/Price-BlFRDHXV.js";
+import { priceUnitSchema as i } from "../models/Price-BlFRDHXV.js";
 import { currencyCodeSchema as m } from "./money-Dy4b9loa.js";
-import { shopConfigurationSchema as r } from "./shop-opening-hours-B47MMaoD.js";
-import { isoDateSchema as H, shopOpeningDaySchema as x, shopOpeningHoursOverrideSchema as z, shopOpeningHoursPeriodSchema as E, shopOpeningSlotSchema as I, timeOfDaySchema as L } from "./shop-opening-hours-B47MMaoD.js";
+import { shopConfigurationSchema as r } from "./shop-opening-hours-DqNWstqT.js";
+import { isoDateSchema as x, shopExtraTimeSlotRuleSchema as E, shopOpeningDaySchema as H, shopOpeningHoursOverrideSchema as z, shopOpeningHoursPeriodSchema as I, shopOpeningSlotSchema as L, timeOfDaySchema as $ } from "./shop-opening-hours-DqNWstqT.js";
 const l = [
   "soldOutOnly",
   "soldOutAndFewRemaining",
@@ -16,30 +16,30 @@ const l = [
   "soldOutAndFewRemaining",
   "fewRemaining",
   "fewRemainingCounts"
-]), p = (i) => c.has(i), d = {
+]), p = (a) => c.has(a), h = {
   message: "A defaultFewRemainingThreshold is required for display modes that highlight 'few remaining' states"
-}, h = e.object({
+}, d = e.object({
   defaultMode: u,
   defaultFewRemainingThreshold: e.number().int().min(1).optional()
 }).refine(
-  (i) => !p(i.defaultMode) || i.defaultFewRemainingThreshold !== void 0,
-  d
+  (a) => !p(a.defaultMode) || a.defaultFewRemainingThreshold !== void 0,
+  h
 ), g = e.object({
   enabled: e.boolean(),
   defaultTtlMinutes: e.number().int().min(1)
 }), b = e.object({
-  unit: a,
+  unit: i,
   label: s.optional(),
   durationHours: e.number().positive()
 }), f = e.object({
   enabled: e.boolean(),
   boundaryHour: e.number().int().min(0).max(23)
 }), S = e.object({
-  baseUnit: a,
+  baseUnit: i,
   rentalUnits: e.array(b).min(1),
   halfDay: f.optional()
 }).refine(
-  (i) => i.rentalUnits.some((t) => t.unit === i.baseUnit),
+  (a) => a.rentalUnits.some((t) => t.unit === a.baseUnit),
   { message: "Rental units must include the configured base unit" }
 ), y = e.number().min(0, { message: "Percentage must be greater than or equal to 0" }).max(1, { message: "Percentage must be less than or equal to 1" }), o = e.object({
   enabled: e.boolean(),
@@ -68,8 +68,8 @@ const l = [
 }).catchall(e.unknown()), R = e.object({
   mode: O,
   dynamicOptions: C.optional()
-}), k = m, T = e.object({
-  availabilityDisplay: h,
+}), k = m, M = e.object({
+  availabilityDisplay: d,
   holdSettings: g,
   pricing: S,
   bookingDeposit: o,
@@ -80,25 +80,26 @@ const l = [
 });
 export {
   F as DEFAULT_PAYMENT_POLICIES,
-  h as availabilityDisplayConfigurationSchema,
+  d as availabilityDisplayConfigurationSchema,
   u as availabilityDisplayModeSchema,
   o as bookingDepositPolicySchema,
-  T as bookingEngineConfigurationSchema,
+  M as bookingEngineConfigurationSchema,
   R as checkoutConfigurationSchema,
   C as checkoutDynamicOptionsSchema,
   O as checkoutModeSchema,
   k as currencySchema,
   g as holdSettingsSchema,
-  H as isoDateSchema,
+  x as isoDateSchema,
   q as paymentPoliciesSchema,
   S as pricingConfigurationSchema,
   f as pricingHalfDaySchema,
   b as pricingUnitOptionSchema,
   n as securityDepositPolicySchema,
   r as shopConfigurationSchema,
-  x as shopOpeningDaySchema,
+  E as shopExtraTimeSlotRuleSchema,
+  H as shopOpeningDaySchema,
   z as shopOpeningHoursOverrideSchema,
-  E as shopOpeningHoursPeriodSchema,
-  I as shopOpeningSlotSchema,
-  L as timeOfDaySchema
+  I as shopOpeningHoursPeriodSchema,
+  L as shopOpeningSlotSchema,
+  $ as timeOfDaySchema
 };

package/dist/chunks/pkg/booking-engine/dist/schemas/{cart-inputs-DYgEGJ5M.js → cart-inputs-ByBK0IVJ.js}

@@ -1,9 +1,9 @@
 import { z as e } from "zod";
 import { identifierSchema as i } from "../models/types-DLcvzW5b.js";
 import { moneyMinorSchema as a } from "./money-Dy4b9loa.js";
-import { fulfillmentModeSchema as s } from "./public-booking-engine-configuration-C9VB-WhU.js";
+import { fulfillmentModeSchema as s } from "./public-booking-engine-configuration-DKoak4s5.js";
 import { richTextSchema as m } from "./rich-text-CqXhNDN3.js";
-import { timeOfDaySchema as r, isoDateSchema as n } from "./shop-opening-hours-B47MMaoD.js";
+import { timeOfDaySchema as r, isoDateSchema as n } from "./shop-opening-hours-DqNWstqT.js";
 const p = e.object({
   startDate: n,
   endDate: n,

package/dist/chunks/pkg/booking-engine/dist/schemas/{public-booking-engine-configuration-C9VB-WhU.js → public-booking-engine-configuration-DKoak4s5.js}

@@ -1,6 +1,6 @@
 import { z as o } from "zod";
-import { checkoutConfigurationSchema as i, bookingEngineConfigurationSchema as a } from "./booking-engine-configuration-CnBdp3jk.js";
-import { timeOfDaySchema as e } from "./shop-opening-hours-B47MMaoD.js";
+import { checkoutConfigurationSchema as i, bookingEngineConfigurationSchema as a } from "./booking-engine-configuration-BKlzwJJX.js";
+import { timeOfDaySchema as e } from "./shop-opening-hours-DqNWstqT.js";
 const n = o.enum(["pickup", "delivery"]), t = o.object({
   fulfillmentModes: o.array(n).min(1).optional(),
   sameDayCutoff: e.optional()

package/dist/chunks/pkg/booking-engine/dist/schemas/shop-opening-hours-DqNWstqT.js

@@ -0,0 +1,51 @@
+import { z as e } from "zod";
+const o = /^([01]\d|2[0-3]):[0-5]\d$/, i = /^\d{4}-\d{2}-\d{2}$/, r = e.string().regex(o, {
+  message: "Time value must use 24-hour HH:MM format"
+}), a = e.string().regex(i, {
+  message: "Date must use YYYY-MM-DD format"
+}), s = e.object({
+  start: r,
+  end: r
+}).refine((t) => t.start < t.end, {
+  message: "End must be after start",
+  path: ["end"]
+}), n = e.union([
+  e.literal(0),
+  e.literal(1),
+  e.literal(2),
+  e.literal(3),
+  e.literal(4),
+  e.literal(5),
+  e.literal(6)
+]), m = e.object({
+  day: n,
+  openingSlots: e.array(s)
+}), l = e.object({
+  name: e.string().min(1),
+  startDate: a,
+  endDate: a,
+  openingHours: e.array(m).min(1)
+}), p = e.object({
+  date: a,
+  openingSlots: e.array(s)
+}), g = e.object({
+  minutesAfterClose: e.number().int().positive().max(240),
+  // Surcharge for returning in this tier, in currency minor units.
+  extraAmount: e.number().int().positive()
+}), u = e.object({
+  timeZone: e.string().min(1),
+  openingHours: e.array(l).min(1),
+  openingHoursOverrides: e.array(p).optional(),
+  extraTimeSlots: e.array(g).optional()
+});
+export {
+  a as isoDateSchema,
+  u as shopConfigurationSchema,
+  g as shopExtraTimeSlotRuleSchema,
+  n as shopOpeningDayIndexSchema,
+  m as shopOpeningDaySchema,
+  p as shopOpeningHoursOverrideSchema,
+  l as shopOpeningHoursPeriodSchema,
+  s as shopOpeningSlotSchema,
+  r as timeOfDaySchema
+};