@medalsocial/booking 0.0.0-placeholder.0 → 0.2.0

package/dist/next/server.mjs

@@ -0,0 +1,63 @@
+import { createBookingRuntime } from "./runtime.mjs";
+import { createBookingHandlerFor } from "./handler.mjs";
+import { loadBookingPage as loadBookingPage$1, loadManagePage as loadManagePage$1, loadPortalPage as loadPortalPage$1 } from "./loaders.mjs";
+import { createPortalFor } from "./portal.mjs";
+//#region src/next/server.ts
+/**
+* One call that wires a booking site's server half.
+*
+* ```ts
+* // lib/booking/server.ts
+* import 'server-only';
+* import { createBookingServer } from '@medalsocial/booking/next';
+* export const booking = createBookingServer({ config, medal, cache, … });
+*
+* // app/api/booking/[...path]/route.ts (and app/api/portal/[...path]/route.ts)
+* export const { GET, POST, DELETE } = booking.handler;
+* ```
+*
+* The handler, the loaders and the portal share one runtime, so in-flight
+* refreshes and Medal clients are shared too. The standalone functions
+* (`createBookingHandler`, `loadBookingPage`, …) reuse the runtime built for
+* the same options object.
+*/
+const RUNTIMES = /* @__PURE__ */ new WeakMap();
+function runtimeFor(options) {
+	const known = RUNTIMES.get(options);
+	if (known) return known;
+	const built = createBookingRuntime(options);
+	RUNTIMES.set(options, built);
+	return built;
+}
+function createBookingServer(options) {
+	return serverFor(runtimeFor(options));
+}
+/** The same, over a runtime the caller built (tests, unusual wiring). */
+function serverFor(rt) {
+	return {
+		handler: createBookingHandlerFor(rt),
+		portal: createPortalFor(rt),
+		loadBookingPage: (args) => loadBookingPage$1(rt, args),
+		loadManagePage: (token, switches) => loadManagePage$1(rt, token, switches),
+		loadPortalPage: (switches) => loadPortalPage$1(rt, switches)
+	};
+}
+function createBookingHandler(options) {
+	return createBookingHandlerFor(runtimeFor(options));
+}
+function createPortal(options) {
+	return createPortalFor(runtimeFor(options));
+}
+function loadBookingPage(options, args) {
+	return loadBookingPage$1(runtimeFor(options), args);
+}
+function loadManagePage(options, token, switches) {
+	return loadManagePage$1(runtimeFor(options), token, switches);
+}
+function loadPortalPage(options, switches) {
+	return loadPortalPage$1(runtimeFor(options), switches);
+}
+//#endregion
+export { createBookingHandler, createBookingServer, createPortal, loadBookingPage, loadManagePage, loadPortalPage, serverFor };
+
+//# sourceMappingURL=server.mjs.map

package/dist/next/server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.mjs","names":["loadBookingPageFor","loadManagePageFor","loadPortalPageFor"],"sources":["../../src/next/server.ts"],"sourcesContent":["/**\n * One call that wires a booking site's server half.\n *\n * ```ts\n * // lib/booking/server.ts\n * import 'server-only';\n * import { createBookingServer } from '@medalsocial/booking/next';\n * export const booking = createBookingServer({ config, medal, cache, … });\n *\n * // app/api/booking/[...path]/route.ts (and app/api/portal/[...path]/route.ts)\n * export const { GET, POST, DELETE } = booking.handler;\n * ```\n *\n * The handler, the loaders and the portal share one runtime, so in-flight\n * refreshes and Medal clients are shared too. The standalone functions\n * (`createBookingHandler`, `loadBookingPage`, …) reuse the runtime built for\n * the same options object.\n */\n\nimport { createBookingHandlerFor } from './handler';\nimport {\n  type BookingPageResult,\n  loadBookingPage as loadBookingPageFor,\n  loadManagePage as loadManagePageFor,\n  loadPortalPage as loadPortalPageFor,\n  type ManagePageResult,\n  type PageSwitches,\n  type PortalPageResult,\n} from './loaders';\nimport type { BookingServerOptions } from './options';\nimport { createPortalFor, type Portal } from './portal';\nimport { type BookingRuntime, createBookingRuntime } from './runtime';\n\nconst RUNTIMES = new WeakMap<BookingServerOptions, BookingRuntime>();\n\nfunction runtimeFor(options: BookingServerOptions): BookingRuntime {\n  const known = RUNTIMES.get(options);\n  if (known) return known;\n  const built = createBookingRuntime(options);\n  RUNTIMES.set(options, built);\n  return built;\n}\n\ntype SearchParams = Record<string, string | string[] | undefined>;\n\nexport interface BookingServer {\n  handler: ReturnType<typeof createBookingHandlerFor>;\n  portal: Portal;\n  loadBookingPage(\n    args?: PageSwitches & { searchParams?: SearchParams }\n  ): Promise<BookingPageResult>;\n  loadManagePage(token: string, switches?: PageSwitches): Promise<ManagePageResult>;\n  loadPortalPage(switches?: PageSwitches): Promise<PortalPageResult>;\n}\n\nexport function createBookingServer(options: BookingServerOptions): BookingServer {\n  return serverFor(runtimeFor(options));\n}\n\n/** The same, over a runtime the caller built (tests, unusual wiring). */\nexport function serverFor(rt: BookingRuntime): BookingServer {\n  return {\n    handler: createBookingHandlerFor(rt),\n    portal: createPortalFor(rt),\n    loadBookingPage: (args) => loadBookingPageFor(rt, args),\n    loadManagePage: (token, switches) => loadManagePageFor(rt, token, switches),\n    loadPortalPage: (switches) => loadPortalPageFor(rt, switches),\n  };\n}\n\nexport function createBookingHandler(options: BookingServerOptions) {\n  return createBookingHandlerFor(runtimeFor(options));\n}\n\nexport function createPortal(options: BookingServerOptions): Portal {\n  return createPortalFor(runtimeFor(options));\n}\n\nexport function loadBookingPage(\n  options: BookingServerOptions,\n  args?: PageSwitches & { searchParams?: SearchParams }\n): Promise<BookingPageResult> {\n  return loadBookingPageFor(runtimeFor(options), args);\n}\n\nexport function loadManagePage(\n  options: BookingServerOptions,\n  token: string,\n  switches?: PageSwitches\n): Promise<ManagePageResult> {\n  return loadManagePageFor(runtimeFor(options), token, switches);\n}\n\nexport function loadPortalPage(\n  options: BookingServerOptions,\n  switches?: PageSwitches\n): Promise<PortalPageResult> {\n  return loadPortalPageFor(runtimeFor(options), switches);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAiCA,MAAM,2BAAW,IAAI,QAA8C;AAEnE,SAAS,WAAW,SAA+C;CACjE,MAAM,QAAQ,SAAS,IAAI,OAAO;CAClC,IAAI,OAAO,OAAO;CAClB,MAAM,QAAQ,qBAAqB,OAAO;CAC1C,SAAS,IAAI,SAAS,KAAK;CAC3B,OAAO;AACT;AAcA,SAAgB,oBAAoB,SAA8C;CAChF,OAAO,UAAU,WAAW,OAAO,CAAC;AACtC;;AAGA,SAAgB,UAAU,IAAmC;CAC3D,OAAO;EACL,SAAS,wBAAwB,EAAE;EACnC,QAAQ,gBAAgB,EAAE;EAC1B,kBAAkB,SAASA,kBAAmB,IAAI,IAAI;EACtD,iBAAiB,OAAO,aAAaC,iBAAkB,IAAI,OAAO,QAAQ;EAC1E,iBAAiB,aAAaC,iBAAkB,IAAI,QAAQ;CAC9D;AACF;AAEA,SAAgB,qBAAqB,SAA+B;CAClE,OAAO,wBAAwB,WAAW,OAAO,CAAC;AACpD;AAEA,SAAgB,aAAa,SAAuC;CAClE,OAAO,gBAAgB,WAAW,OAAO,CAAC;AAC5C;AAEA,SAAgB,gBACd,SACA,MAC4B;CAC5B,OAAOF,kBAAmB,WAAW,OAAO,GAAG,IAAI;AACrD;AAEA,SAAgB,eACd,SACA,OACA,UAC2B;CAC3B,OAAOC,iBAAkB,WAAW,OAAO,GAAG,OAAO,QAAQ;AAC/D;AAEA,SAAgB,eACd,SACA,UAC2B;CAC3B,OAAOC,iBAAkB,WAAW,OAAO,GAAG,QAAQ;AACxD"}

package/dist/react/BookingLink.d.mts

@@ -0,0 +1,61 @@
+import { BookingConfig } from "../core/config.mjs";
+import { BookingOverrides } from "./Provider.mjs";
+import Link from "next/link";
+import { ComponentProps } from "react";
+//#region src/react/BookingLink.d.ts
+/**
+ * Every in-site link into the booking page, so the one tap a site exists for
+ * never waits on a blank screen.
+ *
+ * PREFETCH. The booking page is dynamic, and a dynamic route with no
+ * `loading.js` is prefetched only down to its layout. So the bare booking
+ * path is prefetched in FULL (`prefetch`), once per page view however many
+ * buttons point at it. A deep link (`?kategori=barn`) is a different URL and
+ * a different server render, and a home page may carry a dozen, so those
+ * switch to a full prefetch only on intent — hover, or the touch that starts a
+ * tap.
+ *
+ * FEEDBACK. A route `loading.tsx` would stream a shell before the page runs,
+ * and a booking page that hands off to another provider answers with a
+ * redirect: the shell would turn it into a client redirect after a flash. So
+ * `:active` presses the button in the tap's frame, and while the navigation is
+ * still pending `BookingPendingHost` draws the booking frame over the page.
+ */
+type PathsConfig = Pick<BookingConfig, 'paths'>;
+/** A link into the booking page, with or without a query; `null` for anything else. */
+export declare function bookingTarget(href: string, config: PathsConfig): 'bare' | 'deep' | null;
+/** The `next/link` prefetch props for one href. */
+export declare function bookingPrefetch(href: string, config: PathsConfig): {
+  prefetch?: boolean;
+  unstable_dynamicOnHover?: boolean;
+};
+/** Fired by a booking link on a plain tap; heard by `BookingPendingHost`. */
+export declare const BOOKING_NAVIGATION_EVENT = "medal-booking:navigation";
+/** A navigation that lands inside this never shows the frame at all. */
+export declare const PENDING_DELAY_MS = 120;
+/** A navigation that never lands (offline, aborted) stops covering the page. */
+export declare const PENDING_TIMEOUT_MS = 12000;
+/**
+ * Draws the booking frame (meda's `BookingSkeleton`) for a navigation into
+ * the booking page that is taking a moment, and removes it when the route
+ * lands.
+ *
+ * In the root layout, not in the link: the link that was tapped may be gone
+ * before the navigation is — a menu overlay closes on the same tap — and the
+ * frame has to outlive it. Shown only after `PENDING_DELAY_MS`, so a
+ * prefetched navigation (the usual case) never flashes it.
+ */
+export declare function BookingPendingHost(props: BookingOverrides): import("react").JSX.Element | null;
+export type BookingLinkProps = Omit<ComponentProps<typeof Link>, 'prefetch' | 'href'> & {
+  href: string;
+  /** The site's config; or the nearest `BookingProvider`'s. */
+  config?: Readonly<BookingConfig>;
+};
+/**
+ * `next/link` for a booking destination. Anything that is not the booking
+ * page — a landing page, the price list — passes straight through, so callers
+ * can hand it whatever their CMS field holds.
+ */
+export declare function BookingLink({ href, children, onClick, target, config, ...rest }: BookingLinkProps): import("react").JSX.Element;
+//#endregion
+//# sourceMappingURL=BookingLink.d.mts.map

package/dist/react/BookingLink.mjs

@@ -0,0 +1,102 @@
+'use client';
+import { useBookingKit } from "./Provider.mjs";
+import { screenLabels } from "./screen-labels.mjs";
+import { BookingSkeleton } from "@medalsocial/meda/booking";
+import Link from "next/link";
+import { usePathname } from "next/navigation";
+import { useEffect, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/react/BookingLink.tsx
+/** A link into the booking page, with or without a query; `null` for anything else. */
+function bookingTarget(href, config) {
+	const path = config.paths.booking;
+	if (href === path) return "bare";
+	return href.startsWith(`${path}?`) ? "deep" : null;
+}
+/** The `next/link` prefetch props for one href. */
+function bookingPrefetch(href, config) {
+	const target = bookingTarget(href, config);
+	if (target === "bare") return { prefetch: true };
+	if (target === "deep") return { unstable_dynamicOnHover: true };
+	return {};
+}
+/** Fired by a booking link on a plain tap; heard by `BookingPendingHost`. */
+const BOOKING_NAVIGATION_EVENT = "medal-booking:navigation";
+/** A navigation that lands inside this never shows the frame at all. */
+const PENDING_DELAY_MS = 120;
+/** A navigation that never lands (offline, aborted) stops covering the page. */
+const PENDING_TIMEOUT_MS = 12e3;
+/** Only a tap the router will handle in this tab: not ⌘/ctrl/shift-click. */
+function isPlainTap(event) {
+	return !event.defaultPrevented && event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey;
+}
+/**
+* Draws the booking frame (meda's `BookingSkeleton`) for a navigation into
+* the booking page that is taking a moment, and removes it when the route
+* lands.
+*
+* In the root layout, not in the link: the link that was tapped may be gone
+* before the navigation is — a menu overlay closes on the same tap — and the
+* frame has to outlive it. Shown only after `PENDING_DELAY_MS`, so a
+* prefetched navigation (the usual case) never flashes it.
+*/
+function BookingPendingHost(props) {
+	const { kit, classNames } = useBookingKit(props);
+	const pathname = usePathname();
+	const [visible, setVisible] = useState(false);
+	const timers = useRef([]);
+	useEffect(() => {
+		const clear = () => {
+			for (const timer of timers.current) window.clearTimeout(timer);
+			timers.current = [];
+		};
+		const start = () => {
+			clear();
+			timers.current = [window.setTimeout(() => setVisible(true), 120), window.setTimeout(() => setVisible(false), PENDING_TIMEOUT_MS)];
+		};
+		const stop = () => {
+			clear();
+			setVisible(false);
+		};
+		window.addEventListener(BOOKING_NAVIGATION_EVENT, start);
+		window.addEventListener("popstate", stop);
+		return () => {
+			clear();
+			window.removeEventListener(BOOKING_NAVIGATION_EVENT, start);
+			window.removeEventListener("popstate", stop);
+		};
+	}, []);
+	useEffect(() => {
+		for (const timer of timers.current) window.clearTimeout(timer);
+		timers.current = [];
+		setVisible(false);
+	}, [pathname]);
+	return visible ? /* @__PURE__ */ jsx(BookingSkeleton, {
+		labels: screenLabels(kit.labels),
+		classNames: classNames.skeleton
+	}) : null;
+}
+/**
+* `next/link` for a booking destination. Anything that is not the booking
+* page — a landing page, the price list — passes straight through, so callers
+* can hand it whatever their CMS field holds.
+*/
+function BookingLink({ href, children, onClick, target, config, ...rest }) {
+	const paths = useBookingKit({ config }).kit.config;
+	const booking = bookingTarget(href, paths) !== null;
+	return /* @__PURE__ */ jsx(Link, {
+		href,
+		target,
+		...bookingPrefetch(href, paths),
+		onClick: (event) => {
+			onClick?.(event);
+			if (booking && !target && isPlainTap(event) && window.location.pathname !== paths.paths.booking) window.dispatchEvent(new Event(BOOKING_NAVIGATION_EVENT));
+		},
+		...rest,
+		children
+	});
+}
+//#endregion
+export { BOOKING_NAVIGATION_EVENT, BookingLink, BookingPendingHost, PENDING_DELAY_MS, PENDING_TIMEOUT_MS, bookingPrefetch, bookingTarget };
+
+//# sourceMappingURL=BookingLink.mjs.map

package/dist/react/BookingLink.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BookingLink.mjs","names":[],"sources":["../../src/react/BookingLink.tsx"],"sourcesContent":["import { BookingSkeleton } from '@medalsocial/meda/booking';\nimport Link from 'next/link';\nimport { usePathname } from 'next/navigation';\nimport { type ComponentProps, type MouseEvent, useEffect, useRef, useState } from 'react';\nimport type { BookingConfig } from '../core/config';\nimport { type BookingOverrides, useBookingKit } from './Provider';\nimport { screenLabels } from './screen-labels';\n\n/**\n * Every in-site link into the booking page, so the one tap a site exists for\n * never waits on a blank screen.\n *\n * PREFETCH. The booking page is dynamic, and a dynamic route with no\n * `loading.js` is prefetched only down to its layout. So the bare booking\n * path is prefetched in FULL (`prefetch`), once per page view however many\n * buttons point at it. A deep link (`?kategori=barn`) is a different URL and\n * a different server render, and a home page may carry a dozen, so those\n * switch to a full prefetch only on intent — hover, or the touch that starts a\n * tap.\n *\n * FEEDBACK. A route `loading.tsx` would stream a shell before the page runs,\n * and a booking page that hands off to another provider answers with a\n * redirect: the shell would turn it into a client redirect after a flash. So\n * `:active` presses the button in the tap's frame, and while the navigation is\n * still pending `BookingPendingHost` draws the booking frame over the page.\n */\n\ntype PathsConfig = Pick<BookingConfig, 'paths'>;\n\n/** A link into the booking page, with or without a query; `null` for anything else. */\nexport function bookingTarget(href: string, config: PathsConfig): 'bare' | 'deep' | null {\n  const path = config.paths.booking;\n  if (href === path) return 'bare';\n  return href.startsWith(`${path}?`) ? 'deep' : null;\n}\n\n/** The `next/link` prefetch props for one href. */\nexport function bookingPrefetch(\n  href: string,\n  config: PathsConfig\n): { prefetch?: boolean; unstable_dynamicOnHover?: boolean } {\n  const target = bookingTarget(href, config);\n  if (target === 'bare') return { prefetch: true };\n  if (target === 'deep') return { unstable_dynamicOnHover: true };\n  return {};\n}\n\n/** Fired by a booking link on a plain tap; heard by `BookingPendingHost`. */\nexport const BOOKING_NAVIGATION_EVENT = 'medal-booking:navigation';\n/** A navigation that lands inside this never shows the frame at all. */\nexport const PENDING_DELAY_MS = 120;\n/** A navigation that never lands (offline, aborted) stops covering the page. */\nexport const PENDING_TIMEOUT_MS = 12_000;\n\n/** Only a tap the router will handle in this tab: not ⌘/ctrl/shift-click. */\nfunction isPlainTap(event: MouseEvent<HTMLAnchorElement>): boolean {\n  return (\n    !event.defaultPrevented &&\n    event.button === 0 &&\n    !event.metaKey &&\n    !event.ctrlKey &&\n    !event.shiftKey &&\n    !event.altKey\n  );\n}\n\n/**\n * Draws the booking frame (meda's `BookingSkeleton`) for a navigation into\n * the booking page that is taking a moment, and removes it when the route\n * lands.\n *\n * In the root layout, not in the link: the link that was tapped may be gone\n * before the navigation is — a menu overlay closes on the same tap — and the\n * frame has to outlive it. Shown only after `PENDING_DELAY_MS`, so a\n * prefetched navigation (the usual case) never flashes it.\n */\nexport function BookingPendingHost(props: BookingOverrides) {\n  const { kit, classNames } = useBookingKit(props);\n  const pathname = usePathname();\n  const [visible, setVisible] = useState(false);\n  const timers = useRef<number[]>([]);\n\n  useEffect(() => {\n    const clear = () => {\n      for (const timer of timers.current) window.clearTimeout(timer);\n      timers.current = [];\n    };\n    const start = () => {\n      clear();\n      timers.current = [\n        window.setTimeout(() => setVisible(true), PENDING_DELAY_MS),\n        window.setTimeout(() => setVisible(false), PENDING_TIMEOUT_MS),\n      ];\n    };\n    const stop = () => {\n      clear();\n      setVisible(false);\n    };\n    window.addEventListener(BOOKING_NAVIGATION_EVENT, start);\n    window.addEventListener('popstate', stop);\n    return () => {\n      clear();\n      window.removeEventListener(BOOKING_NAVIGATION_EVENT, start);\n      window.removeEventListener('popstate', stop);\n    };\n  }, []);\n\n  // The route landed (or the visitor went elsewhere): the frame's job is done.\n  // biome-ignore lint/correctness/useExhaustiveDependencies: runs on arrival, keyed by the path.\n  useEffect(() => {\n    for (const timer of timers.current) window.clearTimeout(timer);\n    timers.current = [];\n    setVisible(false);\n  }, [pathname]);\n\n  return visible ? (\n    <BookingSkeleton labels={screenLabels(kit.labels)} classNames={classNames.skeleton} />\n  ) : null;\n}\n\nexport type BookingLinkProps = Omit<ComponentProps<typeof Link>, 'prefetch' | 'href'> & {\n  href: string;\n  /** The site's config; or the nearest `BookingProvider`'s. */\n  config?: Readonly<BookingConfig>;\n};\n\n/**\n * `next/link` for a booking destination. Anything that is not the booking\n * page — a landing page, the price list — passes straight through, so callers\n * can hand it whatever their CMS field holds.\n */\nexport function BookingLink({\n  href,\n  children,\n  onClick,\n  target,\n  config,\n  ...rest\n}: BookingLinkProps) {\n  const paths = useBookingKit({ config }).kit.config;\n  const booking = bookingTarget(href, paths) !== null;\n  return (\n    <Link\n      href={href}\n      target={target}\n      {...bookingPrefetch(href, paths)}\n      onClick={(event) => {\n        onClick?.(event);\n        // Unless we are already there: no navigation is coming to end it.\n        if (\n          booking &&\n          !target &&\n          isPlainTap(event) &&\n          window.location.pathname !== paths.paths.booking\n        ) {\n          window.dispatchEvent(new Event(BOOKING_NAVIGATION_EVENT));\n        }\n      }}\n      {...rest}\n    >\n      {children}\n    </Link>\n  );\n}\n"],"mappings":";;;;;;;;;;AA8BA,SAAgB,cAAc,MAAc,QAA6C;CACvF,MAAM,OAAO,OAAO,MAAM;CAC1B,IAAI,SAAS,MAAM,OAAO;CAC1B,OAAO,KAAK,WAAW,GAAG,KAAK,EAAE,IAAI,SAAS;AAChD;;AAGA,SAAgB,gBACd,MACA,QAC2D;CAC3D,MAAM,SAAS,cAAc,MAAM,MAAM;CACzC,IAAI,WAAW,QAAQ,OAAO,EAAE,UAAU,KAAK;CAC/C,IAAI,WAAW,QAAQ,OAAO,EAAE,yBAAyB,KAAK;CAC9D,OAAO,CAAC;AACV;;AAGA,MAAa,2BAA2B;;AAExC,MAAa,mBAAmB;;AAEhC,MAAa,qBAAqB;;AAGlC,SAAS,WAAW,OAA+C;CACjE,OACE,CAAC,MAAM,oBACP,MAAM,WAAW,KACjB,CAAC,MAAM,WACP,CAAC,MAAM,WACP,CAAC,MAAM,YACP,CAAC,MAAM;AAEX;;;;;;;;;;;AAYA,SAAgB,mBAAmB,OAAyB;CAC1D,MAAM,EAAE,KAAK,eAAe,cAAc,KAAK;CAC/C,MAAM,WAAW,YAAY;CAC7B,MAAM,CAAC,SAAS,cAAc,SAAS,KAAK;CAC5C,MAAM,SAAS,OAAiB,CAAC,CAAC;CAElC,gBAAgB;EACd,MAAM,cAAc;GAClB,KAAK,MAAM,SAAS,OAAO,SAAS,OAAO,aAAa,KAAK;GAC7D,OAAO,UAAU,CAAC;EACpB;EACA,MAAM,cAAc;GAClB,MAAM;GACN,OAAO,UAAU,CACf,OAAO,iBAAiB,WAAW,IAAI,GAAA,GAAmB,GAC1D,OAAO,iBAAiB,WAAW,KAAK,GAAG,kBAAkB,CAC/D;EACF;EACA,MAAM,aAAa;GACjB,MAAM;GACN,WAAW,KAAK;EAClB;EACA,OAAO,iBAAiB,0BAA0B,KAAK;EACvD,OAAO,iBAAiB,YAAY,IAAI;EACxC,aAAa;GACX,MAAM;GACN,OAAO,oBAAoB,0BAA0B,KAAK;GAC1D,OAAO,oBAAoB,YAAY,IAAI;EAC7C;CACF,GAAG,CAAC,CAAC;CAIL,gBAAgB;EACd,KAAK,MAAM,SAAS,OAAO,SAAS,OAAO,aAAa,KAAK;EAC7D,OAAO,UAAU,CAAC;EAClB,WAAW,KAAK;CAClB,GAAG,CAAC,QAAQ,CAAC;CAEb,OAAO,UACL,oBAAC,iBAAD;EAAiB,QAAQ,aAAa,IAAI,MAAM;EAAG,YAAY,WAAW;CAAW,CAAA,IACnF;AACN;;;;;;AAaA,SAAgB,YAAY,EAC1B,MACA,UACA,SACA,QACA,QACA,GAAG,QACgB;CACnB,MAAM,QAAQ,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI;CAC5C,MAAM,UAAU,cAAc,MAAM,KAAK,MAAM;CAC/C,OACE,oBAAC,MAAD;EACQ;EACE;EACR,GAAI,gBAAgB,MAAM,KAAK;EAC/B,UAAU,UAAU;GAClB,UAAU,KAAK;GAEf,IACE,WACA,CAAC,UACD,WAAW,KAAK,KAChB,OAAO,SAAS,aAAa,MAAM,MAAM,SAEzC,OAAO,cAAc,IAAI,MAAM,wBAAwB,CAAC;EAE5D;EACA,GAAI;EAEH;CACG,CAAA;AAEV"}

package/dist/react/BookingWizard.d.mts

@@ -0,0 +1,49 @@
+import { WizardState, WizardStep } from "../core/machine.mjs";
+import { PortalActions } from "./actions.mjs";
+import { BookingOverrides } from "./Provider.mjs";
+import { BookingSeed, useBooking } from "./useBooking.mjs";
+//#region src/react/BookingWizard.d.ts
+export interface BookingWizardProps extends BookingOverrides {
+  /** What the page prefetched (the `/next` loader's seed). */
+  seed: BookingSeed;
+  /** This request's phone and address, over `config.contact` (the loader's `contact`). */
+  contact?: {
+    phone?: string | null;
+    address?: string | null;
+  };
+  /** The parent the page found a portal session for; `null` for a guest. */
+  guardian?: BookingGuardianProp;
+  /**
+   * The app's server actions for the login sheet (Decision 8). Without them —
+   * or with `config.portal.enabled` off — no login is offered.
+   */
+  actions?: Pick<PortalActions, 'startLogin' | 'startVipps'>;
+  /** How many days the window covers. Default `config.window.rangeDays`. */
+  rangeDays?: number;
+  /**
+   * The site's origin (`https://…`), so the manage links inside the calendar
+   * file are absolute. Absent, they stay root-relative.
+   */
+  siteUrl?: string;
+  /** A monitoring tap: the step the visitor is on, and a submission's outcome. */
+  onEvent?: (event: BookingWizardEvent) => void;
+}
+type BookingGuardianProp = Parameters<typeof useBooking>[0]['guardian'];
+export type BookingWizardEvent = {
+  type: 'step';
+  step: WizardStep | 'confirmed';
+} | {
+  type: 'submit_ok';
+  bookings: number;
+} | {
+  type: 'submit_error';
+  code: NonNullable<WizardState['error']>;
+};
+/**
+ * The wizard, behind its own Suspense boundary: `useSearchParams` throws to
+ * the nearest one during a static prerender, and without ours that is the
+ * root layout's — the whole page would ship empty until hydration.
+ */
+export declare function BookingWizard(props: BookingWizardProps): import("react").JSX.Element;
+//#endregion
+//# sourceMappingURL=BookingWizard.d.mts.map