@loczer/storefront-sdk 0.147.0 → 0.149.0

package/dist/lib/playgroundDevSettings.js

@@ -0,0 +1,61 @@
+import { useState as w, useEffect as f } from "react";
+const l = "__LOCZER_STOREFRONT_PLAYGROUND__", r = "loczer-storefront-playground-dev-settings", s = "loczer:storefront-playground-dev-settings", n = {
+  heroMode: "current_booking_hero"
+}, d = (e) => {
+  if (!e || typeof e != "object")
+    return n;
+  const t = e;
+  return {
+    heroMode: t.heroMode === "booking_bar_overlay_hero" || t.heroMode === "vertical_marquee_hero" ? t.heroMode : "current_booking_hero"
+  };
+}, a = () => typeof window > "u" ? !1 : window[l] === !0, i = () => {
+  if (typeof window > "u" || !a())
+    return n;
+  try {
+    const e = window.localStorage.getItem(r);
+    return e ? d(JSON.parse(e)) : n;
+  } catch {
+    return n;
+  }
+}, S = (e) => e.heroMode === n.heroMode, _ = (e) => {
+  if (typeof window > "u" || !a())
+    return;
+  const t = d(e);
+  try {
+    S(t) ? window.localStorage.removeItem(r) : window.localStorage.setItem(r, JSON.stringify(t));
+  } catch {
+  }
+  try {
+    window.dispatchEvent(new CustomEvent(s, { detail: t }));
+  } catch {
+  }
+}, h = () => {
+  _(n);
+}, v = () => {
+  const [e, t] = w(() => i());
+  return f(() => {
+    if (!a())
+      return;
+    const c = (o) => {
+      o.key === r && t(i());
+    }, u = (o) => {
+      const g = o;
+      if (g.detail) {
+        t(d(g.detail));
+        return;
+      }
+      t(i());
+    };
+    return window.addEventListener("storage", c), window.addEventListener(s, u), () => {
+      window.removeEventListener("storage", c), window.removeEventListener(s, u);
+    };
+  }, []), e;
+};
+export {
+  n as DEFAULT_PLAYGROUND_DEV_SETTINGS,
+  a as isStorefrontPlaygroundRuntime,
+  i as readPlaygroundDevSettings,
+  h as resetPlaygroundDevSettings,
+  v as usePlaygroundDevSettings,
+  _ as writePlaygroundDevSettings
+};

package/dist/lib/pricing.d.ts

@@ -0,0 +1,14 @@
+import { TFunction } from 'i18next';
+import { StorefrontPublicProductPrice } from './storefrontProducts';
+export type DailyPriceRow = {
+    dayCount: number;
+    totalPriceLabel: string;
+    perDayPriceLabel: string;
+};
+export declare const formatStorefrontPriceMinor: (valueMinor: number, locale: string, { currency }?: {
+    currency?: string;
+}) => string;
+export declare function calculateDailyPriceForQuantity(prices: StorefrontPublicProductPrice[] | undefined, dayCount: number): number | null;
+export declare function buildDailyPriceRows(prices: StorefrontPublicProductPrice[] | undefined, locale: string): DailyPriceRow[];
+export declare function buildPriceTierLabels(prices: StorefrontPublicProductPrice[] | undefined, locale: string, t: TFunction): string[];
+//# sourceMappingURL=pricing.d.ts.map

package/dist/lib/pricing.js

@@ -0,0 +1,50 @@
+import { calculatePriceForQuantity as g } from "../chunks/pkg/booking-engine/dist/utils/pricing-DcnUXaeI.js";
+import { formatPriceMinor as d } from "./utils.js";
+const f = "EUR", b = 8, p = (t) => [...t].sort((r, i) => r.quantity - i.quantity), P = (t) => t.find((r) => r.currency?.trim())?.currency?.trim() || f, F = (t) => Math.abs(t) % 100 !== 0 ? {} : {
+  minimumFractionDigits: 0,
+  maximumFractionDigits: 0
+}, u = (t, r, { currency: i = f } = {}) => d(t, r, {
+  currency: i,
+  ...F(t)
+}), m = (t) => p(
+  (t ?? []).filter((r) => r.unit === "day" && r.quantity > 0)
+), _ = (t, r, i) => t === 1 ? i("price_unit_day", { count: 1 }) : `${new Intl.NumberFormat(r, {
+  maximumFractionDigits: 2,
+  minimumFractionDigits: Number.isInteger(t) ? 0 : 1
+}).format(t)} ${i("price_unit_day", { count: t })}`;
+function Q(t, r) {
+  if (!Number.isInteger(r) || r <= 0) return null;
+  const i = m(t);
+  if (i.length === 0) return null;
+  try {
+    return g(i, r, "day");
+  } catch {
+    return null;
+  }
+}
+function E(t, r) {
+  const i = m(t);
+  if (i.length === 0) return [];
+  const n = P(i);
+  return Array.from({ length: b }, (a, c) => {
+    const e = c + 1, o = Q(i, e) ?? 0, s = Math.ceil(o / e / 10) * 10;
+    return {
+      dayCount: e,
+      totalPriceLabel: u(o, r, { currency: n }),
+      perDayPriceLabel: u(s, r, { currency: n })
+    };
+  });
+}
+function I(t, r, i) {
+  const n = m(t), a = P(n);
+  return n.map((c, e) => {
+    const o = e > 0 ? n[e - 1] : void 0, s = o?.quantity ?? 0, D = o?.value ?? 0, l = c.quantity - s, y = c.value - D;
+    return l <= 0 || y < 0 ? u(c.value, r, { currency: a }) : `${u(y, r, { currency: a })} / ${_(l, r, i)}`;
+  });
+}
+export {
+  E as buildDailyPriceRows,
+  I as buildPriceTierLabels,
+  Q as calculateDailyPriceForQuantity,
+  u as formatStorefrontPriceMinor
+};

package/dist/lib/productImageStyles.d.ts

@@ -0,0 +1,9 @@
+import { CSSProperties } from 'react';
+import { StorefrontPublicImageStyle } from './storefrontProducts';
+type ProductImageContainerStyle = {
+    className: string;
+    style?: CSSProperties;
+};
+export declare const resolveProductImageContainerStyle: (primaryImageStyle?: StorefrontPublicImageStyle) => ProductImageContainerStyle;
+export {};
+//# sourceMappingURL=productImageStyles.d.ts.map

package/dist/lib/productImageStyles.js

@@ -0,0 +1,8 @@
+import { cn as e } from "@rpcbase/ui";
+const r = "bg-gradient-to-br from-slate-100 to-slate-200 border border-slate-200", t = (o) => !o || o.bgMode === "complex" ? { className: r } : o.bgMode === "transparent" ? { className: r } : o.bgColor ? {
+  className: e(o.needsLightBorder && "border border-slate-200"),
+  style: { backgroundColor: o.bgColor }
+} : { className: r };
+export {
+  t as resolveProductImageContainerStyle
+};

package/dist/lib/productVariants.d.ts

@@ -0,0 +1,13 @@
+type ProductVariantLike = {
+    id?: unknown;
+    computedName?: unknown;
+    attributes?: unknown;
+};
+export declare function getProductVariantAttributeValue(variant: ProductVariantLike, key: string): string | undefined;
+export declare function getProductVariantDisplay(variant: ProductVariantLike): {
+    label: string;
+    description?: string;
+};
+export declare const getStorefrontProductVariantDisplay: typeof getProductVariantDisplay;
+export {};
+//# sourceMappingURL=productVariants.d.ts.map

package/dist/lib/productVariants.js

@@ -0,0 +1,26 @@
+const i = (t) => typeof t == "string" ? t.trim() : "";
+function c(t) {
+  return Array.isArray(t.attributes) ? t.attributes : [];
+}
+function d(t, n) {
+  const e = n.trim();
+  if (e)
+    for (const o of c(t)) {
+      if (i(o?.key) !== e) continue;
+      const a = i(o?.value);
+      if (a) return a;
+    }
+}
+function l(t) {
+  const n = i(t.id), e = i(t.computedName), u = [c(t).map((r) => i(r.value)).filter((r) => r.length > 0).join(" · "), e, n].find((r) => r.length > 0) ?? n, s = e.length > 0 && e !== u ? e : "";
+  return {
+    label: u || n,
+    description: s || void 0
+  };
+}
+const b = l;
+export {
+  d as getProductVariantAttributeValue,
+  l as getProductVariantDisplay,
+  b as getStorefrontProductVariantDisplay
+};

package/dist/lib/products.d.ts

@@ -0,0 +1,37 @@
+import { StorefrontPublicAccessoryProduct, StorefrontPublicBikeProduct, StorefrontPublicProductPrice } from './storefrontProducts';
+import { LocalizedString } from '../localization';
+export type BikeProduct = Omit<StorefrontPublicBikeProduct, "kind"> & {
+    kind: "bike" | "e-bike";
+};
+export type AccessoryProduct = StorefrontPublicAccessoryProduct & {
+    kind: "accessory";
+};
+export type StorefrontProduct = BikeProduct | AccessoryProduct;
+type SortableStorefrontProduct = {
+    id: string;
+    prices?: StorefrontPublicProductPrice[];
+    assetRelScore?: number;
+};
+type SortableStorefrontBikeProduct = SortableStorefrontProduct & {
+    kind?: StorefrontPublicBikeProduct["kind"];
+};
+export type StorefrontProductsCollections = {
+    bikes: BikeProduct[];
+    accessories: AccessoryProduct[];
+};
+export declare const buildStorefrontProductSlug: ({ id, productShortCode, name, }: {
+    id: string;
+    productShortCode?: string | null;
+    name?: LocalizedString;
+}) => string;
+export declare function getStorefrontBaseDailyRateMinor(prices: StorefrontPublicProductPrice[] | undefined): number;
+export declare function compareStorefrontBikeProducts<T extends SortableStorefrontBikeProduct>(left: T, right: T): number;
+export declare function compareStorefrontAccessoryProducts<T extends SortableStorefrontProduct>(left: T, right: T): number;
+export declare const toStorefrontBikeProducts: (bikes: StorefrontPublicBikeProduct[]) => BikeProduct[];
+export declare const toStorefrontAccessoryProducts: (accessories: StorefrontPublicAccessoryProduct[]) => AccessoryProduct[];
+export declare const findStorefrontProduct: (id: string, products: StorefrontProductsCollections) => StorefrontProduct | null;
+export declare const findStorefrontProductBySlug: (slug: string, products: StorefrontProductsCollections) => StorefrontProduct | null;
+export declare const getStorefrontCheckoutProductId: (product: Pick<StorefrontProduct, "id" | "checkoutProductId">) => string;
+export declare const getStorefrontRepresentedVariantId: (product: Pick<StorefrontProduct, "representedVariantId">) => string | undefined;
+export {};
+//# sourceMappingURL=products.d.ts.map

package/dist/lib/products.js

@@ -0,0 +1,58 @@
+const u = /[\u0300-\u036f]/g, d = /[^a-z0-9]+/g, l = /^-+|-+$/g, i = (e) => e.normalize("NFKD").replace(u, "").toLowerCase().replace(d, "-").replace(l, ""), f = (e) => {
+  const t = e?.en?.value.trim();
+  return t || (Object.values(e ?? {}).find((r) => r.value.trim().length > 0)?.value.trim() ?? "");
+}, S = ({
+  id: e,
+  productShortCode: t,
+  name: r
+}) => {
+  const o = i(typeof t == "string" ? t.trim() : ""), n = i(f(r)), c = i(e);
+  return `product-${[o, n].filter((a) => a.length > 0).join("-") || c || "item"}`;
+};
+function s(e) {
+  const t = e?.find((r) => r.unit === "day" && r.quantity === 1);
+  return t ? t.value : -1;
+}
+function b(e, t) {
+  const r = e.kind === "e-bike" ? "e-bike" : "bike", o = t.kind === "e-bike" ? "e-bike" : "bike";
+  if (r !== o)
+    return r === "e-bike" ? -1 : 1;
+  const n = (t.assetRelScore ?? 0) - (e.assetRelScore ?? 0);
+  if (n !== 0) return n;
+  const c = s(t.prices) - s(e.prices);
+  return c !== 0 ? c : e.id.localeCompare(t.id);
+}
+function m(e, t) {
+  const r = (t.assetRelScore ?? 0) - (e.assetRelScore ?? 0);
+  if (r !== 0) return r;
+  const o = s(t.prices) - s(e.prices);
+  return o !== 0 ? o : e.id.localeCompare(t.id);
+}
+const p = (e) => e.map((t) => ({
+  ...t,
+  kind: t.kind === "e-bike" ? "e-bike" : "bike"
+})), R = (e) => e.map((t) => ({
+  ...t,
+  kind: "accessory"
+})), E = (e, t) => {
+  const r = t.bikes.find((n) => n.id === e);
+  return r || (t.accessories.find((n) => n.id === e) ?? null);
+}, y = (e, t) => {
+  const r = t.bikes.find((n) => n.slug === e);
+  return r || (t.accessories.find((n) => n.slug === e) ?? null);
+}, A = (e) => e.checkoutProductId?.trim() || e.id, P = (e) => {
+  const t = e.representedVariantId?.trim();
+  return t || void 0;
+};
+export {
+  S as buildStorefrontProductSlug,
+  m as compareStorefrontAccessoryProducts,
+  b as compareStorefrontBikeProducts,
+  E as findStorefrontProduct,
+  y as findStorefrontProductBySlug,
+  s as getStorefrontBaseDailyRateMinor,
+  A as getStorefrontCheckoutProductId,
+  P as getStorefrontRepresentedVariantId,
+  R as toStorefrontAccessoryProducts,
+  p as toStorefrontBikeProducts
+};

package/dist/lib/richAddress.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const richAddressSchema: z.ZodObject<{
+    provider: z.ZodLiteral<"google_places">;
+    placeId: z.ZodString;
+    label: z.ZodString;
+    fullLabel: z.ZodOptional<z.ZodString>;
+    formattedAddress: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+    }, z.core.$strip>>;
+    addressComponents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        longText: z.ZodString;
+        shortText: z.ZodString;
+        types: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    distanceMeters: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type RichAddress = z.infer<typeof richAddressSchema>;
+//# sourceMappingURL=richAddress.d.ts.map

package/dist/lib/richAddress.js

@@ -0,0 +1,24 @@
+import { z as t } from "zod";
+const i = t.object({
+  provider: t.literal("google_places"),
+  placeId: t.string().trim().min(1),
+  label: t.string().trim().min(1),
+  fullLabel: t.string().trim().min(1).optional(),
+  formattedAddress: t.string().trim().min(1).optional(),
+  location: t.object({
+    lat: t.number(),
+    lng: t.number()
+  }).optional(),
+  addressComponents: t.array(
+    t.object({
+      longText: t.string(),
+      shortText: t.string(),
+      types: t.array(t.string())
+    }).strict()
+  ).optional(),
+  types: t.array(t.string().trim().min(1)).optional(),
+  distanceMeters: t.number().int().nonnegative().optional()
+}).strict();
+export {
+  i as richAddressSchema
+};

package/dist/lib/securePaymentLink.d.ts

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+export declare const GET_SECURE_PAYMENT_LINK_ROUTE = "/api/public/storefront/secure-payment-link/get";
+export declare const GET_STRIPE_SECURE_PAYMENT_SESSION_ROUTE = "/api/public/storefront/secure-payment-link/stripe-session";
+export declare const GET_MOLLIE_SECURE_PAYMENT_SESSION_ROUTE = "/api/public/storefront/secure-payment-link/mollie-session";
+export declare const securePaymentLinkProviderTypeSchema: z.ZodEnum<{
+    stripe_connect_oauth: "stripe_connect_oauth";
+    mollie_connect_oauth: "mollie_connect_oauth";
+}>;
+export type SecurePaymentLinkProviderType = z.infer<typeof securePaymentLinkProviderTypeSchema>;
+export declare const securePaymentLinkStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    authorized: "authorized";
+    succeeded: "succeeded";
+    failed: "failed";
+    cancelled: "cancelled";
+    refunded: "refunded";
+}>;
+export type SecurePaymentLinkStatus = z.infer<typeof securePaymentLinkStatusSchema>;
+export declare const getSecurePaymentLinkRequestSchema: z.ZodObject<{
+    storeSlug: z.ZodString;
+    token: z.ZodString;
+}, z.core.$strip>;
+export type GetSecurePaymentLinkRequest = z.infer<typeof getSecurePaymentLinkRequestSchema>;
+export declare const getSecurePaymentLinkResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    paymentLinkSession: z.ZodOptional<z.ZodObject<{
+        token: z.ZodString;
+        storeSlug: z.ZodString;
+        saleId: z.ZodString;
+        paymentId: z.ZodString;
+        providerType: z.ZodEnum<{
+            stripe_connect_oauth: "stripe_connect_oauth";
+            mollie_connect_oauth: "mollie_connect_oauth";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            authorized: "authorized";
+            succeeded: "succeeded";
+            failed: "failed";
+            cancelled: "cancelled";
+            refunded: "refunded";
+        }>;
+        amountMinor: z.ZodNumber;
+        currency: z.ZodString;
+        reference: z.ZodString;
+        providerPaymentId: z.ZodOptional<z.ZodString>;
+        checkoutUrl: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GetSecurePaymentLinkResponse = z.infer<typeof getSecurePaymentLinkResponseSchema>;
+export declare const getStripeSecurePaymentSessionRequestSchema: z.ZodObject<{
+    storeSlug: z.ZodString;
+    token: z.ZodString;
+}, z.core.$strip>;
+export type GetStripeSecurePaymentSessionRequest = z.infer<typeof getStripeSecurePaymentSessionRequestSchema>;
+export declare const getStripeSecurePaymentSessionResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    clientSecret: z.ZodOptional<z.ZodString>;
+    stripeAccountId: z.ZodOptional<z.ZodString>;
+    payment: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        status: z.ZodString;
+        reference: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        livemode: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GetStripeSecurePaymentSessionResponse = z.infer<typeof getStripeSecurePaymentSessionResponseSchema>;
+export declare const getMollieSecurePaymentSessionRequestSchema: z.ZodObject<{
+    storeSlug: z.ZodString;
+    token: z.ZodString;
+    cardToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GetMollieSecurePaymentSessionRequest = z.infer<typeof getMollieSecurePaymentSessionRequestSchema>;
+export declare const getMollieSecurePaymentSessionResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    profileId: z.ZodOptional<z.ZodString>;
+    testmode: z.ZodOptional<z.ZodBoolean>;
+    paymentStatus: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        authorized: "authorized";
+        succeeded: "succeeded";
+        failed: "failed";
+        cancelled: "cancelled";
+        refunded: "refunded";
+    }>>;
+    checkoutUrl: z.ZodOptional<z.ZodString>;
+    payment: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        status: z.ZodString;
+        reference: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        livemode: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GetMollieSecurePaymentSessionResponse = z.infer<typeof getMollieSecurePaymentSessionResponseSchema>;
+//# sourceMappingURL=securePaymentLink.d.ts.map

package/dist/lib/securePaymentLink.js

@@ -0,0 +1,79 @@
+import { z as e } from "zod";
+const o = "/api/public/storefront/secure-payment-link/get", s = "/api/public/storefront/secure-payment-link/stripe-session", r = "/api/public/storefront/secure-payment-link/mollie-session", n = e.enum(["stripe_connect_oauth", "mollie_connect_oauth"]), t = e.enum([
+  "pending",
+  "authorized",
+  "succeeded",
+  "failed",
+  "cancelled",
+  "refunded"
+]), c = e.object({
+  storeSlug: e.string().trim().min(1).toLowerCase(),
+  token: e.string().trim().min(1)
+}), a = e.object({
+  success: e.boolean(),
+  message: e.string(),
+  paymentLinkSession: e.object({
+    token: e.string().trim().min(1),
+    storeSlug: e.string().trim().min(1),
+    saleId: e.string().trim().min(1),
+    paymentId: e.string().trim().min(1),
+    providerType: n,
+    status: t,
+    amountMinor: e.number().int().positive(),
+    currency: e.string().trim().min(1),
+    reference: e.string().trim().min(1),
+    providerPaymentId: e.string().trim().min(1).optional(),
+    checkoutUrl: e.string().url().optional(),
+    expiresAt: e.string()
+  }).optional()
+}), m = e.object({
+  storeSlug: e.string().trim().min(1).toLowerCase(),
+  token: e.string().trim().min(1)
+}), l = e.object({
+  success: e.boolean(),
+  message: e.string(),
+  clientSecret: e.string().optional(),
+  stripeAccountId: e.string().optional(),
+  payment: e.object({
+    id: e.string(),
+    amount: e.number().int().positive(),
+    currency: e.string(),
+    status: e.string(),
+    reference: e.string().optional(),
+    description: e.string().optional(),
+    livemode: e.boolean()
+  }).optional()
+}), p = e.object({
+  storeSlug: e.string().trim().min(1).toLowerCase(),
+  token: e.string().trim().min(1),
+  cardToken: e.string().trim().min(1).optional()
+}), u = e.object({
+  success: e.boolean(),
+  message: e.string(),
+  profileId: e.string().optional(),
+  testmode: e.boolean().optional(),
+  paymentStatus: t.optional(),
+  checkoutUrl: e.string().url().optional(),
+  payment: e.object({
+    id: e.string(),
+    amount: e.number().int().positive(),
+    currency: e.string(),
+    status: e.string(),
+    reference: e.string().optional(),
+    description: e.string().optional(),
+    livemode: e.boolean()
+  }).optional()
+});
+export {
+  r as GET_MOLLIE_SECURE_PAYMENT_SESSION_ROUTE,
+  o as GET_SECURE_PAYMENT_LINK_ROUTE,
+  s as GET_STRIPE_SECURE_PAYMENT_SESSION_ROUTE,
+  p as getMollieSecurePaymentSessionRequestSchema,
+  u as getMollieSecurePaymentSessionResponseSchema,
+  c as getSecurePaymentLinkRequestSchema,
+  a as getSecurePaymentLinkResponseSchema,
+  m as getStripeSecurePaymentSessionRequestSchema,
+  l as getStripeSecurePaymentSessionResponseSchema,
+  n as securePaymentLinkProviderTypeSchema,
+  t as securePaymentLinkStatusSchema
+};

package/dist/lib/storefrontAvailability.d.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+export declare const ROUTE = "/api/public/storefront/availability/check";
+export declare const storefrontAvailabilityScheduleSchema: z.ZodObject<{
+    startDate: z.ZodString;
+    endDate: z.ZodString;
+    startTime: z.ZodString;
+    endTime: z.ZodString;
+}, z.core.$strip>;
+export type StorefrontAvailabilitySchedule = z.infer<typeof storefrontAvailabilityScheduleSchema>;
+export declare const storefrontAvailabilityProductSchema: z.ZodObject<{
+    productId: z.ZodString;
+    productVariantId: z.ZodOptional<z.ZodString>;
+    quantity: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type StorefrontAvailabilityProduct = z.infer<typeof storefrontAvailabilityProductSchema>;
+export declare const requestSchema: z.ZodObject<{
+    storeSlug: z.ZodString;
+    schedule: z.ZodObject<{
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+        startTime: z.ZodString;
+        endTime: z.ZodString;
+    }, z.core.$strip>;
+    products: z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        productVariantId: z.ZodOptional<z.ZodString>;
+        quantity: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RequestPayload = z.infer<typeof requestSchema>;
+export declare const publicAvailabilityDisplayModeSchema: z.ZodEnum<{
+    soldOutOnly: "soldOutOnly";
+    soldOutAndFewRemaining: "soldOutAndFewRemaining";
+    fewRemaining: "fewRemaining";
+    fewRemainingCounts: "fewRemainingCounts";
+    remainingCounts: "remainingCounts";
+}>;
+export type PublicAvailabilityDisplayMode = z.infer<typeof publicAvailabilityDisplayModeSchema>;
+export declare const storefrontPublicAvailabilityRecordSchema: z.ZodObject<{
+    productId: z.ZodString;
+    productVariantId: z.ZodOptional<z.ZodString>;
+    displayMode: z.ZodEnum<{
+        soldOutOnly: "soldOutOnly";
+        soldOutAndFewRemaining: "soldOutAndFewRemaining";
+        fewRemaining: "fewRemaining";
+        fewRemainingCounts: "fewRemainingCounts";
+        remainingCounts: "remainingCounts";
+    }>;
+    soldOut: z.ZodBoolean;
+    insufficientCapacity: z.ZodOptional<z.ZodBoolean>;
+    fewRemaining: z.ZodOptional<z.ZodBoolean>;
+    remaining: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type StorefrontPublicAvailabilityRecord = z.infer<typeof storefrontPublicAvailabilityRecordSchema>;
+export type StorefrontAvailabilityIssue = "unavailable" | "quantity_unavailable";
+export declare const responseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodOptional<z.ZodString>;
+    availability: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        productVariantId: z.ZodOptional<z.ZodString>;
+        displayMode: z.ZodEnum<{
+            soldOutOnly: "soldOutOnly";
+            soldOutAndFewRemaining: "soldOutAndFewRemaining";
+            fewRemaining: "fewRemaining";
+            fewRemainingCounts: "fewRemainingCounts";
+            remainingCounts: "remainingCounts";
+        }>;
+        soldOut: z.ZodBoolean;
+        insufficientCapacity: z.ZodOptional<z.ZodBoolean>;
+        fewRemaining: z.ZodOptional<z.ZodBoolean>;
+        remaining: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ResponsePayload = z.infer<typeof responseSchema>;
+export declare const buildStorefrontAvailabilityKey: (productId: string, productVariantId?: string | null) => string;
+export declare const doesStorefrontAvailabilityDisplaySoldOut: (displayMode: PublicAvailabilityDisplayMode | undefined) => boolean;
+export declare const shouldBlockStorefrontUnavailableItem: (record: StorefrontPublicAvailabilityRecord | undefined) => boolean;
+export declare const isStorefrontAvailabilityInsufficient: (record: StorefrontPublicAvailabilityRecord | undefined) => boolean;
+export declare const getStorefrontAvailabilityIssue: (record: StorefrontPublicAvailabilityRecord | undefined) => StorefrontAvailabilityIssue | undefined;
+export declare const getStorefrontAvailabilityStatus: (record: StorefrontPublicAvailabilityRecord | undefined) => "AVAILABLE" | "LOW_STOCK" | "OUT_OF_STOCK";
+//# sourceMappingURL=storefrontAvailability.d.ts.map

package/dist/lib/storefrontAvailability.js

@@ -0,0 +1,54 @@
+import { z as t } from "zod";
+const m = "/api/public/storefront/availability/check", a = t.object({
+  startDate: t.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  endDate: t.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  startTime: t.string().regex(/^\d{2}:\d{2}$/),
+  endTime: t.string().regex(/^\d{2}:\d{2}$/)
+}), r = t.object({
+  productId: t.string().trim().min(1),
+  productVariantId: t.string().trim().min(1).optional(),
+  quantity: t.number().int().positive().optional()
+}), b = t.object({
+  storeSlug: t.string().trim().min(1).toLowerCase(),
+  schedule: a,
+  products: t.array(r).min(1)
+}), s = t.enum([
+  "soldOutOnly",
+  "soldOutAndFewRemaining",
+  "fewRemaining",
+  "fewRemainingCounts",
+  "remainingCounts"
+]), l = t.object({
+  productId: t.string().trim().min(1),
+  productVariantId: t.string().trim().min(1).optional(),
+  displayMode: s,
+  soldOut: t.boolean(),
+  insufficientCapacity: t.boolean().optional(),
+  fewRemaining: t.boolean().optional(),
+  remaining: t.number().int().min(0).optional()
+}), f = t.object({
+  success: t.boolean(),
+  message: t.string().optional(),
+  availability: t.array(l).optional()
+}), g = (i, o) => {
+  const n = i.trim().toLowerCase(), e = o?.trim().toLowerCase();
+  return e ? `${n}::${e}` : n;
+}, u = (i) => i === "soldOutOnly" || i === "soldOutAndFewRemaining", p = (i) => i?.soldOut === !0 && u(i.displayMode), c = (i) => i?.insufficientCapacity === !0 || i?.soldOut === !0, y = (i) => {
+  if (i?.soldOut === !0) return "unavailable";
+  if (i?.insufficientCapacity === !0) return "quantity_unavailable";
+}, S = (i) => c(i) ? "OUT_OF_STOCK" : i?.fewRemaining ? "LOW_STOCK" : "AVAILABLE";
+export {
+  m as ROUTE,
+  g as buildStorefrontAvailabilityKey,
+  u as doesStorefrontAvailabilityDisplaySoldOut,
+  y as getStorefrontAvailabilityIssue,
+  S as getStorefrontAvailabilityStatus,
+  c as isStorefrontAvailabilityInsufficient,
+  s as publicAvailabilityDisplayModeSchema,
+  b as requestSchema,
+  f as responseSchema,
+  p as shouldBlockStorefrontUnavailableItem,
+  r as storefrontAvailabilityProductSchema,
+  a as storefrontAvailabilityScheduleSchema,
+  l as storefrontPublicAvailabilityRecordSchema
+};

package/dist/lib/storefrontImage.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const ROUTE = "/api/public/storefront/images/get";
+export declare const requestSchema: z.ZodObject<{
+    imageId: z.ZodString;
+    storeSlug: z.ZodString;
+}, z.core.$strip>;
+export type RequestPayload = z.infer<typeof requestSchema>;
+export declare const buildStorefrontImageUrl: (imageId: string, storeSlug: string) => string;
+//# sourceMappingURL=storefrontImage.d.ts.map