@loczer/storefront-sdk 0.148.0 → 0.150.0

package/dist/StorefrontProvider.js

@@ -0,0 +1,95 @@
+import { jsx as c } from "react/jsx-runtime";
+import { createContext as k, useContext as S } from "react";
+import { useLoaderData as v } from "@rpcbase/router";
+import { apiClient as w } from "@rpcbase/client";
+import { Layout as C } from "./components/Layout/index.js";
+import { I18nProvider as L, resolveStorefrontI18nRequestLanguage as P, detectStorefrontI18nLanguage as _ } from "./i18n/I18nProvider.js";
+import { storefrontConfigurationSchema as R } from "./storefrontSchemas.js";
+import { ROUTE as b, responseSchema as B } from "./lib/storefrontProducts.js";
+import { toStorefrontBikeProducts as y, toStorefrontAccessoryProducts as E } from "./lib/products.js";
+const I = {}, i = k(void 0), X = (async ({ ctx: o, params: e }) => {
+  const t = typeof e.storeSlug == "string" ? e.storeSlug.trim().toLowerCase() : "";
+  if (!t) throw new Response("Store not found", { status: 404, statusText: "Store not found" });
+  try {
+    const r = await w.get("/api/public/storefront/config", { storeSlug: t }, o), f = typeof r == "object" && r !== null ? r : {};
+    if (f.success !== !0)
+      throw new Response("Store not found", { status: 404, statusText: "Store not found" });
+    const n = R.safeParse(f.storefrontConfiguration);
+    if (!n.success)
+      throw console.error("Invalid storefront config received", n.error.flatten()), new Response("Storefront config invalid", { status: 500 });
+    let g = [], d = [];
+    try {
+      const a = await w.get(b, { storeSlug: t }, o), s = B.safeParse(a);
+      if (!s.success)
+        console.error("Invalid storefront products received", s.error.flatten());
+      else if (!s.data.success)
+        console.error("Storefront products unavailable", s.data.message ?? "Unknown error");
+      else {
+        const m = s.data.products;
+        g = y(m?.bikes ?? []), d = E(m?.accessories ?? []);
+      }
+    } catch (a) {
+      console.error("Error fetching storefront products:", a);
+    }
+    const l = n.data.workspace?.languages ?? null, p = n.data.workspace?.workspaceLanguage ?? null, h = o?.req ? P({
+      cookieHeader: o.req.headers?.cookie,
+      acceptLanguageHeader: o.req.headers?.["accept-language"],
+      configuredLanguages: l,
+      configuredFallbackLanguage: p
+    }) : _(l, p);
+    return {
+      storeSlug: t,
+      storefrontConfiguration: n.data,
+      bikes: g,
+      accessories: d,
+      language: h
+    };
+  } catch (r) {
+    throw r instanceof Response ? r : (console.error("Error fetching storefront config:", r), new Response("Storefront config unavailable", { status: 500 }));
+  }
+});
+function j() {
+  const o = v(), e = I, t = typeof e?.RB_PUBLIC_MAPBOX_TOKEN == "string" && e.RB_PUBLIC_MAPBOX_TOKEN.trim().length > 0 ? e.RB_PUBLIC_MAPBOX_TOKEN : void 0;
+  return /* @__PURE__ */ c(i.Provider, { value: { ...o, mapboxToken: t }, children: /* @__PURE__ */ c(
+    L,
+    {
+      initialLanguage: o.language,
+      configuredLanguages: o.storefrontConfiguration.workspace?.languages,
+      configuredFallbackLanguage: o.storefrontConfiguration.workspace?.workspaceLanguage,
+      children: /* @__PURE__ */ c(C, { storefrontConfiguration: o.storefrontConfiguration })
+    }
+  ) });
+}
+function u() {
+  const o = S(i);
+  if (o === void 0)
+    throw new Error("must be used within the provider");
+  return o;
+}
+function F() {
+  return S(i);
+}
+function H() {
+  const { storefrontConfiguration: o } = u();
+  return {
+    config: o,
+    storefrontConfiguration: o
+  };
+}
+function D() {
+  const { storefrontConfiguration: o } = u();
+  return o.workspace?.workspaceLanguage ?? "en";
+}
+function W() {
+  const { bikes: o, accessories: e } = u();
+  return { bikes: o, accessories: e };
+}
+export {
+  j as default,
+  X as loader,
+  F as useOptionalStorefront,
+  u as useStorefront,
+  H as useStorefrontConfig,
+  W as useStorefrontProducts,
+  D as useStorefrontWorkspaceLanguage
+};

package/dist/accessories.d.ts

@@ -0,0 +1,42 @@
+export declare const accessories: ProductAccessory[];
+
+declare type LocalizedString<TExtra extends Record<string, unknown> = Record<string, unknown>> = Record<string, LocalizedStringEntry<TExtra>>;
+
+declare type LocalizedStringEntry<TExtra extends Record<string, unknown> = Record<string, unknown>> = {
+    value: string;
+    updatedAt: Date;
+    autoTranslated?: boolean;
+} & TExtra;
+
+export declare interface Price {
+    label: LocalizedString;
+    value: number;
+    unit: string;
+}
+
+export declare interface ProductAccessory {
+    id: string;
+    name: LocalizedString;
+    description?: LocalizedString;
+    images?: string[];
+    prices: Price[];
+    productVariants?: ProductVariant[];
+}
+
+export declare interface ProductVariant {
+    id: string;
+    computedName: string;
+    attributes: ProductVariantAttribute[];
+    identifiers: Array<{
+        kind: string;
+        value: string;
+    }>;
+}
+
+export declare interface ProductVariantAttribute {
+    key: string;
+    label?: string;
+    value: string;
+}
+
+export { }

package/dist/apiCall.d.ts

@@ -0,0 +1,7 @@
+import { Ctx } from '@rpcbase/api';
+
+export declare const apiGet: <TResponse = Record<string, unknown>>(path: string, payload?: unknown, ctx?: Ctx) => Promise<TResponse>;
+
+export declare const apiPost: <TResponse = Record<string, unknown>>(path: string, payload: unknown, ctx?: Ctx) => Promise<TResponse>;
+
+export { }

package/dist/badge.d.ts

@@ -0,0 +1,14 @@
+import { ClassProp } from 'class-variance-authority/types';
+import { JSX } from 'react/jsx-runtime';
+import * as React_2 from 'react';
+import { VariantProps } from 'class-variance-authority';
+
+export declare function Badge({ className, variant, asChild, ...props }: React_2.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
+    asChild?: boolean;
+}): JSX.Element;
+
+export declare const badgeVariants: (props?: ({
+    variant?: "default" | "secondary" | "outline" | "destructive" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export { }

package/dist/bikes.d.ts

@@ -0,0 +1,107 @@
+declare const bikes: ({
+    id: string;
+    name: {
+        fr: LocalizedStringEntry;
+        en: LocalizedStringEntry;
+    };
+    description: {
+        fr: LocalizedStringEntry;
+        en: LocalizedStringEntry;
+    };
+    images: string[];
+    prices: {
+        label: {
+            fr: LocalizedStringEntry;
+            en: LocalizedStringEntry;
+        };
+        value: number;
+        unit: string;
+    }[];
+    features: {
+        fr: LocalizedStringEntry;
+        en: LocalizedStringEntry;
+    }[];
+    productVariants: {
+        id: string;
+        computedName: string;
+        attributes: {
+            key: string;
+            value: string;
+        }[];
+        identifiers: {
+            kind: string;
+            value: string;
+        }[];
+    }[];
+    availabilityStatus?: undefined;
+} | {
+    id: string;
+    name: {
+        fr: LocalizedStringEntry;
+        en: LocalizedStringEntry;
+    };
+    description: {
+        fr: LocalizedStringEntry;
+        en: LocalizedStringEntry;
+    };
+    images: string[];
+    prices: {
+        label: {
+            fr: LocalizedStringEntry;
+            en: LocalizedStringEntry;
+        };
+        value: number;
+        unit: string;
+    }[];
+    features: {
+        fr: LocalizedStringEntry;
+        en: LocalizedStringEntry;
+    }[];
+    productVariants: {
+        id: string;
+        computedName: string;
+        attributes: {
+            key: string;
+            value: string;
+        }[];
+        identifiers: {
+            kind: string;
+            value: string;
+        }[];
+    }[];
+    availabilityStatus: string;
+} | {
+    id: string;
+    name: {
+        fr: LocalizedStringEntry;
+        en: LocalizedStringEntry;
+    };
+    description: {
+        fr: LocalizedStringEntry;
+        en: LocalizedStringEntry;
+    };
+    images: string[];
+    prices: {
+        label: {
+            fr: LocalizedStringEntry;
+            en: LocalizedStringEntry;
+        };
+        value: number;
+        unit: string;
+    }[];
+    features: {
+        fr: LocalizedStringEntry;
+        en: LocalizedStringEntry;
+    }[];
+    availabilityStatus: string;
+    productVariants?: undefined;
+})[];
+export default bikes;
+
+declare type LocalizedStringEntry<TExtra extends Record<string, unknown> = Record<string, unknown>> = {
+    value: string;
+    updatedAt: Date;
+    autoTranslated?: boolean;
+} & TExtra;
+
+export { }

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

@@ -0,0 +1,279 @@
+declare const adjustBookingPeriod: (period: BookingPeriodInput, options: BookingPeriodAdjustmentOptions) => BookingPeriodAdjustmentResult;
+
+declare namespace bookingPeriod {
+    export {
+        Weekday,
+        StoreOpeningSlot,
+        StoreOpeningDay,
+        StoreOpeningOverride,
+        StoreOpeningSeason,
+        StoreOpeningHours,
+        BookingTimingConfig,
+        minutesToTimeString,
+        parseTimeToMinutes,
+        NormalizedOpeningSlot,
+        NormalizedWorkingDay,
+        NormalizedOpeningHours,
+        NormalizeOpeningHoursOptions,
+        normalizeOpeningHours,
+        BookingPeriodConfig_2 as BookingPeriodConfig,
+        BookingPeriodConstants,
+        createBookingPeriodConstants,
+        DefaultBookingPeriod,
+        DefaultBookingPeriodOptions,
+        getDefaultBookingPeriod,
+        dateToBusinessDateString,
+        businessDateStringToDate,
+        BookingPeriodInput,
+        BookingPeriodAdjustmentResult,
+        BookingPeriodAdjustmentOptions,
+        adjustBookingPeriod
+    }
+}
+
+declare interface BookingPeriodAdjustmentOptions {
+    referenceDate?: Date;
+    toleranceMinutes?: number;
+    config: BookingPeriodConfig_2;
+}
+
+declare 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;
+}
+
+declare type BookingPeriodConfig = bookingPeriod.BookingPeriodConfig;
+
+declare type BookingPeriodConfig_2 = {
+    timing: BookingTimingConfig;
+    openingHours: StoreOpeningHours;
+    openingHoursOverrides: StoreOpeningOverride[];
+    timeZone: string;
+};
+
+declare type BookingPeriodConstants = ReturnType<typeof createBookingPeriodConstants>;
+
+declare interface BookingPeriodInput {
+    startDate?: Date | string | null;
+    startTime?: string | null;
+    endDate?: Date | string | null;
+    endTime?: string | null;
+}
+
+declare type BookingTimingConfig = {
+    slotIntervalMinutes: number;
+    autoFillCutoffMinutes: number;
+    pastToleranceMinutes: number;
+    minBufferMinutes: number;
+};
+
+declare const businessDateStringToDate: (dateString: string) => Date;
+
+declare const createBookingPeriodConstants: (config: BookingPeriodConfig_2) => {
+    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;
+};
+
+declare const dateToBusinessDateString: (date: Date | string | null | undefined, timeZone: string) => string | undefined;
+
+declare interface DefaultBookingPeriod {
+    startDate: Date;
+    startTime: string;
+    endDate: Date;
+    endTime: string;
+}
+
+declare interface DefaultBookingPeriodOptions {
+    referenceDate?: Date;
+    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<{
+    startTimeSlots: TimeSlot[];
+    endTimeSlots: TimeSlot[];
+}>;
+
+export declare const getBookingPeriodTimeSlotsSync: (bookingPeriodConfig: BookingPeriodConfig, { date, }?: {
+    date?: string;
+}) => {
+    startTimeSlots: TimeSlot[];
+    endTimeSlots: TimeSlot[];
+};
+
+declare const getDefaultBookingPeriod: (options: DefaultBookingPeriodOptions) => DefaultBookingPeriod;
+
+export declare const getDisabledTimeSlotRules: (context: DisabledTimeSlotRuleContext) => Promise<DisabledTimeSlotRule[]>;
+
+export declare const getDisabledTimeSlotRulesSync: (_context: DisabledTimeSlotRuleContext) => DisabledTimeSlotRule[];
+
+export declare const getExtraTimeSlotRules: (context: ExtraTimeSlotRuleContext) => Promise<ExtraTimeSlotRule[]>;
+
+export declare const getExtraTimeSlotRulesSync: (_context: ExtraTimeSlotRuleContext) => ExtraTimeSlotRule[];
+
+export declare type JourneyType = "start" | "end";
+
+declare const minutesToTimeString: (minutes: number) => string;
+
+declare type NormalizedOpeningHours = {
+    days: NormalizedWorkingDay[];
+    defaultOpeningMinutes: number;
+    defaultClosingMinutes: number;
+    defaultOpeningLabel: string;
+    defaultClosingLabel: string;
+    defaultSummaryLabel: string;
+    season: {
+        name?: string;
+        startDate: string;
+        endDate: string;
+    } | null;
+};
+
+declare type NormalizedOpeningSlot = {
+    startMinutes: number;
+    endMinutes: number;
+    startLabel: string;
+    endLabel: string;
+    rangeLabel: string;
+};
+
+declare type NormalizedWorkingDay = {
+    day: Weekday;
+    isClosed: boolean;
+    openingSlots: NormalizedOpeningSlot[];
+    openingMinutes: number | null;
+    closingMinutes: number | null;
+    summaryLabel: string | null;
+};
+
+declare const normalizeOpeningHours: (openingHours: StoreOpeningHours, openingHoursOverrides: StoreOpeningOverride[], options?: NormalizeOpeningHoursOptions) => NormalizedOpeningHours;
+
+declare type NormalizeOpeningHoursOptions = {
+    referenceDate?: Date | string | null;
+};
+
+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[];
+};
+
+declare type StoreOpeningHours = StoreOpeningSeason[];
+
+declare type StoreOpeningOverride = {
+    date: string;
+    openingSlots: StoreOpeningSlot[];
+};
+
+declare type StoreOpeningSeason = {
+    name?: string;
+    startDate: string;
+    endDate: string;
+    openingHours: StoreOpeningDay[];
+};
+
+declare type StoreOpeningSlot = {
+    start: string;
+    end: string;
+};
+
+export declare type TimeSlot = TimeSlotBase & {
+    isDisabled: boolean;
+    disabledReason?: string;
+};
+
+export declare type TimeSlotBase = {
+    value: string;
+    label: string;
+    startMinutes: number;
+    endMinutes: number;
+    isExtra: boolean;
+    extraAmount?: number;
+};
+
+export declare const toBusinessDateString: (date: string) => string;
+
+declare type Weekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+export { }