@forgebuild/sidon-booking-widget 0.4.17 → 1.2.0

package/dist/astro-proxy.d.ts

@@ -0,0 +1,44 @@
+/** One OTA API key, or `{ [slug]: key }` for a site serving marinas on several properties. */
+export type MarinaKeys = string | Record<string, string>;
+export interface MarinaProxyOptions<C extends AstroLikeContext = AstroLikeContext> {
+    /** OTA origin, e.g. `https://ota.example.com`. */
+    otaBaseUrl: string;
+    /** Site rail: one key or slug → key. Give this or `auth`. */
+    keys?: MarinaKeys;
+    /** Staff rail: upstream credential headers for this request; null → 401 {error:'Not signed in'}. */
+    auth?: MarinaProxyAuth<C>;
+    /** Upstream timeout; Render cold starts can take most of a minute. */
+    timeoutMs?: number;
+}
+export interface AstroLikeContext {
+    request: Request;
+    params: Record<string, string | undefined>;
+    readonly clientAddress: string;
+}
+export type AstroLikeRoute = (context: AstroLikeContext) => Promise<Response>;
+export type MarinaProxyAuth<C extends AstroLikeContext = AstroLikeContext> = (context: C, slug: string) => Promise<Record<string, string> | null> | Record<string, string> | null;
+export declare function createMarinaProxy<C extends AstroLikeContext = AstroLikeContext>({ otaBaseUrl, keys, auth, timeoutMs, }: MarinaProxyOptions<C>): (context: C) => Promise<Response>;
+export interface MarinaClientOptions {
+    /** OTA origin, e.g. `https://ota.example.com`. */
+    otaBaseUrl: string;
+    keys: MarinaKeys;
+    /** Waits between 429 retries; injectable so the check doesn't really sleep. */
+    sleep?: (ms: number) => Promise<void>;
+    /** Per attempt, default 30000: a hung OTA must fail an SSR page, not hold it open. */
+    timeoutMs?: number;
+}
+export declare class MarinaClientError extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+export declare function createMarinaClient({ otaBaseUrl, keys, sleep, timeoutMs, }: MarinaClientOptions): {
+    /** The configured slugs (`[]` for a single key): a multi-marina site's "other marinas". */
+    slugs: string[];
+    /** `GET /api/marina/guest/:slug[?from&to]`: the map payload, or null. */
+    getMarina: (slug: string, range?: {
+        from: string;
+        to: string;
+    }) => Promise<any>;
+    /** `GET /api/marina/guest/:slug/doc-requirements`: OTA's bare array, or null. */
+    getDocRequirements: (slug: string) => Promise<any[] | null>;
+};

package/dist/astro-proxy.js

@@ -0,0 +1,205 @@
+// Server-side half of the widget: an Astro route that relays the browser's
+// /api/marina/guest/* calls to OTA with the site's API key (or, in the OTA
+// dashboard, the signed-in staff member's credentials), so no credential
+// ever reaches the page. Consumers mount it at
+// src/pages/api/marina/guest/[...path].ts.
+//
+// Deliberately one self-contained file: tsc emits it to dist/ unbundled and
+// Astro SSR loads it from node_modules, so a relative runtime import (which
+// would be extensionless) or a node: import (edge runtimes) would break it.
+// Erasable TS only, so scripts/check-astro-proxy.ts runs it under Node's
+// type stripping with no build step. Never import the element entries here:
+// they call customElements.define at import time, which throws on a server.
+const GUEST_PREFIX = '/api/marina/guest/';
+// Vercel's function body limit; OTA's own upload cap (4 MiB) is stricter.
+const MAX_BODY_BYTES = 4_500_000;
+const REQUEST_HEADERS = ['content-type', 'x-file-name', 'x-booking-token', 'user-agent'];
+// Never content-encoding/content-length: Node's fetch has already decoded
+// the body but keeps those headers. Never set-cookie or location.
+const RESPONSE_HEADERS = ['content-type', 'cache-control', 'retry-after', 'ratelimit'];
+// Astro has already percent-decoded params.path (repeatedly, in 6.4+), so a
+// `%` left over, a backslash or a control character is an evasion attempt.
+const BAD_SEGMENT = /[\\%\u0000-\u001f\u007f]/;
+function jsonError(status, error) {
+    return new Response(JSON.stringify({ error }), {
+        status,
+        headers: { 'content-type': 'application/json; charset=utf-8' },
+    });
+}
+// Own-property lookup: a slug like `constructor` must not resolve to
+// Object.prototype's function and be sent as a key.
+function keyFor(keys, slug) {
+    if (typeof keys === 'string')
+        return keys || null;
+    return keys && Object.hasOwn(keys, slug) ? keys[slug] || null : null;
+}
+// Astro's getter throws (ClientAddressNotAvailable) on adapters without
+// one; OTA then rate-limits the request in its per-property bucket.
+function clientIp(context) {
+    try {
+        return context.clientAddress || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function createMarinaProxy({ otaBaseUrl, keys, auth, timeoutMs = 60_000, }) {
+    // Fail at startup: with both, which credential reaches OTA is a guess; with
+    // neither (e.g. OTA_API_KEY unset) every request would 404 like "no such marina".
+    if ((keys === undefined) === (auth === undefined)) {
+        throw new Error('createMarinaProxy: give exactly one of keys or auth');
+    }
+    return async (context) => {
+        const { request } = context;
+        // Astro dispatches HEAD to the GET export; OTA only needs to see GET.
+        const method = request.method === 'HEAD' ? 'GET' : request.method;
+        if (method !== 'GET' && method !== 'POST')
+            return jsonError(404, 'Not found');
+        const path = context.params.path ?? '';
+        const segments = path.split('/');
+        if (segments.some((s) => s === '' || s === '.' || s === '..' || BAD_SEGMENT.test(s))) {
+            return jsonError(404, 'Not found');
+        }
+        // Belt and braces: whatever the guard missed, the resolved URL must still
+        // sit under the guest prefix — the API key and a staff bearer also open
+        // staff routes.
+        const url = new URL(GUEST_PREFIX + path, otaBaseUrl);
+        if (!url.pathname.startsWith(GUEST_PREFIX))
+            return jsonError(404, 'Not found');
+        url.search = new URL(request.url).search;
+        // After the path checks, so a rejected path never costs a token mint.
+        let credentials;
+        if (auth) {
+            const fromAuth = await auth(context, segments[0]);
+            if (!fromAuth)
+                return jsonError(401, 'Not signed in');
+            credentials = fromAuth;
+        }
+        else {
+            const key = keyFor(keys, segments[0]);
+            if (!key)
+                return jsonError(404, 'Not found');
+            credentials = { 'x-api-key': key };
+        }
+        let body;
+        if (method === 'POST') {
+            if (Number(request.headers.get('content-length')) > MAX_BODY_BYTES) {
+                return jsonError(413, 'Request body too large');
+            }
+            // Buffered rather than streamed: Node's fetch rejects a stream body
+            // without duplex:'half', and a buffer gives OTA a Content-Length.
+            // ponytail: a chunked body is read fully before this check; Vercel caps
+            // it at 4.5 MB before we run, count bytes off the stream if self-hosted.
+            body = await request.arrayBuffer();
+            if (body.byteLength > MAX_BODY_BYTES)
+                return jsonError(413, 'Request body too large');
+        }
+        // Built from scratch, so cookies, Authorization, X-Forwarded-For and any
+        // inbound X-Client-Ip / X-Api-Key / X-Property-Id never reach OTA. The
+        // credentials go on after the allowlist so nothing inbound can shadow them.
+        const headers = new Headers();
+        for (const name of REQUEST_HEADERS) {
+            const value = request.headers.get(name);
+            if (value !== null)
+                headers.set(name, value);
+        }
+        for (const [name, value] of Object.entries(credentials))
+            headers.set(name, value);
+        const ip = clientIp(context);
+        if (ip)
+            headers.set('x-client-ip', ip);
+        let upstream;
+        try {
+            upstream = await fetch(url, {
+                method,
+                headers,
+                body,
+                redirect: 'manual',
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+        }
+        catch (err) {
+            // Caught here because a throw renders Astro's HTML 500 page, which the
+            // widget can't parse.
+            if (err?.name === 'TimeoutError')
+                return jsonError(504, 'Booking service timed out');
+            return jsonError(502, 'Booking service unavailable');
+        }
+        // OTA's guest routes never redirect; a 3xx is infrastructure (e.g. an
+        // http→https hop) and its Location must not reach the browser.
+        if (upstream.status >= 300 && upstream.status < 400)
+            return jsonError(502, 'Booking service unavailable');
+        const out = new Headers();
+        upstream.headers.forEach((value, name) => {
+            if (RESPONSE_HEADERS.includes(name) || name.startsWith('ratelimit-'))
+                out.set(name, value);
+        });
+        // Always a new Response: a fetch() Response's headers are immutable and
+        // Clerk's middleware appends to them, which would throw.
+        return new Response(upstream.body, { status: upstream.status, headers: out });
+    };
+}
+export class MarinaClientError extends Error {
+    // A declared field, not a `public status` parameter property: those
+    // aren't erasable, and Node's type stripping runs this file as-is.
+    status;
+    constructor(message, status) {
+        super(message);
+        this.name = 'MarinaClientError';
+        this.status = status;
+    }
+}
+// Returns OTA's raw JSON (snake_case, NUMERIC columns as strings): each site
+// maps the few fields it reads; the widget adapts its own copy. No cache:
+// sites wrap this in theirs, and SSR availability must stay fresh.
+export function createMarinaClient({ otaBaseUrl, keys, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), timeoutMs = 30_000, }) {
+    // Fail at startup: an unset OTA_API_KEY must not read as "no such marina".
+    if (!otaBaseUrl || !keys)
+        throw new Error('createMarinaClient: otaBaseUrl and keys are required');
+    // null = no such marina (OTA 404, or a slug outside the keys map), so a page can 404.
+    async function get(slug, suffix, query = '') {
+        const key = keyFor(keys, slug);
+        // '.' / '..' survive encodeURIComponent and would resolve out of /guest/, key attached.
+        if (!key || slug === '' || slug === '.' || slug === '..')
+            return null;
+        const url = new URL(GUEST_PREFIX + encodeURIComponent(slug) + suffix + query, otaBaseUrl);
+        // Build-time reads carry no X-Client-Ip, so a whole prerender shares one
+        // 100/min bucket per key: wait out a 429 rather than fail the build.
+        for (let retry = 0;; retry++) {
+            let res;
+            try {
+                res = await fetch(url, { headers: { 'x-api-key': key }, signal: AbortSignal.timeout(timeoutMs) });
+            }
+            catch (err) {
+                // The forwarder's statuses, so a page handles both the same way; a
+                // raw DOMException / TypeError would otherwise escape as a 500.
+                if (err?.name === 'TimeoutError')
+                    throw new MarinaClientError('Booking service timed out', 504);
+                throw new MarinaClientError('Booking service unavailable', 502);
+            }
+            if (res.status === 429 && retry < 3) {
+                await res.body?.cancel(); // free the connection while we wait
+                // NaN when absent or an HTTP-date; OTA's limiter sends seconds.
+                const secs = parseInt(res.headers.get('retry-after') ?? '', 10);
+                await sleep(Math.min(secs >= 0 ? secs : 5, 30) * 1000);
+                continue;
+            }
+            if (res.status === 404)
+                return null;
+            if (!res.ok) {
+                // OTA errors are {error}; an edge / proxy error page may not be JSON at all.
+                const body = await res.json().catch(() => null);
+                throw new MarinaClientError(typeof body?.error === 'string' ? body.error : `OTA request failed (${res.status})`, res.status);
+            }
+            return res.json();
+        }
+    }
+    return {
+        /** The configured slugs (`[]` for a single key): a multi-marina site's "other marinas". */
+        slugs: typeof keys === 'string' ? [] : Object.keys(keys),
+        /** `GET /api/marina/guest/:slug[?from&to]`: the map payload, or null. */
+        getMarina: (slug, range) => get(slug, '', range ? `?${new URLSearchParams({ from: range.from, to: range.to })}` : ''),
+        /** `GET /api/marina/guest/:slug/doc-requirements`: OTA's bare array, or null. */
+        getDocRequirements: (slug) => get(slug, '/doc-requirements'),
+    };
+}

package/dist/custom-element-berth-map.d.ts

@@ -1 +1 @@
-export { }
+export * from './elements.js';

package/dist/custom-element.d.ts

@@ -1 +1 @@
-export { }
+export * from './elements.js';

package/dist/elements.d.ts

@@ -0,0 +1,118 @@
+// Hand-written typings for <sidon-booking-widget> and <sidon-berth-map>.
+// The entry modules only register the elements (side-effect imports), so
+// generated declarations come out as an empty `export {}`. The build copies
+// this file verbatim to dist/elements.d.ts and both entry .d.ts files
+// re-export it (scripts/write-element-types.mjs), which is why it imports
+// nothing: a relative import would dangle in dist/.
+//
+// Keep it in step with the `props` blocks in BookingWidget.svelte and
+// BerthMap.svelte and the events they emit. `npm run check` skips .d.ts
+// files (skipLibCheck), so check an edit with:
+//   npx tsc --ignoreConfig --noEmit --skipLibCheck false --lib es2023,dom src/elements.d.ts
+
+/** Peer-marina logo pin. Mirrors OtherMarina in lib/types.ts. */
+export interface OtherMarina {
+  name: string;
+  lat: number;
+  lng: number;
+  logoMark: string | null;
+  /** Always host-supplied: the package owns no site's routing. */
+  href: string | null;
+}
+
+/** OTA booking status. An expired booking reports `cancelled`. */
+export type SidonBookingStatus = 'hold' | 'pending' | 'confirmed' | 'declined' | 'cancelled';
+
+export interface SidonStepChangeDetail { step: 1 | 2 | 3 }
+/** The booking widget fires this from the wizard only, never in booking-page mode. */
+export interface SidonLoaChangeDetail { loa: number }
+/** `bookingId` is OTA's booking UUID, `marina` the marina slug. */
+export interface SidonBookedDetail { bookingId: string; marina: string }
+export interface SidonBookingStatusDetail { bookingId: string; status: SidonBookingStatus }
+/** A berth label, or null when deselected. */
+export interface SidonBerthSelectedDetail { berthId: string | null }
+/** Dates are `YYYY-MM-DD`; `berth` is a berth label. */
+export interface SidonQuickbookSubmitDetail { from: string | null; to: string | null; length: number; berth: string | null }
+
+// Element properties mirror the attributes, camelCased; optional like them.
+export interface SidonBookingWidgetElement extends HTMLElement {
+  /** OTA marina slug. */
+  marina?: string;
+  /** '' (default) = this page's origin, where the forwarder route lives. */
+  apiOrigin?: string;
+  from?: string;
+  to?: string;
+  length?: number;
+  berth?: string;
+  /** en/it/fr/es (first two letters). Unset: the wizard is English and the
+      booking page follows the booking's own locale. */
+  locale?: string;
+  currencySymbol?: string;
+  variant?: 'navy' | 'dark';
+  /** Present (even empty) = booking-page mode; a value overrides `?booking=`. */
+  bookingId?: string | null;
+  mapsApiKey?: string;
+  mapStyle?: 'chart' | 'coastal';
+  mapHeight?: string;
+  mapWidth?: string;
+  mapGap?: string;
+  width?: string;
+  logoMark?: string | null;
+  marinaName?: string;
+  otherMarinas?: OtherMarina[];
+}
+
+export interface SidonBerthMapElement extends HTMLElement {
+  /** OTA marina slug. */
+  marina?: string;
+  mapsApiKey?: string;
+  /** '' (default) = this page's origin, where the forwarder route lives. */
+  apiOrigin?: string;
+  mapStyle?: 'chart' | 'coastal';
+  locale?: string;
+  currencySymbol?: string;
+  from?: string;
+  to?: string;
+  length?: number;
+  berth?: string;
+  /** 'staff' (the OTA dashboard): every listed berth is clickable and fires
+      sidon-berth-selected, occupied berths are painted for [from, to), and
+      from/to follow their attributes. No card, availability or boat-length
+      checks. Default 'guest'. */
+  mode?: 'guest' | 'staff';
+  /** Re-reads the map payload. Undefined until the element has mounted
+      (a microtask after it is connected), so call `el.refresh?.()`. */
+  readonly refresh?: () => void;
+  bookPath?: string;
+  logoMark?: string | null;
+  marinaName?: string;
+  otherMarinas?: OtherMarina[];
+  mapHeight?: string;
+  showWeather?: boolean;
+  eyebrow?: string;
+  cardTitle?: string;
+  intro?: string;
+  rangeLabel?: string;
+  rangePlaceholder?: string;
+  lengthLabel?: string;
+  selectedLabel?: string;
+  selectedPlaceholder?: string;
+  ctaLabel?: string;
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'sidon-booking-widget': SidonBookingWidgetElement;
+    'sidon-berth-map': SidonBerthMapElement;
+  }
+  // Dispatched with bubbles + composed, so listeners on any ancestor
+  // element get the typed detail too.
+  interface HTMLElementEventMap {
+    'sidon-step-change': CustomEvent<SidonStepChangeDetail>;
+    'sidon-loa-change': CustomEvent<SidonLoaChangeDetail>;
+    'sidon-booked': CustomEvent<SidonBookedDetail>;
+    'sidon-booking-status': CustomEvent<SidonBookingStatusDetail>;
+    'sidon-berth-selected': CustomEvent<SidonBerthSelectedDetail>;
+    'sidon-quickbook-submit': CustomEvent<SidonQuickbookSubmitDetail>;
+  }
+}