@loczer/storefront-sdk 0.208.0 → 0.210.0

package/dist/StorefrontContext.d.ts

@@ -2,6 +2,7 @@ import { Context } from 'react';
 import { StorefrontI18nLanguage } from './i18n/I18nProvider';
 import { AccessoryProduct, BikeProduct } from './lib/products';
 import { StorefrontConfiguration } from './storefrontSchemas';
+import { StorefrontItineraryPreview, StorefrontItinerarySummary } from './lib/storefrontItineraries';
 export type StorefrontContextValue = {
     storeSlug: string;
     storefrontConfiguration: StorefrontConfiguration;
@@ -11,6 +12,8 @@ export type StorefrontContextValue = {
     bookingAccessories: AccessoryProduct[];
     mapboxToken?: string;
     language: StorefrontI18nLanguage;
+    itineraries: StorefrontItinerarySummary[];
+    featuredItineraries: StorefrontItineraryPreview[];
 };
 export declare const StorefrontContext: Context<StorefrontContextValue | undefined>;
 export declare function useStorefront(): StorefrontContextValue;
@@ -480,4 +483,90 @@ export declare function useStorefrontBookingProducts(): {
     bikes: BikeProduct[];
     accessories: AccessoryProduct[];
 };
+export declare function useStorefrontItineraries(): {
+    itineraries: {
+        slug: string;
+        title: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>;
+        introduction: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>;
+        tags: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>[];
+        coverImageId: string | null;
+        difficulty: "easy" | "moderate" | "challenging";
+        tripType: "one_way" | "out_and_back" | "loop";
+        metrics: {
+            distanceMeters: number;
+            durationSeconds: number;
+            elevationGainMeters: number;
+            elevationLossMeters: number;
+        };
+    }[];
+    featuredItineraries: {
+        slug: string;
+        title: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>;
+        introduction: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>;
+        tags: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>[];
+        coverImageId: string | null;
+        difficulty: "easy" | "moderate" | "challenging";
+        tripType: "one_way" | "out_and_back" | "loop";
+        metrics: {
+            distanceMeters: number;
+            durationSeconds: number;
+            elevationGainMeters: number;
+            elevationLossMeters: number;
+        };
+        previewCoordinates: ([number, number] | [number, number, number])[];
+        steps: {
+            id: string;
+            label: Record<string, {
+                [x: string]: unknown;
+                value: string;
+                updatedAt: Date;
+                autoTranslated?: boolean | undefined;
+            }>;
+            description: Record<string, {
+                [x: string]: unknown;
+                value: string;
+                updatedAt: Date;
+                autoTranslated?: boolean | undefined;
+            }>;
+            role: "shaping" | "stop" | "detached";
+            point: {
+                lng: number;
+                lat: number;
+                ele?: number | undefined;
+            };
+            imageIds: string[];
+            category?: string | undefined;
+        }[];
+    }[];
+};
 //# sourceMappingURL=StorefrontContext.d.ts.map

package/dist/StorefrontContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StorefrontContext.d.ts","sourceRoot":"","sources":["../src/StorefrontContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,OAAO,EAAE,MAAM,OAAO,CAAA;AAE/D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAA;AAGlE,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,uBAAuB,EAAE,uBAAuB,CAAA;IAChD,KAAK,EAAE,WAAW,EAAE,CAAA;IACpB,WAAW,EAAE,gBAAgB,EAAE,CAAA;IAC/B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,kBAAkB,EAAE,gBAAgB,EAAE,CAAA;IACtC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,sBAAsB,CAAA;CACjC,CAAA;AAUD,eAAO,MAAM,iBAAiB,6CAEmC,CAAA;AAKjE,wBAAgB,aAAa,2BAQ5B;AAED,wBAAgB,qBAAqB,uCAEpC;AAED,wBAAgB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMlC;AAED,wBAAgB,8BAA8B,IAAI,sBAAsB,CAGvE;AAED,wBAAgB,qBAAqB;;;EAGpC;AAED,wBAAgB,4BAA4B;;;EAG3C"}
+{"version":3,"file":"StorefrontContext.d.ts","sourceRoot":"","sources":["../src/StorefrontContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,OAAO,EAAE,MAAM,OAAO,CAAA;AAE/D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAA;AAClE,OAAO,KAAK,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAA;AAGzG,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,uBAAuB,EAAE,uBAAuB,CAAA;IAChD,KAAK,EAAE,WAAW,EAAE,CAAA;IACpB,WAAW,EAAE,gBAAgB,EAAE,CAAA;IAC/B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,kBAAkB,EAAE,gBAAgB,EAAE,CAAA;IACtC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,sBAAsB,CAAA;IAChC,WAAW,EAAE,0BAA0B,EAAE,CAAA;IACzC,mBAAmB,EAAE,0BAA0B,EAAE,CAAA;CAClD,CAAA;AAUD,eAAO,MAAM,iBAAiB,6CAEmC,CAAA;AAKjE,wBAAgB,aAAa,2BAQ5B;AAED,wBAAgB,qBAAqB,uCAEpC;AAED,wBAAgB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMlC;AAED,wBAAgB,8BAA8B,IAAI,sBAAsB,CAGvE;AAED,wBAAgB,qBAAqB;;;EAGpC;AAED,wBAAgB,4BAA4B;;;EAG3C;AAED,wBAAgB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC"}

package/dist/StorefrontContext.js

@@ -35,5 +35,12 @@ function l() {
 		accessories: t
 	};
 }
+function u() {
+	let { itineraries: e, featuredItineraries: t } = i();
+	return {
+		itineraries: e,
+		featuredItineraries: t
+	};
+}
 //#endregion
-export { r as StorefrontContext, a as useOptionalStorefront, i as useStorefront, l as useStorefrontBookingProducts, o as useStorefrontConfig, c as useStorefrontProducts, s as useStorefrontWorkspaceLanguage };
+export { r as StorefrontContext, a as useOptionalStorefront, i as useStorefront, l as useStorefrontBookingProducts, o as useStorefrontConfig, u as useStorefrontItineraries, c as useStorefrontProducts, s as useStorefrontWorkspaceLanguage };

package/dist/StorefrontProvider.d.ts

@@ -232,6 +232,90 @@ export declare const loader: ({ ctx, params }: import('@rpcbase/client').LoaderA
     bookingBikes: import('.').BikeProduct[];
     bookingAccessories: import('.').AccessoryProduct[];
     language: import('./i18n/I18nProvider').StorefrontI18nLanguage;
+    itineraries: {
+        slug: string;
+        title: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>;
+        introduction: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>;
+        tags: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>[];
+        coverImageId: string | null;
+        difficulty: "easy" | "moderate" | "challenging";
+        tripType: "one_way" | "out_and_back" | "loop";
+        metrics: {
+            distanceMeters: number;
+            durationSeconds: number;
+            elevationGainMeters: number;
+            elevationLossMeters: number;
+        };
+    }[];
+    featuredItineraries: {
+        slug: string;
+        title: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>;
+        introduction: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>;
+        tags: Record<string, {
+            [x: string]: unknown;
+            value: string;
+            updatedAt: Date;
+            autoTranslated?: boolean | undefined;
+        }>[];
+        coverImageId: string | null;
+        difficulty: "easy" | "moderate" | "challenging";
+        tripType: "one_way" | "out_and_back" | "loop";
+        metrics: {
+            distanceMeters: number;
+            durationSeconds: number;
+            elevationGainMeters: number;
+            elevationLossMeters: number;
+        };
+        previewCoordinates: ([number, number] | [number, number, number])[];
+        steps: {
+            id: string;
+            label: Record<string, {
+                [x: string]: unknown;
+                value: string;
+                updatedAt: Date;
+                autoTranslated?: boolean | undefined;
+            }>;
+            description: Record<string, {
+                [x: string]: unknown;
+                value: string;
+                updatedAt: Date;
+                autoTranslated?: boolean | undefined;
+            }>;
+            role: "shaping" | "stop" | "detached";
+            point: {
+                lng: number;
+                lat: number;
+                ele?: number | undefined;
+            };
+            imageIds: string[];
+            category?: string | undefined;
+        }[];
+    }[];
 }>;
 export default function StorefrontProvider(): import("react/jsx-runtime").JSX.Element;
 export * from './StorefrontContext';

package/dist/StorefrontProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StorefrontProvider.d.ts","sourceRoot":"","sources":["../src/StorefrontProvider.tsx"],"names":[],"mappings":"AAwBA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEA,CAAA;AAGnB,MAAM,CAAC,OAAO,UAAU,kBAAkB,4CAqBzC;AAED,cAAc,qBAAqB,CAAA"}
+{"version":3,"file":"StorefrontProvider.d.ts","sourceRoot":"","sources":["../src/StorefrontProvider.tsx"],"names":[],"mappings":"AA8BA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiFA,CAAA;AAGnB,MAAM,CAAC,OAAO,UAAU,kBAAkB,4CAqBzC;AAED,cAAc,qBAAqB,CAAA"}

package/dist/StorefrontProvider.js

@@ -1,65 +1,79 @@
 import { storefrontConfigurationSchema as e } from "./storefrontSchemas.js";
 import { toStorefrontAccessoryProducts as t, toStorefrontBikeProducts as n, toStorefrontBookingProductsCollections as r } from "./lib/products.js";
-import { ROUTE as i, responseSchema as a } from "./lib/storefrontProducts.js";
-import { I18nProvider as o, detectStorefrontI18nLanguage as s, resolveStorefrontI18nRequestLanguage as c } from "./i18n/I18nProvider.js";
-import { Layout as l } from "./components/Layout/index.js";
-import { StorefrontContext as u, useOptionalStorefront as d, useStorefront as f, useStorefrontBookingProducts as p, useStorefrontConfig as m, useStorefrontProducts as h, useStorefrontWorkspaceLanguage as g } from "./StorefrontContext.js";
-import { createStorefrontUnavailableError as _, isStorefrontUnavailableRouteError as v, parseStorefrontUnavailableStatus as y } from "./lib/storefrontUnavailable.js";
-import { jsx as b } from "react/jsx-runtime";
-import { apiClient as x } from "@rpcbase/client";
-import { useLoaderData as S } from "@rpcbase/router";
+import { STOREFRONT_ITINERARIES_FEATURED_ROUTE as i, STOREFRONT_ITINERARIES_LIST_ROUTE as a, storefrontItinerariesFeaturedResponseSchema as o, storefrontItinerariesListResponseSchema as s } from "./lib/storefrontItineraries.js";
+import { ROUTE as c, responseSchema as l } from "./lib/storefrontProducts.js";
+import { StorefrontContext as u, useOptionalStorefront as d, useStorefront as f, useStorefrontBookingProducts as p, useStorefrontConfig as m, useStorefrontItineraries as h, useStorefrontProducts as g, useStorefrontWorkspaceLanguage as _ } from "./StorefrontContext.js";
+import { I18nProvider as v, detectStorefrontI18nLanguage as y, resolveStorefrontI18nRequestLanguage as b } from "./i18n/I18nProvider.js";
+import { Layout as x } from "./components/Layout/index.js";
+import { createStorefrontUnavailableError as S, isStorefrontUnavailableRouteError as C, parseStorefrontUnavailableStatus as w } from "./lib/storefrontUnavailable.js";
+import { jsx as T } from "react/jsx-runtime";
+import { apiClient as E } from "@rpcbase/client";
+import { useLoaderData as D } from "@rpcbase/router";
 //#region src/StorefrontProvider.tsx
-var C = (async ({ ctx: o, params: l }) => {
-	let u = typeof l.storeSlug == "string" ? l.storeSlug.trim().toLowerCase() : "";
-	if (!u) throw _("unknown");
+var O = (async ({ ctx: u, params: d }) => {
+	let f = typeof d.storeSlug == "string" ? d.storeSlug.trim().toLowerCase() : "";
+	if (!f) throw S("unknown");
 	try {
-		let [l, d] = await Promise.all([x.get("/api/public/storefront/config", { storeSlug: u }, o), x.get(i, { storeSlug: u }, o)]), f = typeof l == "object" && l ? l : {};
-		if (f.success !== !0) throw _(y(f.storefrontStatus) ?? "unknown", typeof f.replacementSlug == "string" ? f.replacementSlug : void 0);
-		let p = e.safeParse(f.storefrontConfiguration);
-		if (!p.success) throw console.error("Invalid storefront config received", p.error.flatten()), new Response("Storefront config invalid", { status: 500 });
-		let m = a.safeParse(d);
-		if (!m.success) throw console.error("Invalid storefront products received", m.error.flatten()), new Response("Storefront products invalid", { status: 500 });
-		if (!m.data.success) throw console.error("Storefront products unavailable", m.data.message ?? "Unknown error"), new Response("Storefront products unavailable", { status: 500 });
-		let h = n(m.data.products.bikes), g = t(m.data.products.accessories), v = r({
-			bikes: h,
-			accessories: g
-		}), b = p.data.workspace?.languages ?? null, S = p.data.workspace?.workspaceLanguage ?? null, C = o?.req ? c({
-			cookieHeader: o.req.headers?.cookie,
-			acceptLanguageHeader: o.req.headers?.["accept-language"],
-			configuredLanguages: b,
-			configuredFallbackLanguage: S
-		}) : s(b, S);
+		let [d, p, m, h] = await Promise.all([
+			E.get("/api/public/storefront/config", { storeSlug: f }, u),
+			E.get(c, { storeSlug: f }, u),
+			E.get(a, { storeSlug: f }, u).catch((e) => (console.error("Unable to load Storefront itineraries", e), {
+				success: !1,
+				itineraries: []
+			})),
+			E.get(i, { storeSlug: f }, u).catch((e) => (console.error("Unable to load featured Storefront itineraries", e), {
+				success: !1,
+				itineraries: []
+			}))
+		]), g = typeof d == "object" && d ? d : {};
+		if (g.success !== !0) throw S(w(g.storefrontStatus) ?? "unknown", typeof g.replacementSlug == "string" ? g.replacementSlug : void 0);
+		let _ = e.safeParse(g.storefrontConfiguration);
+		if (!_.success) throw console.error("Invalid storefront config received", _.error.flatten()), new Response("Storefront config invalid", { status: 500 });
+		let v = l.safeParse(p);
+		if (!v.success) throw console.error("Invalid storefront products received", v.error.flatten()), new Response("Storefront products invalid", { status: 500 });
+		if (!v.data.success) throw console.error("Storefront products unavailable", v.data.message ?? "Unknown error"), new Response("Storefront products unavailable", { status: 500 });
+		let x = n(v.data.products.bikes), C = t(v.data.products.accessories), T = r({
+			bikes: x,
+			accessories: C
+		}), D = s.safeParse(m), O = o.safeParse(h), k = _.data.workspace?.languages ?? null, A = _.data.workspace?.workspaceLanguage ?? null, j = u?.req ? b({
+			cookieHeader: u.req.headers?.cookie,
+			acceptLanguageHeader: u.req.headers?.["accept-language"],
+			configuredLanguages: k,
+			configuredFallbackLanguage: A
+		}) : y(k, A);
 		return {
-			storeSlug: u,
-			storefrontConfiguration: p.data,
-			bikes: h,
-			accessories: g,
-			bookingBikes: v.bikes,
-			bookingAccessories: v.accessories,
-			language: C
+			storeSlug: f,
+			storefrontConfiguration: _.data,
+			bikes: x,
+			accessories: C,
+			bookingBikes: T.bikes,
+			bookingAccessories: T.accessories,
+			language: j,
+			itineraries: D.success && D.data.success ? D.data.itineraries : [],
+			featuredItineraries: O.success && O.data.success ? O.data.itineraries : []
 		};
 	} catch (e) {
-		throw v(e) || e instanceof Response ? e : (console.error("Error loading storefront:", e), new Response("Storefront unavailable", { status: 500 }));
+		throw C(e) || e instanceof Response ? e : (console.error("Error loading storefront:", e), new Response("Storefront unavailable", { status: 500 }));
 	}
 });
-function w() {
-	let e = S(), t = {
+function k() {
+	let e = D(), t = {
 		BASE_URL: "/",
 		DEV: !1,
 		MODE: "production",
 		PROD: !0,
 		SSR: !1
 	}, n = typeof t?.RB_PUBLIC_MAPBOX_TOKEN == "string" && t.RB_PUBLIC_MAPBOX_TOKEN.trim().length > 0 ? t.RB_PUBLIC_MAPBOX_TOKEN : void 0;
-	return /* @__PURE__ */ b(u.Provider, {
+	return /* @__PURE__ */ T(u.Provider, {
 		value: {
 			...e,
 			mapboxToken: n
 		},
-		children: /* @__PURE__ */ b(o, {
+		children: /* @__PURE__ */ T(v, {
 			initialLanguage: e.language,
 			configuredLanguages: e.storefrontConfiguration.workspace?.languages,
 			configuredFallbackLanguage: e.storefrontConfiguration.workspace?.workspaceLanguage,
-			children: /* @__PURE__ */ b(l, {
+			children: /* @__PURE__ */ T(x, {
 				storefrontConfiguration: e.storefrontConfiguration,
 				storefrontProducts: {
 					bikes: e.bikes,
@@ -70,4 +84,4 @@ function w() {
 	});
 }
 //#endregion
-export { u as StorefrontContext, w as default, C as loader, d as useOptionalStorefront, f as useStorefront, p as useStorefrontBookingProducts, m as useStorefrontConfig, h as useStorefrontProducts, g as useStorefrontWorkspaceLanguage };
+export { u as StorefrontContext, k as default, O as loader, d as useOptionalStorefront, f as useStorefront, p as useStorefrontBookingProducts, m as useStorefrontConfig, h as useStorefrontItineraries, g as useStorefrontProducts, _ as useStorefrontWorkspaceLanguage };

package/dist/chunks/pkg/booking-engine/dist/node_modules/@date-fns/tz/date/index-DAbcklF5.js

@@ -0,0 +1 @@
+import "./mini-CSEBo1ZP.js";

package/dist/chunks/pkg/booking-engine/dist/node_modules/@date-fns/tz/date/mini-CSEBo1ZP.js

@@ -0,0 +1,60 @@
+import { tzOffset as e } from "../tzOffset/index-COlDDdap.js";
+//#region ../booking-engine/dist/node_modules/@date-fns/tz/date/mini.js
+var t = class t extends Date {
+	constructor(...t) {
+		super(), t.length > 1 && typeof t[t.length - 1] == "string" && (this.timeZone = t.pop()), this.internal = /* @__PURE__ */ new Date(), isNaN(e(this.timeZone, this)) ? this.setTime(NaN) : t.length ? typeof t[0] == "number" && (t.length === 1 || t.length === 2 && typeof t[1] != "number") ? this.setTime(t[0]) : typeof t[0] == "string" ? this.setTime(+new Date(t[0])) : t[0] instanceof Date ? this.setTime(+t[0]) : (this.setTime(+new Date(...t)), a(this, NaN), r(this)) : this.setTime(Date.now());
+	}
+	static tz(e, ...n) {
+		return n.length ? new t(...n, e) : new t(Date.now(), e);
+	}
+	withTimeZone(e) {
+		return new t(+this, e);
+	}
+	getTimezoneOffset() {
+		let t = -e(this.timeZone, this);
+		return t > 0 ? Math.floor(t) : Math.ceil(t);
+	}
+	setTime(e) {
+		return Date.prototype.setTime.apply(this, arguments), r(this), +this;
+	}
+	[Symbol.for("constructDateFrom")](e) {
+		return new t(+new Date(e), this.timeZone);
+	}
+}, n = /^(get|set)(?!UTC)/;
+Object.getOwnPropertyNames(Date.prototype).forEach((e) => {
+	if (!n.test(e)) return;
+	let a = e.replace(n, "$1UTC");
+	t.prototype[a] && (e.startsWith("get") ? t.prototype[e] = function() {
+		return this.internal[a]();
+	} : (t.prototype[e] = function() {
+		return Date.prototype[a].apply(this.internal, arguments), i(this), +this;
+	}, t.prototype[a] = function() {
+		return Date.prototype[a].apply(this, arguments), r(this), +this;
+	}));
+});
+function r(t) {
+	t.internal.setTime(+t), t.internal.setUTCSeconds(t.internal.getUTCSeconds() - Math.round(-e(t.timeZone, t) * 60));
+}
+function i(e) {
+	Date.prototype.setFullYear.call(e, e.internal.getUTCFullYear(), e.internal.getUTCMonth(), e.internal.getUTCDate()), Date.prototype.setHours.call(e, e.internal.getUTCHours(), e.internal.getUTCMinutes(), e.internal.getUTCSeconds(), e.internal.getUTCMilliseconds()), a(e);
+}
+function a(t) {
+	let n = e(t.timeZone, t), r = n > 0 ? Math.floor(n) : Math.ceil(n), i = /* @__PURE__ */ new Date(+t);
+	i.setUTCHours(i.getUTCHours() - 1);
+	let a = -(/* @__PURE__ */ new Date(+t)).getTimezoneOffset(), o = a - -(/* @__PURE__ */ new Date(+i)).getTimezoneOffset(), s = Date.prototype.getHours.apply(t) !== t.internal.getUTCHours();
+	o && s && t.internal.setUTCMinutes(t.internal.getUTCMinutes() + o);
+	let c = a - r;
+	c && Date.prototype.setUTCMinutes.call(t, Date.prototype.getUTCMinutes.call(t) + c);
+	let l = /* @__PURE__ */ new Date(+t);
+	l.setUTCSeconds(0);
+	let u = a > 0 ? l.getSeconds() : (l.getSeconds() - 60) % 60, d = Math.round(-(e(t.timeZone, t) * 60)) % 60;
+	(d || u) && (t.internal.setUTCSeconds(t.internal.getUTCSeconds() + d), Date.prototype.setUTCSeconds.call(t, Date.prototype.getUTCSeconds.call(t) + d + u));
+	let f = e(t.timeZone, t), p = f > 0 ? Math.floor(f) : Math.ceil(f), m = -(/* @__PURE__ */ new Date(+t)).getTimezoneOffset() - p, h = p !== r, g = m - c;
+	if (h && g) {
+		Date.prototype.setUTCMinutes.call(t, Date.prototype.getUTCMinutes.call(t) + g);
+		let n = e(t.timeZone, t), r = p - (n > 0 ? Math.floor(n) : Math.ceil(n));
+		r && (t.internal.setUTCMinutes(t.internal.getUTCMinutes() + r), Date.prototype.setUTCMinutes.call(t, Date.prototype.getUTCMinutes.call(t) + r));
+	}
+}
+//#endregion
+export { t as TZDateMini };

package/dist/chunks/pkg/booking-engine/dist/node_modules/@date-fns/tz/index--u3Qf-qy.js

@@ -0,0 +1,4 @@
+import "./tzOffset/index-COlDDdap.js";
+import "./date/mini-CSEBo1ZP.js";
+import "./date/index-DAbcklF5.js";
+import "./tz/index-CEcibV-H.js";

package/dist/chunks/pkg/booking-engine/dist/node_modules/@date-fns/tz/tz/index-CEcibV-H.js

@@ -0,0 +1 @@
+import "../date/index-DAbcklF5.js";

package/dist/chunks/pkg/booking-engine/dist/node_modules/@date-fns/tz/tzOffset/index-COlDDdap.js

@@ -0,0 +1,22 @@
+//#region ../booking-engine/dist/node_modules/@date-fns/tz/tzOffset/index.js
+var e = {}, t = {};
+function n(n, a) {
+	try {
+		let r = (e[n] ||= new Intl.DateTimeFormat("en-US", {
+			timeZone: n,
+			timeZoneName: "longOffset"
+		}).format)(a).split("GMT")[1];
+		return r in t ? t[r] : i(r, r.split(":"));
+	} catch {
+		if (n in t) return t[n];
+		let e = n?.match(r);
+		return e ? i(n, e.slice(1)) : NaN;
+	}
+}
+var r = /([+-]\d\d):?(\d\d)?/;
+function i(e, n) {
+	let r = +(n[0] || 0), i = +(n[1] || 0), a = (n[2] || 0) / 60;
+	return t[e] = r * 60 + i > 0 ? r * 60 + i + a : r * 60 - i - a;
+}
+//#endregion
+export { n as tzOffset };

package/dist/chunks/pkg/booking-engine/dist/pricing-BJaynUu_.js

@@ -0,0 +1,3 @@
+import { calculatePriceForQuantity as e } from "./utils/pricing-CqXJ5fMP.js";
+import { calculateRentalQuantity as t, combineDateAndTime as n } from "./utils/schedule-ssRov9xe.js";
+export { e as calculatePriceForQuantity, t as calculateRentalQuantity, n as combineDateAndTime };

package/dist/chunks/pkg/booking-engine/dist/utils/schedule-ssRov9xe.js

@@ -0,0 +1,39 @@
+import { getZonedDateTimeParts as e, zonedTimeToUtcDate as t } from "./timezone-B6XIbBPz.js";
+//#region ../booking-engine/dist/utils/schedule.js
+function n(e, n, r = "UTC") {
+	return t(e, n, r);
+}
+var r = 3600 * 1e3, i = 24 * r;
+function a(t, n) {
+	let r = n === "UTC" ? {
+		year: t.getUTCFullYear(),
+		month: t.getUTCMonth() + 1,
+		day: t.getUTCDate()
+	} : e(t, n);
+	return Date.UTC(r.year, r.month - 1, r.day);
+}
+function o(t, n) {
+	return n === "UTC" ? t.getUTCHours() : e(t, n).hour;
+}
+function s(e, t, n, r) {
+	let s = a(e, r), c = a(t, r), l = Math.round((c - s) / i);
+	if (l <= 0) return 1;
+	let u = o(e, r) >= n, d = o(t, r) < n, f = u || d ? .5 : 0;
+	return l + 1 - f;
+}
+function c(e) {
+	let t = e.rentalUnits.find((t) => t.unit === e.baseUnit);
+	if (!t) throw Error(`Pricing configuration is missing a rental unit for base unit ${e.baseUnit}`);
+	if (t.durationHours <= 0) throw Error(`Rental unit ${e.baseUnit} must declare a positive duration`);
+	return t;
+}
+function l(e, t, n, i = "UTC") {
+	let a = c(n), o = n.halfDay, l = n.rentalUnits.some((e) => e.unit === "half_day");
+	if (n.baseUnit === "day" && o?.enabled === !0 && !l) return s(e, t, o?.boundaryHour ?? 12, i);
+	let u = a.durationHours * r;
+	if (u <= 0) throw Error("Base pricing unit must convert to a positive duration");
+	let d = Math.max(0, t.getTime() - e.getTime()) / u;
+	return Math.max(1, Math.ceil(d));
+}
+//#endregion
+export { l as calculateRentalQuantity, n as combineDateAndTime };

package/dist/chunks/pkg/booking-engine/dist/utils/timezone-B6XIbBPz.js

@@ -0,0 +1,79 @@
+import { TZDateMini as e } from "../node_modules/@date-fns/tz/date/mini-CSEBo1ZP.js";
+import "../node_modules/@date-fns/tz/index--u3Qf-qy.js";
+//#region ../booking-engine/dist/utils/timezone.js
+var t = /^(\d{4})-(\d{2})-(\d{2})$/, n = /^(\d{2}):(\d{2})$/;
+function r(e) {
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone: e });
+	} catch (t) {
+		throw t instanceof RangeError ? Error(`Invalid IANA timeZone provided: ${e}`) : t;
+	}
+}
+function i(e, n = "date") {
+	let r = t.exec(e);
+	if (!r) throw Error(`Invalid ${n}: expected YYYY-MM-DD, received ${e}`);
+	let i = Number(r[1]), a = Number(r[2]), o = Number(r[3]);
+	if (!Number.isInteger(i) || i < 0) throw Error(`Invalid ${n}: year must be a positive integer, received ${e}`);
+	if (!Number.isInteger(a) || a < 1 || a > 12) throw Error(`Invalid ${n}: month must be between 01 and 12, received ${e}`);
+	if (!Number.isInteger(o) || o < 1 || o > 31) throw Error(`Invalid ${n}: day must be between 01 and 31, received ${e}`);
+	let s = new Date(Date.UTC(i, a - 1, o));
+	if (s.getUTCFullYear() !== i || s.getUTCMonth() !== a - 1 || s.getUTCDate() !== o) throw Error(`Invalid ${n}: received ${e}`);
+	return {
+		year: i,
+		month: a,
+		day: o
+	};
+}
+function a(e, t = "time") {
+	let r = n.exec(e);
+	if (!r) throw Error(`Invalid ${t}: expected HH:mm, received ${e}`);
+	let i = Number(r[1]), a = Number(r[2]);
+	if (!Number.isInteger(i) || i < 0 || i > 23) throw Error(`Invalid ${t}: hour must be between 00 and 23, received ${e}`);
+	if (!Number.isInteger(a) || a < 0 || a > 59) throw Error(`Invalid ${t}: minute must be between 00 and 59, received ${e}`);
+	return {
+		hour: i,
+		minute: a
+	};
+}
+function o(e) {
+	let t = (t, n) => {
+		let r = e.find((e) => e.type === t)?.value;
+		if (!r) throw Error(`Unable to resolve ${n} from timeZone conversion`);
+		return Number(r);
+	};
+	return {
+		year: t("year", "year"),
+		month: t("month", "month"),
+		day: t("day", "day"),
+		hour: t("hour", "hour"),
+		minute: t("minute", "minute"),
+		second: t("second", "second")
+	};
+}
+function s(e, t) {
+	return r(t), o(new Intl.DateTimeFormat("en-US", {
+		timeZone: t,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hour12: !1,
+		hourCycle: "h23"
+	}).formatToParts(e));
+}
+function c(e, t) {
+	return e.year === t.year && e.month === t.month && e.day === t.day && e.hour === t.hour && e.minute === t.minute;
+}
+function l(t, n, o) {
+	r(o);
+	let l = i(t, "date"), u = a(n, "time"), d = {
+		...l,
+		...u
+	}, f = new e(d.year, d.month - 1, d.day, d.hour, d.minute, 0, o).getTime();
+	if (!c(s(new Date(f), o), d)) throw Error(`Invalid local datetime for timeZone ${o}: ${t} ${n} (DST shift?)`);
+	return new Date(f);
+}
+//#endregion
+export { s as getZonedDateTimeParts, i as parseIsoDateParts, a as parseTimeOfDayParts, l as zonedTimeToUtcDate };